1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110#ifndef _LARGEFILE64_SOURCE
111
112# define _LARGEFILE64_SOURCE
113#endif
114#include <assert.h>
115#include <sys/mount.h>
116#if !defined(BLKSSZGET)
117# define BLKSSZGET _IO(0x12, 104)
118#endif
119#if !defined(BLKGETSIZE64)
120# define BLKGETSIZE64 _IOR(0x12,114,size_t)
121#endif
122#include "libbb.h"
123#include "unicode.h"
124
125#if BB_LITTLE_ENDIAN
126# define inline_if_little_endian ALWAYS_INLINE
127#else
128# define inline_if_little_endian
129#endif
130
131
132
133#ifndef ENABLE_FEATURE_FDISK_BLKSIZE
134# define ENABLE_FEATURE_FDISK_BLKSIZE 0
135# define IF_FEATURE_FDISK_BLKSIZE(a)
136#endif
137
138#define DEFAULT_SECTOR_SIZE 512
139#define DEFAULT_SECTOR_SIZE_STR "512"
140#define MAX_SECTOR_SIZE 2048
141#define SECTOR_SIZE 512
142#define MAXIMUM_PARTS 60
143
144#define ACTIVE_FLAG 0x80
145
146#define EXTENDED 0x05
147#define WIN98_EXTENDED 0x0f
148#define LINUX_PARTITION 0x81
149#define LINUX_SWAP 0x82
150#define LINUX_NATIVE 0x83
151#define LINUX_EXTENDED 0x85
152#define LINUX_LVM 0x8e
153#define LINUX_RAID 0xfd
154
155
156enum {
157 OPT_b = 1 << 0,
158 OPT_C = 1 << 1,
159 OPT_H = 1 << 2,
160 OPT_l = 1 << 3,
161 OPT_S = 1 << 4,
162 OPT_u = 1 << 5,
163 OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
164};
165
166
167typedef unsigned long long ullong;
168
169
170
171typedef uint32_t sector_t;
172#if UINT_MAX == 0xffffffff
173# define SECT_FMT ""
174#elif ULONG_MAX == 0xffffffff
175# define SECT_FMT "l"
176#else
177# error Cant detect sizeof(uint32_t)
178#endif
179
180struct hd_geometry {
181 unsigned char heads;
182 unsigned char sectors;
183 unsigned short cylinders;
184 unsigned long start;
185};
186
187#define HDIO_GETGEO 0x0301
188
189
190
191static const char msg_building_new_label[] ALIGN1 =
192"Building a new %s. Changes will remain in memory only,\n"
193"until you decide to write them. After that the previous content\n"
194"won't be recoverable.\n\n";
195
196static const char msg_part_already_defined[] ALIGN1 =
197"Partition %u is already defined, delete it before re-adding\n";
198
199
200
201struct partition {
202 unsigned char boot_ind;
203 unsigned char head;
204 unsigned char sector;
205 unsigned char cyl;
206 unsigned char sys_ind;
207 unsigned char end_head;
208 unsigned char end_sector;
209 unsigned char end_cyl;
210 unsigned char start4[4];
211 unsigned char size4[4];
212} PACKED;
213
214
215
216
217
218
219
220
221
222struct pte {
223 struct partition *part_table;
224 struct partition *ext_pointer;
225 sector_t offset_from_dev_start;
226 char *sectorbuffer;
227#if ENABLE_FEATURE_FDISK_WRITABLE
228 char changed;
229#endif
230};
231
232#define unable_to_open "can't open '%s'"
233#define unable_to_read "can't read from %s"
234#define unable_to_seek "can't seek on %s"
235
236enum label_type {
237 LABEL_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF, LABEL_GPT
238};
239
240#define LABEL_IS_DOS (LABEL_DOS == current_label_type)
241
242#if ENABLE_FEATURE_SUN_LABEL
243#define LABEL_IS_SUN (LABEL_SUN == current_label_type)
244#define STATIC_SUN static
245#else
246#define LABEL_IS_SUN 0
247#define STATIC_SUN extern
248#endif
249
250#if ENABLE_FEATURE_SGI_LABEL
251#define LABEL_IS_SGI (LABEL_SGI == current_label_type)
252#define STATIC_SGI static
253#else
254#define LABEL_IS_SGI 0
255#define STATIC_SGI extern
256#endif
257
258#if ENABLE_FEATURE_AIX_LABEL
259#define LABEL_IS_AIX (LABEL_AIX == current_label_type)
260#define STATIC_AIX static
261#else
262#define LABEL_IS_AIX 0
263#define STATIC_AIX extern
264#endif
265
266#if ENABLE_FEATURE_OSF_LABEL
267#define LABEL_IS_OSF (LABEL_OSF == current_label_type)
268#define STATIC_OSF static
269#else
270#define LABEL_IS_OSF 0
271#define STATIC_OSF extern
272#endif
273
274#if ENABLE_FEATURE_GPT_LABEL
275#define LABEL_IS_GPT (LABEL_GPT == current_label_type)
276#define STATIC_GPT static
277#else
278#define LABEL_IS_GPT 0
279#define STATIC_GPT extern
280#endif
281
282enum action { OPEN_MAIN, TRY_ONLY, CREATE_EMPTY_DOS, CREATE_EMPTY_SUN };
283
284static void update_units(void);
285#if ENABLE_FEATURE_FDISK_WRITABLE
286static void change_units(void);
287static void reread_partition_table(int leave);
288static void delete_partition(int i);
289static unsigned get_partition(int warn, unsigned max);
290static void list_types(const char *const *sys);
291static sector_t read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg);
292#endif
293static const char *partition_type(unsigned char type);
294static void get_geometry(void);
295static void read_pte(struct pte *pe, sector_t offset);
296#if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
297static int get_boot(enum action what);
298#else
299static int get_boot(void);
300#endif
301
302#define PLURAL 0
303#define SINGULAR 1
304
305static sector_t get_start_sect(const struct partition *p);
306static sector_t get_nr_sects(const struct partition *p);
307
308
309
310static const char *const i386_sys_types[] = {
311 "\x00" "Empty",
312 "\x01" "FAT12",
313 "\x04" "FAT16 <32M",
314 "\x05" "Extended",
315 "\x06" "FAT16",
316 "\x07" "HPFS/NTFS",
317 "\x0a" "OS/2 Boot Manager",
318 "\x0b" "Win95 FAT32",
319 "\x0c" "Win95 FAT32 (LBA)",
320 "\x0e" "Win95 FAT16 (LBA)",
321 "\x0f" "Win95 Ext'd (LBA)",
322 "\x11" "Hidden FAT12",
323 "\x12" "Compaq diagnostics",
324 "\x14" "Hidden FAT16 <32M",
325 "\x16" "Hidden FAT16",
326 "\x17" "Hidden HPFS/NTFS",
327 "\x1b" "Hidden Win95 FAT32",
328 "\x1c" "Hidden W95 FAT32 (LBA)",
329 "\x1e" "Hidden W95 FAT16 (LBA)",
330 "\x3c" "Part.Magic recovery",
331 "\x41" "PPC PReP Boot",
332 "\x42" "SFS",
333 "\x63" "GNU HURD or SysV",
334 "\x80" "Old Minix",
335 "\x81" "Minix / old Linux",
336 "\x82" "Linux swap",
337 "\x83" "Linux",
338 "\x84" "OS/2 hidden C: drive",
339 "\x85" "Linux extended",
340 "\x86" "NTFS volume set",
341 "\x87" "NTFS volume set",
342 "\x8e" "Linux LVM",
343 "\x9f" "BSD/OS",
344 "\xa0" "Thinkpad hibernation",
345 "\xa5" "FreeBSD",
346 "\xa6" "OpenBSD",
347 "\xa8" "Darwin UFS",
348 "\xa9" "NetBSD",
349 "\xab" "Darwin boot",
350 "\xb7" "BSDI fs",
351 "\xb8" "BSDI swap",
352 "\xbe" "Solaris boot",
353 "\xeb" "BeOS fs",
354 "\xee" "EFI GPT",
355 "\xef" "EFI (FAT-12/16/32)",
356 "\xf0" "Linux/PA-RISC boot",
357 "\xf2" "DOS secondary",
358 "\xfd" "Linux raid autodetect",
359
360
361#if 0
362 "\x02" "XENIX root",
363 "\x03" "XENIX usr",
364 "\x08" "AIX",
365 "\x09" "AIX bootable",
366 "\x10" "OPUS",
367 "\x18" "AST SmartSleep",
368 "\x24" "NEC DOS",
369 "\x39" "Plan 9",
370 "\x40" "Venix 80286",
371 "\x4d" "QNX4.x",
372 "\x4e" "QNX4.x 2nd part",
373 "\x4f" "QNX4.x 3rd part",
374 "\x50" "OnTrack DM",
375 "\x51" "OnTrack DM6 Aux1",
376 "\x52" "CP/M",
377 "\x53" "OnTrack DM6 Aux3",
378 "\x54" "OnTrackDM6",
379 "\x55" "EZ-Drive",
380 "\x56" "Golden Bow",
381 "\x5c" "Priam Edisk",
382 "\x61" "SpeedStor",
383 "\x64" "Novell Netware 286",
384 "\x65" "Novell Netware 386",
385 "\x70" "DiskSecure Multi-Boot",
386 "\x75" "PC/IX",
387 "\x93" "Amoeba",
388 "\x94" "Amoeba BBT",
389 "\xa7" "NeXTSTEP",
390 "\xbb" "Boot Wizard hidden",
391 "\xc1" "DRDOS/sec (FAT-12)",
392 "\xc4" "DRDOS/sec (FAT-16 < 32M)",
393 "\xc6" "DRDOS/sec (FAT-16)",
394 "\xc7" "Syrinx",
395 "\xda" "Non-FS data",
396 "\xdb" "CP/M / CTOS / ...",
397
398 "\xde" "Dell Utility",
399 "\xdf" "BootIt",
400 "\xe1" "DOS access",
401
402 "\xe3" "DOS R/O",
403 "\xe4" "SpeedStor",
404
405 "\xf1" "SpeedStor",
406 "\xf4" "SpeedStor",
407 "\xfe" "LANstep",
408 "\xff" "BBT",
409#endif
410 NULL
411};
412
413enum {
414 dev_fd = 3
415};
416
417
418struct globals {
419 char *line_ptr;
420
421 const char *disk_device;
422 int g_partitions;
423 unsigned units_per_sector;
424 unsigned sector_size;
425 unsigned user_set_sector_size;
426 unsigned sector_offset;
427 unsigned g_heads, g_sectors, g_cylinders;
428 smallint current_label_type;
429 smallint display_in_cyl_units;
430#if ENABLE_FEATURE_OSF_LABEL
431 smallint possibly_osf_label;
432#endif
433
434 smallint listing;
435 smallint dos_compatible_flag;
436#if ENABLE_FEATURE_FDISK_WRITABLE
437
438 smallint nowarn;
439#endif
440 int ext_index;
441 unsigned user_cylinders, user_heads, user_sectors;
442 unsigned pt_heads, pt_sectors;
443 unsigned kern_heads, kern_sectors;
444 sector_t extended_offset;
445 sector_t total_number_of_sectors;
446
447 jmp_buf listingbuf;
448 char line_buffer[80];
449
450
451 char MBRbuffer[MAX_SECTOR_SIZE];
452
453 struct pte ptes[MAXIMUM_PARTS];
454};
455#define G (*ptr_to_globals)
456#define line_ptr (G.line_ptr )
457#define disk_device (G.disk_device )
458#define g_partitions (G.g_partitions )
459#define units_per_sector (G.units_per_sector )
460#define sector_size (G.sector_size )
461#define user_set_sector_size (G.user_set_sector_size)
462#define sector_offset (G.sector_offset )
463#define g_heads (G.g_heads )
464#define g_sectors (G.g_sectors )
465#define g_cylinders (G.g_cylinders )
466#define current_label_type (G.current_label_type )
467#define display_in_cyl_units (G.display_in_cyl_units)
468#define possibly_osf_label (G.possibly_osf_label )
469#define listing (G.listing )
470#define dos_compatible_flag (G.dos_compatible_flag )
471#define nowarn (G.nowarn )
472#define ext_index (G.ext_index )
473#define user_cylinders (G.user_cylinders )
474#define user_heads (G.user_heads )
475#define user_sectors (G.user_sectors )
476#define pt_heads (G.pt_heads )
477#define pt_sectors (G.pt_sectors )
478#define kern_heads (G.kern_heads )
479#define kern_sectors (G.kern_sectors )
480#define extended_offset (G.extended_offset )
481#define total_number_of_sectors (G.total_number_of_sectors)
482#define listingbuf (G.listingbuf )
483#define line_buffer (G.line_buffer )
484#define MBRbuffer (G.MBRbuffer )
485#define ptes (G.ptes )
486#define INIT_G() do { \
487 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
488 sector_size = DEFAULT_SECTOR_SIZE; \
489 sector_offset = 1; \
490 g_partitions = 4; \
491 units_per_sector = 1; \
492 dos_compatible_flag = 1; \
493} while (0)
494
495
496
497
498
499
500static sector_t bb_BLKGETSIZE_sectors(int fd)
501{
502 uint64_t v64;
503 unsigned long longsectors;
504
505 if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
506
507 v64 >>= 9;
508 if (v64 != (sector_t)v64) {
509 ret_trunc:
510
511
512
513
514 bb_error_msg("device has more than 2^32 sectors, can't use all of them");
515 v64 = (uint32_t)-1L;
516 }
517 return v64;
518 }
519
520 if (ioctl(fd, BLKGETSIZE, &longsectors)) {
521
522 off_t sz = lseek(fd, 0, SEEK_END);
523 longsectors = 0;
524 if (sz > 0)
525 longsectors = (uoff_t)sz / sector_size;
526 lseek(fd, 0, SEEK_SET);
527 }
528 if (sizeof(long) > sizeof(sector_t)
529 && longsectors != (sector_t)longsectors
530 ) {
531 goto ret_trunc;
532 }
533 return longsectors;
534}
535
536
537#define IS_EXTENDED(i) \
538 ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
539
540#define cround(n) (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
541
542#define scround(x) (((x)+units_per_sector-1)/units_per_sector)
543
544#define pt_offset(b, n) \
545 ((struct partition *)((b) + 0x1be + (n) * sizeof(struct partition)))
546
547#define sector(s) ((s) & 0x3f)
548
549#define cylinder(s, c) ((c) | (((s) & 0xc0) << 2))
550
551static void
552close_dev_fd(void)
553{
554
555 xmove_fd(xopen(bb_dev_null, O_RDONLY), dev_fd);
556}
557
558
559static const char *
560partname(const char *dev, int pno, int lth)
561{
562 const char *p;
563 int w, wp;
564 int bufsiz;
565 char *bufp;
566
567 bufp = auto_string(xzalloc(80));
568 bufsiz = 80;
569
570 w = strlen(dev);
571 p = "";
572
573 if (isdigit(dev[w-1]))
574 p = "p";
575
576
577
578 if (strcmp(dev + w - 4, "disc") == 0) {
579 w -= 4;
580 p = "part";
581 }
582
583 wp = strlen(p);
584
585 if (lth) {
586 snprintf(bufp, bufsiz, "%*.*s%s%-2u",
587 lth-wp-2, w, dev, p, pno);
588 } else {
589 snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
590 }
591 return bufp;
592}
593
594static ALWAYS_INLINE struct partition *
595get_part_table(int i)
596{
597 return ptes[i].part_table;
598}
599
600static const char *
601str_units(int n)
602{
603 if (n == 1)
604 return display_in_cyl_units ? "cylinder" : "sector";
605 return display_in_cyl_units ? "cylinders" : "sectors";
606}
607
608static int
609valid_part_table_flag(const char *mbuffer)
610{
611 return (mbuffer[510] == 0x55 && (uint8_t)mbuffer[511] == 0xaa);
612}
613
614static void fdisk_fatal(const char *why)
615{
616 if (listing) {
617 close_dev_fd();
618 longjmp(listingbuf, 1);
619 }
620 bb_error_msg_and_die(why, disk_device);
621}
622
623static void
624seek_sector(sector_t secno)
625{
626#if ENABLE_FDISK_SUPPORT_LARGE_DISKS
627 off64_t off = (off64_t)secno * sector_size;
628 if (lseek64(dev_fd, off, SEEK_SET) == (off64_t) -1)
629 fdisk_fatal(unable_to_seek);
630#else
631 uint64_t off = (uint64_t)secno * sector_size;
632 if (off > MAXINT(off_t)
633 || lseek(dev_fd, (off_t)off, SEEK_SET) == (off_t) -1
634 ) {
635 fdisk_fatal(unable_to_seek);
636 }
637#endif
638}
639
640#if ENABLE_FEATURE_FDISK_WRITABLE
641static void
642set_all_unchanged(void)
643{
644 int i;
645
646 for (i = 0; i < MAXIMUM_PARTS; i++)
647 ptes[i].changed = 0;
648}
649
650static ALWAYS_INLINE void
651set_changed(int i)
652{
653 ptes[i].changed = 1;
654}
655
656static ALWAYS_INLINE void
657write_part_table_flag(char *b)
658{
659 b[510] = 0x55;
660 b[511] = 0xaa;
661}
662
663
664static int
665read_line(const char *prompt)
666{
667 int sz;
668
669 sz = read_line_input(NULL, prompt, line_buffer, sizeof(line_buffer));
670 if (sz <= 0)
671 exit(EXIT_SUCCESS);
672
673 if (line_buffer[sz-1] == '\n')
674 line_buffer[--sz] = '\0';
675
676 line_ptr = line_buffer;
677 while (*line_ptr != '\0' && (unsigned char)*line_ptr <= ' ')
678 line_ptr++;
679 return *line_ptr;
680}
681
682static char
683read_nonempty(const char *mesg)
684{
685 while (!read_line(mesg))
686 continue;
687 return *line_ptr;
688}
689
690static char
691read_maybe_empty(const char *mesg)
692{
693 if (!read_line(mesg)) {
694 line_ptr = line_buffer;
695 line_ptr[0] = '\n';
696 line_ptr[1] = '\0';
697 }
698 return line_ptr[0];
699}
700
701static int
702read_hex(const char *const *sys)
703{
704 unsigned long v;
705 while (1) {
706 read_nonempty("Hex code (type L to list codes): ");
707 if ((line_ptr[0] | 0x20) == 'l') {
708 list_types(sys);
709 continue;
710 }
711 v = bb_strtoul(line_ptr, NULL, 16);
712 if (v <= 0xff)
713 return v;
714 }
715}
716
717static void
718write_sector(sector_t secno, const void *buf)
719{
720 seek_sector(secno);
721 xwrite(dev_fd, buf, sector_size);
722}
723#endif
724
725
726#include "fdisk_aix.c"
727
728struct sun_partition {
729 unsigned char info[128];
730 unsigned char spare0[14];
731 struct sun_info {
732 unsigned char spare1;
733 unsigned char id;
734 unsigned char spare2;
735 unsigned char flags;
736 } infos[8];
737 unsigned char spare1[246];
738 unsigned short rspeed;
739 unsigned short pcylcount;
740 unsigned short sparecyl;
741 unsigned char spare2[4];
742 unsigned short ilfact;
743 unsigned short ncyl;
744 unsigned short nacyl;
745 unsigned short ntrks;
746 unsigned short nsect;
747 unsigned char spare3[4];
748 struct sun_partinfo {
749 uint32_t start_cylinder;
750 uint32_t num_sectors;
751 } partitions[8];
752 unsigned short magic;
753 unsigned short csum;
754} FIX_ALIASING;
755typedef struct sun_partition sun_partition;
756#define sunlabel ((sun_partition *)MBRbuffer)
757STATIC_OSF void bsd_select(void);
758STATIC_OSF void xbsd_print_disklabel(int);
759#include "fdisk_osf.c"
760
761STATIC_GPT void gpt_list_table(int xtra);
762#include "fdisk_gpt.c"
763
764#if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL
765static uint16_t
766fdisk_swap16(uint16_t x)
767{
768 return (x << 8) | (x >> 8);
769}
770
771static uint32_t
772fdisk_swap32(uint32_t x)
773{
774 return (x << 24) |
775 ((x & 0xFF00) << 8) |
776 ((x & 0xFF0000) >> 8) |
777 (x >> 24);
778}
779#endif
780
781STATIC_SGI const char *const sgi_sys_types[];
782STATIC_SGI unsigned sgi_get_num_sectors(int i);
783STATIC_SGI int sgi_get_sysid(int i);
784STATIC_SGI void sgi_delete_partition(int i);
785STATIC_SGI void sgi_change_sysid(int i, int sys);
786STATIC_SGI void sgi_list_table(int xtra);
787#if ENABLE_FEATURE_FDISK_ADVANCED
788STATIC_SGI void sgi_set_xcyl(void);
789#endif
790STATIC_SGI int verify_sgi(int verbose);
791STATIC_SGI void sgi_add_partition(int n, int sys);
792STATIC_SGI void sgi_set_swappartition(int i);
793STATIC_SGI const char *sgi_get_bootfile(void);
794STATIC_SGI void sgi_set_bootfile(const char* aFile);
795STATIC_SGI void create_sgiinfo(void);
796STATIC_SGI void sgi_write_table(void);
797STATIC_SGI void sgi_set_bootpartition(int i);
798#include "fdisk_sgi.c"
799
800STATIC_SUN const char *const sun_sys_types[];
801STATIC_SUN void sun_delete_partition(int i);
802STATIC_SUN void sun_change_sysid(int i, int sys);
803STATIC_SUN void sun_list_table(int xtra);
804STATIC_SUN void add_sun_partition(int n, int sys);
805#if ENABLE_FEATURE_FDISK_ADVANCED
806STATIC_SUN void sun_set_alt_cyl(void);
807STATIC_SUN void sun_set_ncyl(int cyl);
808STATIC_SUN void sun_set_xcyl(void);
809STATIC_SUN void sun_set_ilfact(void);
810STATIC_SUN void sun_set_rspeed(void);
811STATIC_SUN void sun_set_pcylcount(void);
812#endif
813STATIC_SUN void toggle_sunflags(int i, unsigned char mask);
814STATIC_SUN void verify_sun(void);
815STATIC_SUN void sun_write_table(void);
816#include "fdisk_sun.c"
817
818
819static inline_if_little_endian unsigned
820read4_little_endian(const unsigned char *cp)
821{
822 uint32_t v;
823 move_from_unaligned32(v, cp);
824 return SWAP_LE32(v);
825}
826
827static sector_t
828get_start_sect(const struct partition *p)
829{
830 return read4_little_endian(p->start4);
831}
832
833static sector_t
834get_nr_sects(const struct partition *p)
835{
836 return read4_little_endian(p->size4);
837}
838
839#if ENABLE_FEATURE_FDISK_WRITABLE
840
841
842static inline_if_little_endian void
843store4_little_endian(unsigned char *cp, unsigned val)
844{
845 uint32_t v = SWAP_LE32(val);
846 move_to_unaligned32(cp, v);
847}
848
849static void
850set_start_sect(struct partition *p, unsigned start_sect)
851{
852 store4_little_endian(p->start4, start_sect);
853}
854
855static void
856set_nr_sects(struct partition *p, unsigned nr_sects)
857{
858 store4_little_endian(p->size4, nr_sects);
859}
860#endif
861
862
863static void
864read_pte(struct pte *pe, sector_t offset)
865{
866 pe->offset_from_dev_start = offset;
867 pe->sectorbuffer = xzalloc(sector_size);
868 seek_sector(offset);
869
870 if (full_read(dev_fd, pe->sectorbuffer, sector_size) != sector_size)
871 fdisk_fatal(unable_to_read);
872#if ENABLE_FEATURE_FDISK_WRITABLE
873 pe->changed = 0;
874#endif
875 pe->part_table = pe->ext_pointer = NULL;
876}
877
878static sector_t
879get_partition_start_from_dev_start(const struct pte *pe)
880{
881 return pe->offset_from_dev_start + get_start_sect(pe->part_table);
882}
883
884#if ENABLE_FEATURE_FDISK_WRITABLE
885
886
887
888
889
890
891#ifdef UNUSED
892static int
893is_dos_partition(int t)
894{
895 return (t == 1 || t == 4 || t == 6 ||
896 t == 0x0b || t == 0x0c || t == 0x0e ||
897 t == 0x11 || t == 0x12 || t == 0x14 || t == 0x16 ||
898 t == 0x1b || t == 0x1c || t == 0x1e || t == 0x24 ||
899 t == 0xc1 || t == 0xc4 || t == 0xc6);
900}
901#endif
902
903static void
904menu(void)
905{
906 puts("Command Action");
907 if (LABEL_IS_SUN) {
908 puts("a\ttoggle a read only flag");
909 puts("b\tedit bsd disklabel");
910 puts("c\ttoggle the mountable flag");
911 puts("d\tdelete a partition");
912 puts("l\tlist known partition types");
913 puts("n\tadd a new partition");
914 puts("o\tcreate a new empty DOS partition table");
915 puts("p\tprint the partition table");
916 puts("q\tquit without saving changes");
917 puts("s\tcreate a new empty Sun disklabel");
918 puts("t\tchange a partition's system id");
919 puts("u\tchange display/entry units");
920 puts("v\tverify the partition table");
921 puts("w\twrite table to disk and exit");
922#if ENABLE_FEATURE_FDISK_ADVANCED
923 puts("x\textra functionality (experts only)");
924#endif
925 } else if (LABEL_IS_SGI) {
926 puts("a\tselect bootable partition");
927 puts("b\tedit bootfile entry");
928 puts("c\tselect sgi swap partition");
929 puts("d\tdelete a partition");
930 puts("l\tlist known partition types");
931 puts("n\tadd a new partition");
932 puts("o\tcreate a new empty DOS partition table");
933 puts("p\tprint the partition table");
934 puts("q\tquit without saving changes");
935 puts("s\tcreate a new empty Sun disklabel");
936 puts("t\tchange a partition's system id");
937 puts("u\tchange display/entry units");
938 puts("v\tverify the partition table");
939 puts("w\twrite table to disk and exit");
940 } else if (LABEL_IS_AIX) {
941 puts("o\tcreate a new empty DOS partition table");
942 puts("q\tquit without saving changes");
943 puts("s\tcreate a new empty Sun disklabel");
944 } else if (LABEL_IS_GPT) {
945 puts("o\tcreate a new empty DOS partition table");
946 puts("p\tprint the partition table");
947 puts("q\tquit without saving changes");
948 puts("s\tcreate a new empty Sun disklabel");
949 } else {
950 puts("a\ttoggle a bootable flag");
951 puts("b\tedit bsd disklabel");
952 puts("c\ttoggle the dos compatibility flag");
953 puts("d\tdelete a partition");
954 puts("l\tlist known partition types");
955 puts("n\tadd a new partition");
956 puts("o\tcreate a new empty DOS partition table");
957 puts("p\tprint the partition table");
958 puts("q\tquit without saving changes");
959 puts("s\tcreate a new empty Sun disklabel");
960 puts("t\tchange a partition's system id");
961 puts("u\tchange display/entry units");
962 puts("v\tverify the partition table");
963 puts("w\twrite table to disk and exit");
964#if ENABLE_FEATURE_FDISK_ADVANCED
965 puts("x\textra functionality (experts only)");
966#endif
967 }
968}
969#endif
970
971
972#if ENABLE_FEATURE_FDISK_ADVANCED
973static void
974xmenu(void)
975{
976 puts("Command Action");
977 if (LABEL_IS_SUN) {
978 puts("a\tchange number of alternate cylinders");
979 puts("c\tchange number of cylinders");
980 puts("d\tprint the raw data in the partition table");
981 puts("e\tchange number of extra sectors per cylinder");
982 puts("h\tchange number of heads");
983 puts("i\tchange interleave factor");
984 puts("o\tchange rotation speed (rpm)");
985 puts("p\tprint the partition table");
986 puts("q\tquit without saving changes");
987 puts("r\treturn to main menu");
988 puts("s\tchange number of sectors/track");
989 puts("v\tverify the partition table");
990 puts("w\twrite table to disk and exit");
991 puts("y\tchange number of physical cylinders");
992 } else if (LABEL_IS_SGI) {
993 puts("b\tmove beginning of data in a partition");
994 puts("c\tchange number of cylinders");
995 puts("d\tprint the raw data in the partition table");
996 puts("e\tlist extended partitions");
997 puts("g\tcreate an IRIX (SGI) partition table");
998 puts("h\tchange number of heads");
999 puts("p\tprint the partition table");
1000 puts("q\tquit without saving changes");
1001 puts("r\treturn to main menu");
1002 puts("s\tchange number of sectors/track");
1003 puts("v\tverify the partition table");
1004 puts("w\twrite table to disk and exit");
1005 } else if (LABEL_IS_AIX) {
1006 puts("b\tmove beginning of data in a partition");
1007 puts("c\tchange number of cylinders");
1008 puts("d\tprint the raw data in the partition table");
1009 puts("e\tlist extended partitions");
1010 puts("g\tcreate an IRIX (SGI) partition table");
1011 puts("h\tchange number of heads");
1012 puts("p\tprint the partition table");
1013 puts("q\tquit without saving changes");
1014 puts("r\treturn to main menu");
1015 puts("s\tchange number of sectors/track");
1016 puts("v\tverify the partition table");
1017 puts("w\twrite table to disk and exit");
1018 } else {
1019 puts("b\tmove beginning of data in a partition");
1020 puts("c\tchange number of cylinders");
1021 puts("d\tprint the raw data in the partition table");
1022 puts("e\tlist extended partitions");
1023 puts("f\tfix partition order");
1024#if ENABLE_FEATURE_SGI_LABEL
1025 puts("g\tcreate an IRIX (SGI) partition table");
1026#endif
1027 puts("h\tchange number of heads");
1028 puts("p\tprint the partition table");
1029 puts("q\tquit without saving changes");
1030 puts("r\treturn to main menu");
1031 puts("s\tchange number of sectors/track");
1032 puts("v\tverify the partition table");
1033 puts("w\twrite table to disk and exit");
1034 }
1035}
1036#endif
1037
1038#if ENABLE_FEATURE_FDISK_WRITABLE
1039static const char *const *
1040get_sys_types(void)
1041{
1042 return (
1043 LABEL_IS_SUN ? sun_sys_types :
1044 LABEL_IS_SGI ? sgi_sys_types :
1045 i386_sys_types);
1046}
1047#else
1048#define get_sys_types() i386_sys_types
1049#endif
1050
1051static const char *
1052partition_type(unsigned char type)
1053{
1054 int i;
1055 const char *const *types = get_sys_types();
1056
1057 for (i = 0; types[i]; i++)
1058 if ((unsigned char)types[i][0] == type)
1059 return types[i] + 1;
1060
1061 return "Unknown";
1062}
1063
1064static int
1065is_cleared_partition(const struct partition *p)
1066{
1067
1068 const char *cp = (const char *)p;
1069 int cnt = sizeof(*p);
1070 char bits = 0;
1071 while (--cnt >= 0)
1072 bits |= *cp++;
1073 return (bits == 0);
1074}
1075
1076static void
1077clear_partition(struct partition *p)
1078{
1079 if (p)
1080 memset(p, 0, sizeof(*p));
1081}
1082
1083#if ENABLE_FEATURE_FDISK_WRITABLE
1084static int
1085get_sysid(int i)
1086{
1087 return LABEL_IS_SUN ? sunlabel->infos[i].id :
1088 (LABEL_IS_SGI ? sgi_get_sysid(i) :
1089 ptes[i].part_table->sys_ind);
1090}
1091
1092static void
1093list_types(const char *const *sys)
1094{
1095 enum { COLS = 3 };
1096
1097 unsigned last[COLS];
1098 unsigned done, next, size;
1099 int i;
1100
1101 for (size = 0; sys[size]; size++)
1102 continue;
1103
1104 done = 0;
1105 for (i = COLS-1; i >= 0; i--) {
1106 done += (size + i - done) / (i + 1);
1107 last[COLS-1 - i] = done;
1108 }
1109
1110 i = done = next = 0;
1111 do {
1112 printf("%c%2x %-22.22s", i ? ' ' : '\n',
1113 (unsigned char)sys[next][0],
1114 sys[next] + 1);
1115 next = last[i++] + done;
1116 if (i >= COLS || next >= last[i]) {
1117 i = 0;
1118 next = ++done;
1119 }
1120 } while (done < last[0]);
1121 bb_putchar('\n');
1122}
1123
1124#define set_hsc(h, s, c, sector) do \
1125{ \
1126 s = sector % g_sectors + 1; \
1127 sector /= g_sectors; \
1128 h = sector % g_heads; \
1129 sector /= g_heads; \
1130 c = sector & 0xff; \
1131 s |= (sector >> 2) & 0xc0; \
1132} while (0)
1133
1134static void set_hsc_start_end(struct partition *p, sector_t start, sector_t stop)
1135{
1136 if (dos_compatible_flag && (start / (g_sectors * g_heads) > 1023))
1137 start = g_heads * g_sectors * 1024 - 1;
1138 set_hsc(p->head, p->sector, p->cyl, start);
1139
1140 if (dos_compatible_flag && (stop / (g_sectors * g_heads) > 1023))
1141 stop = g_heads * g_sectors * 1024 - 1;
1142 set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
1143}
1144
1145static void
1146set_partition(int i, int doext, sector_t start, sector_t stop, int sysid)
1147{
1148 struct partition *p;
1149 sector_t offset;
1150
1151 if (doext) {
1152 p = ptes[i].ext_pointer;
1153 offset = extended_offset;
1154 } else {
1155 p = ptes[i].part_table;
1156 offset = ptes[i].offset_from_dev_start;
1157 }
1158 p->boot_ind = 0;
1159 p->sys_ind = sysid;
1160 set_start_sect(p, start - offset);
1161 set_nr_sects(p, stop - start + 1);
1162 set_hsc_start_end(p, start, stop);
1163 ptes[i].changed = 1;
1164}
1165#endif
1166
1167static int
1168warn_geometry(void)
1169{
1170 if (g_heads && g_sectors && g_cylinders)
1171 return 0;
1172
1173 printf("Unknown value(s) for:");
1174 if (!g_heads)
1175 printf(" heads");
1176 if (!g_sectors)
1177 printf(" sectors");
1178 if (!g_cylinders)
1179 printf(" cylinders");
1180#if ENABLE_FEATURE_FDISK_WRITABLE
1181 puts(" (settable in the extra functions menu)");
1182#else
1183 bb_putchar('\n');
1184#endif
1185 return 1;
1186}
1187
1188static void
1189update_units(void)
1190{
1191 int cyl_units = g_heads * g_sectors;
1192
1193 if (display_in_cyl_units && cyl_units)
1194 units_per_sector = cyl_units;
1195 else
1196 units_per_sector = 1;
1197}
1198
1199#if ENABLE_FEATURE_FDISK_WRITABLE
1200static void
1201warn_cylinders(void)
1202{
1203 if (LABEL_IS_DOS && g_cylinders > 1024 && !nowarn)
1204 printf("\n"
1205"The number of cylinders for this disk is set to %u.\n"
1206"There is nothing wrong with that, but this is larger than 1024,\n"
1207"and could in certain setups cause problems with:\n"
1208"1) software that runs at boot time (e.g., old versions of LILO)\n"
1209"2) booting and partitioning software from other OSs\n"
1210" (e.g., DOS FDISK, OS/2 FDISK)\n",
1211 g_cylinders);
1212}
1213#endif
1214
1215static void
1216read_extended(int ext)
1217{
1218 int i;
1219 struct pte *pex;
1220 struct partition *p, *q;
1221
1222 ext_index = ext;
1223 pex = &ptes[ext];
1224 pex->ext_pointer = pex->part_table;
1225
1226 p = pex->part_table;
1227 if (!get_start_sect(p)) {
1228 puts("Bad offset in primary extended partition");
1229 return;
1230 }
1231
1232 while (IS_EXTENDED(p->sys_ind)) {
1233 struct pte *pe = &ptes[g_partitions];
1234
1235 if (g_partitions >= MAXIMUM_PARTS) {
1236
1237
1238
1239 struct pte *pre = &ptes[g_partitions - 1];
1240#if ENABLE_FEATURE_FDISK_WRITABLE
1241 printf("Warning: deleting partitions after %u\n",
1242 g_partitions);
1243 pre->changed = 1;
1244#endif
1245 clear_partition(pre->ext_pointer);
1246 return;
1247 }
1248
1249 read_pte(pe, extended_offset + get_start_sect(p));
1250
1251 if (!extended_offset)
1252 extended_offset = get_start_sect(p);
1253
1254 q = p = pt_offset(pe->sectorbuffer, 0);
1255 for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) {
1256 if (IS_EXTENDED(p->sys_ind)) {
1257 if (pe->ext_pointer)
1258 printf("Warning: extra link "
1259 "pointer in partition table"
1260 " %u\n", g_partitions + 1);
1261 else
1262 pe->ext_pointer = p;
1263 } else if (p->sys_ind) {
1264 if (pe->part_table)
1265 printf("Warning: ignoring extra "
1266 "data in partition table"
1267 " %u\n", g_partitions + 1);
1268 else
1269 pe->part_table = p;
1270 }
1271 }
1272
1273
1274 if (!pe->part_table) {
1275 if (q != pe->ext_pointer)
1276 pe->part_table = q;
1277 else
1278 pe->part_table = q + 1;
1279 }
1280 if (!pe->ext_pointer) {
1281 if (q != pe->part_table)
1282 pe->ext_pointer = q;
1283 else
1284 pe->ext_pointer = q + 1;
1285 }
1286
1287 p = pe->ext_pointer;
1288 g_partitions++;
1289 }
1290
1291#if ENABLE_FEATURE_FDISK_WRITABLE
1292
1293 remove:
1294 for (i = 4; i < g_partitions; i++) {
1295 struct pte *pe = &ptes[i];
1296
1297 if (!get_nr_sects(pe->part_table)
1298 && (g_partitions > 5 || ptes[4].part_table->sys_ind)
1299 ) {
1300 printf("Omitting empty partition (%u)\n", i+1);
1301 delete_partition(i);
1302 goto remove;
1303 }
1304 }
1305#endif
1306}
1307
1308#if ENABLE_FEATURE_FDISK_WRITABLE
1309static void
1310create_doslabel(void)
1311{
1312 printf(msg_building_new_label, "DOS disklabel");
1313
1314 current_label_type = LABEL_DOS;
1315#if ENABLE_FEATURE_OSF_LABEL
1316 possibly_osf_label = 0;
1317#endif
1318 g_partitions = 4;
1319
1320 memset(&MBRbuffer[510 - 4*16], 0, 4*16);
1321 write_part_table_flag(MBRbuffer);
1322 extended_offset = 0;
1323 set_all_unchanged();
1324 set_changed(0);
1325 get_boot(CREATE_EMPTY_DOS);
1326}
1327#endif
1328
1329static void
1330get_sectorsize(void)
1331{
1332 if (!user_set_sector_size) {
1333 int arg;
1334 if (ioctl(dev_fd, BLKSSZGET, &arg) == 0)
1335 sector_size = arg;
1336 if (sector_size != DEFAULT_SECTOR_SIZE)
1337 printf("Note: sector size is %u "
1338 "(not " DEFAULT_SECTOR_SIZE_STR ")\n",
1339 sector_size);
1340 }
1341}
1342
1343static void
1344get_kernel_geometry(void)
1345{
1346 struct hd_geometry geometry;
1347
1348 if (!ioctl(dev_fd, HDIO_GETGEO, &geometry)) {
1349 kern_heads = geometry.heads;
1350 kern_sectors = geometry.sectors;
1351
1352 }
1353}
1354
1355static void
1356get_partition_table_geometry(void)
1357{
1358 const unsigned char *bufp = (const unsigned char *)MBRbuffer;
1359 struct partition *p;
1360 int i, h, s, hh, ss;
1361 int first = 1;
1362 int bad = 0;
1363
1364 if (!(valid_part_table_flag((char*)bufp)))
1365 return;
1366
1367 hh = ss = 0;
1368 for (i = 0; i < 4; i++) {
1369 p = pt_offset(bufp, i);
1370 if (p->sys_ind != 0) {
1371 h = p->end_head + 1;
1372 s = (p->end_sector & 077);
1373 if (first) {
1374 hh = h;
1375 ss = s;
1376 first = 0;
1377 } else if (hh != h || ss != s)
1378 bad = 1;
1379 }
1380 }
1381
1382 if (!first && !bad) {
1383 pt_heads = hh;
1384 pt_sectors = ss;
1385 }
1386}
1387
1388static void
1389get_geometry(void)
1390{
1391 int sec_fac;
1392
1393 get_sectorsize();
1394 sec_fac = sector_size / 512;
1395#if ENABLE_FEATURE_SUN_LABEL
1396 guess_device_type();
1397#endif
1398 g_heads = g_cylinders = g_sectors = 0;
1399 kern_heads = kern_sectors = 0;
1400 pt_heads = pt_sectors = 0;
1401
1402 get_kernel_geometry();
1403 get_partition_table_geometry();
1404
1405 g_heads = user_heads ? user_heads :
1406 pt_heads ? pt_heads :
1407 kern_heads ? kern_heads : 255;
1408 g_sectors = user_sectors ? user_sectors :
1409 pt_sectors ? pt_sectors :
1410 kern_sectors ? kern_sectors : 63;
1411 total_number_of_sectors = bb_BLKGETSIZE_sectors(dev_fd);
1412
1413 sector_offset = 1;
1414 if (dos_compatible_flag)
1415 sector_offset = g_sectors;
1416
1417 g_cylinders = total_number_of_sectors / (g_heads * g_sectors * sec_fac);
1418 if (!g_cylinders)
1419 g_cylinders = user_cylinders;
1420}
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441#if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
1442static int get_boot(enum action what)
1443#else
1444static int get_boot(void)
1445#define get_boot(what) get_boot()
1446#endif
1447{
1448 int i, fd;
1449
1450 g_partitions = 4;
1451 for (i = 0; i < 4; i++) {
1452 struct pte *pe = &ptes[i];
1453 pe->part_table = pt_offset(MBRbuffer, i);
1454 pe->ext_pointer = NULL;
1455 pe->offset_from_dev_start = 0;
1456 pe->sectorbuffer = MBRbuffer;
1457#if ENABLE_FEATURE_FDISK_WRITABLE
1458 pe->changed = (what == CREATE_EMPTY_DOS);
1459#endif
1460 }
1461
1462#if ENABLE_FEATURE_FDISK_WRITABLE
1463
1464
1465
1466
1467
1468
1469 if (what == CREATE_EMPTY_DOS IF_FEATURE_SUN_LABEL(|| what == CREATE_EMPTY_SUN))
1470 goto created_table;
1471
1472 fd = open(disk_device, (option_mask32 & OPT_l) ? O_RDONLY : O_RDWR);
1473
1474 if (fd < 0) {
1475 fd = open(disk_device, O_RDONLY);
1476 if (fd < 0) {
1477 if (what == TRY_ONLY)
1478 return 1;
1479 fdisk_fatal(unable_to_open);
1480 }
1481 printf("'%s' is opened for read only\n", disk_device);
1482 }
1483 xmove_fd(fd, dev_fd);
1484 if (512 != full_read(dev_fd, MBRbuffer, 512)) {
1485 if (what == TRY_ONLY) {
1486 close_dev_fd();
1487 return 1;
1488 }
1489 fdisk_fatal(unable_to_read);
1490 }
1491#else
1492 fd = open(disk_device, O_RDONLY);
1493 if (fd < 0)
1494 return 1;
1495 if (512 != full_read(fd, MBRbuffer, 512)) {
1496 close(fd);
1497 return 1;
1498 }
1499 xmove_fd(fd, dev_fd);
1500#endif
1501
1502 get_geometry();
1503 update_units();
1504
1505#if ENABLE_FEATURE_SUN_LABEL
1506 if (check_sun_label())
1507 return 0;
1508#endif
1509#if ENABLE_FEATURE_SGI_LABEL
1510 if (check_sgi_label())
1511 return 0;
1512#endif
1513#if ENABLE_FEATURE_AIX_LABEL
1514 if (check_aix_label())
1515 return 0;
1516#endif
1517#if ENABLE_FEATURE_GPT_LABEL
1518 if (check_gpt_label())
1519 return 0;
1520#endif
1521#if ENABLE_FEATURE_OSF_LABEL
1522 if (check_osf_label()) {
1523 possibly_osf_label = 1;
1524 if (!valid_part_table_flag(MBRbuffer)) {
1525 current_label_type = LABEL_OSF;
1526 return 0;
1527 }
1528 puts("This disk has both DOS and BSD magic.\n"
1529 "Give the 'b' command to go to BSD mode.");
1530 }
1531#endif
1532
1533#if !ENABLE_FEATURE_FDISK_WRITABLE
1534 if (!valid_part_table_flag(MBRbuffer))
1535 return -1;
1536#else
1537 if (!valid_part_table_flag(MBRbuffer)) {
1538 if (what == OPEN_MAIN) {
1539 puts("Device contains neither a valid DOS "
1540 "partition table, nor Sun, SGI, OSF or GPT "
1541 "disklabel");
1542#ifdef __sparc__
1543 IF_FEATURE_SUN_LABEL(create_sunlabel();)
1544#else
1545 create_doslabel();
1546#endif
1547 return 0;
1548 }
1549
1550 return -1;
1551 }
1552 created_table:
1553#endif
1554
1555
1556 IF_FEATURE_FDISK_WRITABLE(warn_cylinders();)
1557 warn_geometry();
1558
1559 for (i = 0; i < 4; i++) {
1560 if (IS_EXTENDED(ptes[i].part_table->sys_ind)) {
1561 if (g_partitions != 4)
1562 printf("Ignoring extra extended "
1563 "partition %u\n", i + 1);
1564 else
1565 read_extended(i);
1566 }
1567 }
1568
1569 for (i = 3; i < g_partitions; i++) {
1570 struct pte *pe = &ptes[i];
1571 if (!valid_part_table_flag(pe->sectorbuffer)) {
1572 printf("Warning: invalid flag 0x%02x,0x%02x of partition "
1573 "table %u will be corrected by w(rite)\n",
1574 pe->sectorbuffer[510],
1575 pe->sectorbuffer[511],
1576 i + 1);
1577 IF_FEATURE_FDISK_WRITABLE(pe->changed = 1;)
1578 }
1579 }
1580
1581 return 0;
1582}
1583
1584#if ENABLE_FEATURE_FDISK_WRITABLE
1585
1586
1587
1588
1589
1590
1591
1592static sector_t
1593read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg)
1594{
1595 sector_t value;
1596 int default_ok = 1;
1597 const char *fmt = "%s (%u-%u, default %u): ";
1598
1599 if (dflt < low || dflt > high) {
1600 fmt = "%s (%u-%u): ";
1601 default_ok = 0;
1602 }
1603
1604 while (1) {
1605 int use_default = default_ok;
1606
1607
1608 do {
1609 printf(fmt, mesg, low, high, dflt);
1610 read_maybe_empty("");
1611 } while (*line_ptr != '\n' && !isdigit(*line_ptr)
1612 && *line_ptr != '-' && *line_ptr != '+');
1613
1614 if (*line_ptr == '+' || *line_ptr == '-') {
1615 int minus = (*line_ptr == '-');
1616 unsigned scale_shift;
1617
1618 if (sizeof(value) <= sizeof(long))
1619 value = strtoul(line_ptr + 1, NULL, 10);
1620 else
1621 value = strtoull(line_ptr + 1, NULL, 10);
1622
1623
1624
1625
1626 while (isdigit(*++line_ptr))
1627 use_default = 0;
1628
1629 scale_shift = 0;
1630 switch (*line_ptr | 0x20) {
1631 case 'k':
1632 scale_shift = 10;
1633 break;
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654 case 'm':
1655 scale_shift = 20;
1656 break;
1657 case 'g':
1658 scale_shift = 30;
1659 break;
1660 case 't':
1661 scale_shift = 40;
1662 break;
1663 default:
1664 break;
1665 }
1666 if (scale_shift) {
1667 ullong bytes;
1668 unsigned long unit;
1669
1670 bytes = (ullong) value << scale_shift;
1671 unit = sector_size * units_per_sector;
1672 bytes += unit/2;
1673 bytes /= unit;
1674 value = (bytes != 0 ? bytes - 1 : 0);
1675 }
1676 if (minus)
1677 value = -value;
1678 value += base;
1679 } else {
1680 if (sizeof(value) <= sizeof(long))
1681 value = strtoul(line_ptr, NULL, 10);
1682 else
1683 value = strtoull(line_ptr, NULL, 10);
1684 while (isdigit(*line_ptr)) {
1685 line_ptr++;
1686 use_default = 0;
1687 }
1688 }
1689 if (use_default) {
1690 value = dflt;
1691 printf("Using default value %u\n", value);
1692 }
1693 if (value >= low && value <= high)
1694 break;
1695 puts("Value is out of range");
1696 }
1697 return value;
1698}
1699
1700static unsigned
1701get_partition(int warn, unsigned max)
1702{
1703 struct pte *pe;
1704 unsigned i;
1705
1706 i = read_int(1, 0, max, 0, "Partition number") - 1;
1707 pe = &ptes[i];
1708
1709 if (warn) {
1710 if ((!LABEL_IS_SUN && !LABEL_IS_SGI && !pe->part_table->sys_ind)
1711 || (LABEL_IS_SUN && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id))
1712 || (LABEL_IS_SGI && !sgi_get_num_sectors(i))
1713 ) {
1714 printf("Warning: partition %u has empty type\n", i+1);
1715 }
1716 }
1717 return i;
1718}
1719
1720static int
1721get_existing_partition(int warn, unsigned max)
1722{
1723 int pno = -1;
1724 unsigned i;
1725
1726 for (i = 0; i < max; i++) {
1727 struct pte *pe = &ptes[i];
1728 struct partition *p = pe->part_table;
1729
1730 if (p && !is_cleared_partition(p)) {
1731 if (pno >= 0)
1732 goto not_unique;
1733 pno = i;
1734 }
1735 }
1736 if (pno >= 0) {
1737 printf("Selected partition %u\n", pno+1);
1738 return pno;
1739 }
1740 puts("No partition is defined yet!");
1741 return -1;
1742
1743 not_unique:
1744 return get_partition(warn, max);
1745}
1746
1747static int
1748get_nonexisting_partition(void)
1749{
1750 const int max = 4;
1751 int pno = -1;
1752 unsigned i;
1753
1754 for (i = 0; i < max; i++) {
1755 struct pte *pe = &ptes[i];
1756 struct partition *p = pe->part_table;
1757
1758 if (p && is_cleared_partition(p)) {
1759 if (pno >= 0)
1760 goto not_unique;
1761 pno = i;
1762 }
1763 }
1764 if (pno >= 0) {
1765 printf("Selected partition %u\n", pno+1);
1766 return pno;
1767 }
1768 puts("All primary partitions have been defined already!");
1769 return -1;
1770
1771 not_unique:
1772 return get_partition( 0, max);
1773}
1774
1775
1776static void
1777change_units(void)
1778{
1779 display_in_cyl_units = !display_in_cyl_units;
1780 update_units();
1781 printf("Changing display/entry units to %s\n",
1782 str_units(PLURAL));
1783}
1784
1785static void
1786toggle_active(int i)
1787{
1788 struct pte *pe = &ptes[i];
1789 struct partition *p = pe->part_table;
1790
1791 if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
1792 printf("WARNING: Partition %u is an extended partition\n", i + 1);
1793 p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
1794 pe->changed = 1;
1795}
1796
1797static void
1798toggle_dos_compatibility_flag(void)
1799{
1800 dos_compatible_flag = 1 - dos_compatible_flag;
1801 if (dos_compatible_flag) {
1802 sector_offset = g_sectors;
1803 printf("DOS Compatibility flag is %sset\n", "");
1804 } else {
1805 sector_offset = 1;
1806 printf("DOS Compatibility flag is %sset\n", "not ");
1807 }
1808}
1809
1810static void
1811delete_partition(int i)
1812{
1813 struct pte *pe = &ptes[i];
1814 struct partition *p = pe->part_table;
1815 struct partition *q = pe->ext_pointer;
1816
1817
1818
1819
1820
1821 if (warn_geometry())
1822 return;
1823 pe->changed = 1;
1824
1825 if (LABEL_IS_SUN) {
1826 sun_delete_partition(i);
1827 return;
1828 }
1829 if (LABEL_IS_SGI) {
1830 sgi_delete_partition(i);
1831 return;
1832 }
1833
1834 if (i < 4) {
1835 if (IS_EXTENDED(p->sys_ind) && i == ext_index) {
1836 g_partitions = 4;
1837 ptes[ext_index].ext_pointer = NULL;
1838 extended_offset = 0;
1839 }
1840 clear_partition(p);
1841 return;
1842 }
1843
1844 if (!q->sys_ind && i > 4) {
1845
1846 --g_partitions;
1847 --i;
1848 clear_partition(ptes[i].ext_pointer);
1849 ptes[i].changed = 1;
1850 } else {
1851
1852 if (i > 4) {
1853
1854 p = ptes[i-1].ext_pointer;
1855 *p = *q;
1856 set_start_sect(p, get_start_sect(q));
1857 set_nr_sects(p, get_nr_sects(q));
1858 ptes[i-1].changed = 1;
1859 } else if (g_partitions > 5) {
1860
1861 pe = &ptes[5];
1862
1863 if (pe->part_table)
1864 set_start_sect(pe->part_table,
1865 get_partition_start_from_dev_start(pe) -
1866 extended_offset);
1867 pe->offset_from_dev_start = extended_offset;
1868 pe->changed = 1;
1869 }
1870
1871 if (g_partitions > 5) {
1872 g_partitions--;
1873 while (i < g_partitions) {
1874 ptes[i] = ptes[i+1];
1875 i++;
1876 }
1877 } else {
1878
1879 clear_partition(ptes[i].part_table);
1880 }
1881 }
1882}
1883
1884static void
1885change_sysid(void)
1886{
1887 int i, sys, origsys;
1888 struct partition *p;
1889
1890
1891
1892
1893 if (!LABEL_IS_SGI) {
1894 i = get_existing_partition(0, g_partitions);
1895 } else {
1896 i = get_partition(0, g_partitions);
1897 }
1898 if (i == -1)
1899 return;
1900 p = ptes[i].part_table;
1901 origsys = sys = get_sysid(i);
1902
1903
1904
1905 if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) {
1906 printf("Partition %u does not exist yet!\n", i + 1);
1907 return;
1908 }
1909 while (1) {
1910 sys = read_hex(get_sys_types());
1911
1912 if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) {
1913 puts("Type 0 means free space to many systems\n"
1914 "(but not to Linux). Having partitions of\n"
1915 "type 0 is probably unwise.");
1916
1917 }
1918
1919 if (!LABEL_IS_SUN && !LABEL_IS_SGI) {
1920 if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {
1921 puts("You cannot change a partition into"
1922 " an extended one or vice versa");
1923 break;
1924 }
1925 }
1926
1927 if (sys < 256) {
1928#if ENABLE_FEATURE_SUN_LABEL
1929 if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK)
1930 puts("Consider leaving partition 3 "
1931 "as Whole disk (5),\n"
1932 "as SunOS/Solaris expects it and "
1933 "even Linux likes it\n");
1934#endif
1935#if ENABLE_FEATURE_SGI_LABEL
1936 if (LABEL_IS_SGI &&
1937 (
1938 (i == 10 && sys != SGI_ENTIRE_DISK) ||
1939 (i == 8 && sys != 0)
1940 )
1941 ) {
1942 puts("Consider leaving partition 9 "
1943 "as volume header (0),\nand "
1944 "partition 11 as entire volume (6)"
1945 "as IRIX expects it\n");
1946 }
1947#endif
1948 if (sys == origsys)
1949 break;
1950 if (LABEL_IS_SUN) {
1951 sun_change_sysid(i, sys);
1952 } else if (LABEL_IS_SGI) {
1953 sgi_change_sysid(i, sys);
1954 } else
1955 p->sys_ind = sys;
1956
1957 printf("Changed system type of partition %u "
1958 "to %x (%s)\n", i + 1, sys,
1959 partition_type(sys));
1960 ptes[i].changed = 1;
1961
1962
1963 break;
1964 }
1965 }
1966}
1967#endif
1968
1969
1970
1971
1972
1973
1974
1975static void
1976linear2chs(unsigned ls, unsigned *c, unsigned *h, unsigned *s)
1977{
1978 int spc = g_heads * g_sectors;
1979
1980 *c = ls / spc;
1981 ls = ls % spc;
1982 *h = ls / g_sectors;
1983 *s = ls % g_sectors + 1;
1984}
1985
1986static void
1987check_consistency(const struct partition *p, int partition)
1988{
1989 unsigned pbc, pbh, pbs;
1990 unsigned pec, peh, pes;
1991 unsigned lbc, lbh, lbs;
1992 unsigned lec, leh, les;
1993
1994 if (!g_heads || !g_sectors || (partition >= 4))
1995 return;
1996
1997
1998 pbc = cylinder(p->sector, p->cyl);
1999 pbh = p->head;
2000 pbs = sector(p->sector);
2001
2002
2003 pec = cylinder(p->end_sector, p->end_cyl);
2004 peh = p->end_head;
2005 pes = sector(p->end_sector);
2006
2007
2008 linear2chs(get_start_sect(p), &lbc, &lbh, &lbs);
2009
2010
2011 linear2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
2012
2013
2014 if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
2015 printf("Partition %u has different physical/logical "
2016 "start (non-Linux?):\n", partition + 1);
2017 printf(" phys=(%u,%u,%u) ", pbc, pbh, pbs);
2018 printf("logical=(%u,%u,%u)\n", lbc, lbh, lbs);
2019 }
2020
2021
2022 if (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
2023 printf("Partition %u has different physical/logical "
2024 "end:\n", partition + 1);
2025 printf(" phys=(%u,%u,%u) ", pec, peh, pes);
2026 printf("logical=(%u,%u,%u)\n", lec, leh, les);
2027 }
2028}
2029
2030static void
2031list_disk_geometry(void)
2032{
2033 ullong bytes = ((ullong)total_number_of_sectors << 9);
2034 ullong xbytes = bytes / (1024*1024);
2035 char x = 'M';
2036
2037 if (xbytes >= 10000) {
2038 xbytes += 512;
2039 xbytes /= 1024;
2040 x = 'G';
2041 }
2042 printf("Disk %s: %llu %cB, %llu bytes, %"SECT_FMT"u sectors\n"
2043 "%u cylinders, %u heads, %u sectors/track\n"
2044 "Units: %s of %u * %u = %u bytes\n\n",
2045 disk_device, xbytes, x,
2046 bytes, total_number_of_sectors,
2047 g_cylinders, g_heads, g_sectors,
2048 str_units(PLURAL),
2049 units_per_sector, sector_size, units_per_sector * sector_size
2050 );
2051}
2052
2053
2054
2055
2056
2057
2058static int
2059wrong_p_order(int *prev)
2060{
2061 const struct pte *pe;
2062 const struct partition *p;
2063 sector_t last_p_start_pos = 0, p_start_pos;
2064 unsigned i, last_i = 0;
2065
2066 for (i = 0; i < g_partitions; i++) {
2067 if (i == 4) {
2068 last_i = 4;
2069 last_p_start_pos = 0;
2070 }
2071 pe = &ptes[i];
2072 p = pe->part_table;
2073 if (p->sys_ind) {
2074 p_start_pos = get_partition_start_from_dev_start(pe);
2075
2076 if (last_p_start_pos > p_start_pos) {
2077 if (prev)
2078 *prev = last_i;
2079 return i;
2080 }
2081
2082 last_p_start_pos = p_start_pos;
2083 last_i = i;
2084 }
2085 }
2086 return 0;
2087}
2088
2089#if ENABLE_FEATURE_FDISK_ADVANCED
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103static void
2104fix_chain_of_logicals(void)
2105{
2106 int j, oj, ojj, sj, sjj;
2107 struct partition *pj,*pjj,tmp;
2108
2109
2110
2111 stage1:
2112 for (j = 5; j < g_partitions - 1; j++) {
2113 oj = ptes[j].offset_from_dev_start;
2114 ojj = ptes[j+1].offset_from_dev_start;
2115 if (oj > ojj) {
2116 ptes[j].offset_from_dev_start = ojj;
2117 ptes[j+1].offset_from_dev_start = oj;
2118 pj = ptes[j].part_table;
2119 set_start_sect(pj, get_start_sect(pj)+oj-ojj);
2120 pjj = ptes[j+1].part_table;
2121 set_start_sect(pjj, get_start_sect(pjj)+ojj-oj);
2122 set_start_sect(ptes[j-1].ext_pointer,
2123 ojj-extended_offset);
2124 set_start_sect(ptes[j].ext_pointer,
2125 oj-extended_offset);
2126 goto stage1;
2127 }
2128 }
2129
2130
2131 stage2:
2132 for (j = 4; j < g_partitions - 1; j++) {
2133 pj = ptes[j].part_table;
2134 pjj = ptes[j+1].part_table;
2135 sj = get_start_sect(pj);
2136 sjj = get_start_sect(pjj);
2137 oj = ptes[j].offset_from_dev_start;
2138 ojj = ptes[j+1].offset_from_dev_start;
2139 if (oj+sj > ojj+sjj) {
2140 tmp = *pj;
2141 *pj = *pjj;
2142 *pjj = tmp;
2143 set_start_sect(pj, ojj+sjj-oj);
2144 set_start_sect(pjj, oj+sj-ojj);
2145 goto stage2;
2146 }
2147 }
2148
2149
2150 for (j = 4; j < g_partitions; j++)
2151 ptes[j].changed = 1;
2152}
2153
2154
2155static void
2156fix_partition_table_order(void)
2157{
2158 struct pte *pei, *pek;
2159 int i,k;
2160
2161 if (!wrong_p_order(NULL)) {
2162 puts("Ordering is already correct\n");
2163 return;
2164 }
2165
2166 while ((i = wrong_p_order(&k)) != 0 && i < 4) {
2167
2168
2169 struct partition *pi, *pk, *pe, pbuf;
2170 pei = &ptes[i];
2171 pek = &ptes[k];
2172
2173 pe = pei->ext_pointer;
2174 pei->ext_pointer = pek->ext_pointer;
2175 pek->ext_pointer = pe;
2176
2177 pi = pei->part_table;
2178 pk = pek->part_table;
2179
2180 memmove(&pbuf, pi, sizeof(struct partition));
2181 memmove(pi, pk, sizeof(struct partition));
2182 memmove(pk, &pbuf, sizeof(struct partition));
2183
2184 pei->changed = pek->changed = 1;
2185 }
2186
2187 if (i)
2188 fix_chain_of_logicals();
2189
2190 puts("Done");
2191}
2192#endif
2193
2194static const char *
2195chs_string11(unsigned cyl, unsigned head, unsigned sect)
2196{
2197 char *buf = auto_string(xzalloc(sizeof(int)*3 * 3));
2198 sprintf(buf, "%u,%u,%u", cylinder(sect,cyl), head, sector(sect));
2199 return buf;
2200}
2201
2202static void
2203list_table(int xtra)
2204{
2205 int i, w;
2206
2207 if (LABEL_IS_SUN) {
2208 sun_list_table(xtra);
2209 return;
2210 }
2211 if (LABEL_IS_SGI) {
2212 sgi_list_table(xtra);
2213 return;
2214 }
2215 if (LABEL_IS_GPT) {
2216 gpt_list_table(xtra);
2217 return;
2218 }
2219
2220 list_disk_geometry();
2221
2222 if (LABEL_IS_OSF) {
2223 xbsd_print_disklabel(xtra);
2224 return;
2225 }
2226
2227
2228
2229
2230
2231 w = strlen(disk_device);
2232 if (w && isdigit(disk_device[w-1]))
2233 w++;
2234 if (w < 7)
2235 w = 7;
2236
2237 printf("%-*s Boot StartCHS EndCHS StartLBA EndLBA Sectors Size Id Type\n",
2238 w-1, "Device");
2239
2240 for (i = 0; i < g_partitions; i++) {
2241 const struct partition *p;
2242 const struct pte *pe = &ptes[i];
2243 char boot4[4];
2244 char numstr6[6];
2245 sector_t start_sect;
2246 sector_t end_sect;
2247 sector_t nr_sects;
2248
2249 p = pe->part_table;
2250 if (!p || is_cleared_partition(p))
2251 continue;
2252
2253 sprintf(boot4, "%02x", p->boot_ind);
2254 if ((p->boot_ind & 0x7f) == 0) {
2255
2256 boot4[0] = p->boot_ind ? '*' : ' ';
2257 boot4[1] = ' ';
2258 }
2259
2260 start_sect = get_partition_start_from_dev_start(pe);
2261 end_sect = start_sect;
2262 nr_sects = get_nr_sects(p);
2263 if (nr_sects != 0)
2264 end_sect += nr_sects - 1;
2265
2266 smart_ulltoa5((ullong)nr_sects * sector_size,
2267 numstr6, " KMGTPEZY")[0] = '\0';
2268
2269#define SFMT SECT_FMT
2270
2271 printf("%s%s %-11s"" %-11s"" %10"SFMT"u %10"SFMT"u %10"SFMT"u %s %2x %s\n",
2272 partname(disk_device, i+1, w+2),
2273 boot4,
2274 chs_string11(p->cyl, p->head, p->sector),
2275 chs_string11(p->end_cyl, p->end_head, p->end_sector),
2276 start_sect,
2277 end_sect,
2278 nr_sects,
2279 numstr6,
2280 p->sys_ind,
2281 partition_type(p->sys_ind)
2282 );
2283#undef SFMT
2284 check_consistency(p, i);
2285 }
2286
2287
2288
2289
2290 if (LABEL_IS_DOS && wrong_p_order(NULL)) {
2291
2292 puts("\nPartition table entries are not in disk order");
2293 }
2294}
2295
2296#if ENABLE_FEATURE_FDISK_ADVANCED
2297static void
2298x_list_table(int extend)
2299{
2300 const struct pte *pe;
2301 const struct partition *p;
2302 int i;
2303
2304 printf("\nDisk %s: %u heads, %u sectors, %u cylinders\n\n",
2305 disk_device, g_heads, g_sectors, g_cylinders);
2306 puts("Nr AF Hd Sec Cyl Hd Sec Cyl Start Size ID");
2307 for (i = 0; i < g_partitions; i++) {
2308 pe = &ptes[i];
2309 p = (extend ? pe->ext_pointer : pe->part_table);
2310 if (p != NULL) {
2311 printf("%2u %02x%4u%4u%5u%4u%4u%5u%11"SECT_FMT"u%11"SECT_FMT"u %02x\n",
2312 i + 1, p->boot_ind,
2313 p->head,
2314 sector(p->sector),
2315 cylinder(p->sector, p->cyl),
2316 p->end_head,
2317 sector(p->end_sector),
2318 cylinder(p->end_sector, p->end_cyl),
2319 get_start_sect(p),
2320 get_nr_sects(p),
2321 p->sys_ind
2322 );
2323 if (p->sys_ind)
2324 check_consistency(p, i);
2325 }
2326 }
2327}
2328#endif
2329
2330#if ENABLE_FEATURE_FDISK_WRITABLE
2331static void
2332fill_bounds(sector_t *first, sector_t *last)
2333{
2334 unsigned i;
2335 const struct pte *pe = &ptes[0];
2336 const struct partition *p;
2337
2338 for (i = 0; i < g_partitions; pe++,i++) {
2339 p = pe->part_table;
2340 if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) {
2341 first[i] = 0xffffffff;
2342 last[i] = 0;
2343 } else {
2344 first[i] = get_partition_start_from_dev_start(pe);
2345 last[i] = first[i] + get_nr_sects(p) - 1;
2346 }
2347 }
2348}
2349
2350static void
2351check(int n, unsigned h, unsigned s, unsigned c, sector_t start)
2352{
2353 sector_t total, real_s, real_c;
2354
2355 real_s = sector(s) - 1;
2356 real_c = cylinder(s, c);
2357 total = (real_c * g_sectors + real_s) * g_heads + h;
2358 if (!total)
2359 printf("Partition %u contains sector 0\n", n);
2360 if (h >= g_heads)
2361 printf("Partition %u: head %u greater than maximum %u\n",
2362 n, h + 1, g_heads);
2363 if (real_s >= g_sectors)
2364 printf("Partition %u: sector %u greater than "
2365 "maximum %u\n", n, s, g_sectors);
2366 if (real_c >= g_cylinders)
2367 printf("Partition %u: cylinder %"SECT_FMT"u greater than "
2368 "maximum %u\n", n, real_c + 1, g_cylinders);
2369 if (g_cylinders <= 1024 && start != total)
2370 printf("Partition %u: previous sectors %"SECT_FMT"u disagrees with "
2371 "total %"SECT_FMT"u\n", n, start, total);
2372}
2373
2374static void
2375verify(void)
2376{
2377 int i, j;
2378 sector_t total = 1;
2379 sector_t chs_size;
2380 sector_t first[g_partitions], last[g_partitions];
2381 struct partition *p;
2382
2383 if (warn_geometry())
2384 return;
2385
2386 if (LABEL_IS_SUN) {
2387 verify_sun();
2388 return;
2389 }
2390 if (LABEL_IS_SGI) {
2391 verify_sgi(1);
2392 return;
2393 }
2394
2395 fill_bounds(first, last);
2396 for (i = 0; i < g_partitions; i++) {
2397 struct pte *pe = &ptes[i];
2398
2399 p = pe->part_table;
2400 if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
2401 check_consistency(p, i);
2402 if (get_partition_start_from_dev_start(pe) < first[i])
2403 printf("Warning: bad start-of-data in "
2404 "partition %u\n", i + 1);
2405 check(i + 1, p->end_head, p->end_sector, p->end_cyl,
2406 last[i]);
2407 total += last[i] + 1 - first[i];
2408 for (j = 0; j < i; j++) {
2409 if ((first[i] >= first[j] && first[i] <= last[j])
2410 || ((last[i] <= last[j] && last[i] >= first[j]))) {
2411 printf("Warning: partition %u overlaps "
2412 "partition %u\n", j + 1, i + 1);
2413 total += first[i] >= first[j] ?
2414 first[i] : first[j];
2415 total -= last[i] <= last[j] ?
2416 last[i] : last[j];
2417 }
2418 }
2419 }
2420 }
2421
2422 if (extended_offset) {
2423 struct pte *pex = &ptes[ext_index];
2424 sector_t e_last = get_start_sect(pex->part_table) +
2425 get_nr_sects(pex->part_table) - 1;
2426
2427 for (i = 4; i < g_partitions; i++) {
2428 total++;
2429 p = ptes[i].part_table;
2430 if (!p->sys_ind) {
2431 if (i != 4 || i + 1 < g_partitions)
2432 printf("Warning: partition %u "
2433 "is empty\n", i + 1);
2434 } else if (first[i] < extended_offset || last[i] > e_last) {
2435 printf("Logical partition %u not entirely in "
2436 "partition %u\n", i + 1, ext_index + 1);
2437 }
2438 }
2439 }
2440
2441 chs_size = (sector_t)g_heads * g_sectors * g_cylinders;
2442 if (total > chs_size)
2443 printf("Total allocated sectors %u"
2444 " greater than CHS size %"SECT_FMT"u\n",
2445 total, chs_size
2446 );
2447 else {
2448 total = chs_size - total;
2449 if (total != 0)
2450 printf("%"SECT_FMT"u unallocated sectors\n", total);
2451 }
2452}
2453
2454static void
2455add_partition(int n, int sys)
2456{
2457 char mesg[256];
2458 int i, num_read = 0;
2459 struct partition *p = ptes[n].part_table;
2460 struct partition *q = ptes[ext_index].part_table;
2461 sector_t limit, temp;
2462 sector_t start, stop = 0;
2463 sector_t first[g_partitions], last[g_partitions];
2464
2465 if (p && p->sys_ind) {
2466 printf(msg_part_already_defined, n + 1);
2467 return;
2468 }
2469 fill_bounds(first, last);
2470 if (n < 4) {
2471 start = sector_offset;
2472 if (display_in_cyl_units || !total_number_of_sectors)
2473 limit = (sector_t) g_heads * g_sectors * g_cylinders - 1;
2474 else
2475 limit = total_number_of_sectors - 1;
2476 if (extended_offset) {
2477 first[ext_index] = extended_offset;
2478 last[ext_index] = get_start_sect(q) +
2479 get_nr_sects(q) - 1;
2480 }
2481 } else {
2482 start = extended_offset + sector_offset;
2483 limit = get_start_sect(q) + get_nr_sects(q) - 1;
2484 }
2485 if (display_in_cyl_units)
2486 for (i = 0; i < g_partitions; i++)
2487 first[i] = (cround(first[i]) - 1) * units_per_sector;
2488
2489 snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));
2490 do {
2491 temp = start;
2492 for (i = 0; i < g_partitions; i++) {
2493 int lastplusoff;
2494
2495 if (start == ptes[i].offset_from_dev_start)
2496 start += sector_offset;
2497 lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
2498 if (start >= first[i] && start <= lastplusoff)
2499 start = lastplusoff + 1;
2500 }
2501 if (start > limit)
2502 break;
2503 if (start >= temp+units_per_sector && num_read) {
2504 printf("Sector %"SECT_FMT"u is already allocated\n", temp);
2505 temp = start;
2506 num_read = 0;
2507 }
2508 if (!num_read && start == temp) {
2509 sector_t saved_start;
2510
2511 saved_start = start;
2512 start = read_int(cround(saved_start), cround(saved_start), cround(limit), 0, mesg);
2513 if (display_in_cyl_units) {
2514 start = (start - 1) * units_per_sector;
2515 if (start < saved_start)
2516 start = saved_start;
2517 }
2518 num_read = 1;
2519 }
2520 } while (start != temp || !num_read);
2521 if (n > 4) {
2522 struct pte *pe = &ptes[n];
2523
2524 pe->offset_from_dev_start = start - sector_offset;
2525 if (pe->offset_from_dev_start == extended_offset) {
2526 pe->offset_from_dev_start++;
2527 if (sector_offset == 1)
2528 start++;
2529 }
2530 }
2531
2532 for (i = 0; i < g_partitions; i++) {
2533 struct pte *pe = &ptes[i];
2534
2535 if (start < pe->offset_from_dev_start && limit >= pe->offset_from_dev_start)
2536 limit = pe->offset_from_dev_start - 1;
2537 if (start < first[i] && limit >= first[i])
2538 limit = first[i] - 1;
2539 }
2540 if (start > limit) {
2541 puts("No free sectors available");
2542 if (n > 4)
2543 g_partitions--;
2544 return;
2545 }
2546 if (cround(start) == cround(limit)) {
2547 stop = limit;
2548 } else {
2549 snprintf(mesg, sizeof(mesg),
2550 "Last %s or +size{,K,M,G,T}",
2551 str_units(SINGULAR)
2552 );
2553 stop = read_int(cround(start), cround(limit), cround(limit), cround(start), mesg);
2554 if (display_in_cyl_units) {
2555 stop = stop * units_per_sector - 1;
2556 if (stop >limit)
2557 stop = limit;
2558 }
2559 }
2560
2561 set_partition(n, 0, start, stop, sys);
2562 if (n > 4)
2563 set_partition(n - 1, 1, ptes[n].offset_from_dev_start, stop, EXTENDED);
2564
2565 if (IS_EXTENDED(sys)) {
2566 struct pte *pe4 = &ptes[4];
2567 struct pte *pen = &ptes[n];
2568
2569 ext_index = n;
2570 pen->ext_pointer = p;
2571 pe4->offset_from_dev_start = extended_offset = start;
2572 pe4->sectorbuffer = xzalloc(sector_size);
2573 pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
2574 pe4->ext_pointer = pe4->part_table + 1;
2575 pe4->changed = 1;
2576 g_partitions = 5;
2577 }
2578}
2579
2580static void
2581add_logical(void)
2582{
2583 if (g_partitions > 5 || ptes[4].part_table->sys_ind) {
2584 struct pte *pe = &ptes[g_partitions];
2585
2586 pe->sectorbuffer = xzalloc(sector_size);
2587 pe->part_table = pt_offset(pe->sectorbuffer, 0);
2588 pe->ext_pointer = pe->part_table + 1;
2589 pe->offset_from_dev_start = 0;
2590 pe->changed = 1;
2591 g_partitions++;
2592 }
2593 add_partition(g_partitions - 1, LINUX_NATIVE);
2594}
2595
2596static void
2597new_partition(void)
2598{
2599 int i, free_primary = 0;
2600
2601 if (warn_geometry())
2602 return;
2603
2604 if (LABEL_IS_SUN) {
2605 add_sun_partition(get_partition(0, g_partitions), LINUX_NATIVE);
2606 return;
2607 }
2608 if (LABEL_IS_SGI) {
2609 sgi_add_partition(get_partition(0, g_partitions), LINUX_NATIVE);
2610 return;
2611 }
2612 if (LABEL_IS_AIX) {
2613 puts("Sorry - this fdisk cannot handle AIX disk labels.\n"
2614"If you want to add DOS-type partitions, create a new empty DOS partition\n"
2615"table first (use 'o'). This will destroy the present disk contents.");
2616 return;
2617 }
2618
2619 for (i = 0; i < 4; i++)
2620 free_primary += !ptes[i].part_table->sys_ind;
2621
2622 if (!free_primary && g_partitions >= MAXIMUM_PARTS) {
2623 puts("The maximum number of partitions has been created");
2624 return;
2625 }
2626
2627 if (!free_primary) {
2628 if (extended_offset)
2629 add_logical();
2630 else
2631 puts("You must delete some partition and add "
2632 "an extended partition first");
2633 } else {
2634 char c, line[80];
2635 snprintf(line, sizeof(line),
2636 "Partition type\n"
2637 " p primary partition (1-4)\n"
2638 " %s\n",
2639 (extended_offset ?
2640 "l logical (5 or over)" : "e extended"));
2641 while (1) {
2642 c = read_nonempty(line);
2643 c |= 0x20;
2644 if (c == 'p') {
2645 i = get_nonexisting_partition();
2646 if (i >= 0)
2647 add_partition(i, LINUX_NATIVE);
2648 return;
2649 }
2650 if (c == 'l' && extended_offset) {
2651 add_logical();
2652 return;
2653 }
2654 if (c == 'e' && !extended_offset) {
2655 i = get_nonexisting_partition();
2656 if (i >= 0)
2657 add_partition(i, EXTENDED);
2658 return;
2659 }
2660 printf("Invalid partition number "
2661 "for type '%c'\n", c);
2662 }
2663 }
2664}
2665
2666static void
2667reread_partition_table(int leave)
2668{
2669 int i;
2670
2671 puts("Calling ioctl() to re-read partition table");
2672 sync();
2673
2674
2675
2676 sleep(1);
2677 i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
2678 "WARNING: rereading partition table "
2679 "failed, kernel still uses old table");
2680#if 0
2681 if (dos_changed)
2682 puts(
2683 "\nWARNING: If you have created or modified any DOS 6.x\n"
2684 "partitions, please see the fdisk manual page for additional\n"
2685 "information");
2686#endif
2687
2688 if (leave) {
2689 if (ENABLE_FEATURE_CLEAN_UP)
2690 close_dev_fd();
2691 exit(i != 0);
2692 }
2693}
2694
2695static void
2696write_table(void)
2697{
2698 int i;
2699
2700 if (LABEL_IS_DOS) {
2701 for (i = 0; i < 3; i++)
2702 if (ptes[i].changed)
2703 ptes[3].changed = 1;
2704 for (i = 3; i < g_partitions; i++) {
2705 struct pte *pe = &ptes[i];
2706 if (pe->changed) {
2707 write_part_table_flag(pe->sectorbuffer);
2708 write_sector(pe->offset_from_dev_start, pe->sectorbuffer);
2709 }
2710 }
2711 }
2712 else if (LABEL_IS_SGI) {
2713
2714 sgi_write_table();
2715 }
2716 else if (LABEL_IS_SUN) {
2717 for (i = 0; i < 8; i++) {
2718 if (ptes[i].changed) {
2719 sun_write_table();
2720 break;
2721 }
2722 }
2723 }
2724
2725 puts("The partition table has been altered.");
2726 reread_partition_table(1);
2727}
2728#endif
2729
2730#if ENABLE_FEATURE_FDISK_ADVANCED
2731#define MAX_PER_LINE 16
2732static void
2733print_buffer(char *pbuffer)
2734{
2735 int i,l;
2736
2737 for (i = 0, l = 0; i < sector_size; i++, l++) {
2738 if (l == 0)
2739 printf("0x%03X:", i);
2740 printf(" %02X", (unsigned char) pbuffer[i]);
2741 if (l == MAX_PER_LINE - 1) {
2742 bb_putchar('\n');
2743 l = -1;
2744 }
2745 }
2746 if (l > 0)
2747 bb_putchar('\n');
2748 bb_putchar('\n');
2749}
2750
2751static void
2752print_raw(void)
2753{
2754 int i;
2755
2756 printf("Device: %s\n", disk_device);
2757 if (LABEL_IS_SGI || LABEL_IS_SUN)
2758 print_buffer(MBRbuffer);
2759 else {
2760 for (i = 3; i < g_partitions; i++)
2761 print_buffer(ptes[i].sectorbuffer);
2762 }
2763}
2764
2765static void
2766move_begin(unsigned i)
2767{
2768 struct pte *pe = &ptes[i];
2769 struct partition *p = pe->part_table;
2770 sector_t new, first, nr_sects;
2771
2772 if (warn_geometry())
2773 return;
2774 nr_sects = get_nr_sects(p);
2775 if (!p->sys_ind || !nr_sects || IS_EXTENDED(p->sys_ind)) {
2776 printf("Partition %u has no data area\n", i + 1);
2777 return;
2778 }
2779 first = get_partition_start_from_dev_start(pe);
2780 new = read_int(0 , first, first + nr_sects - 1, first, "New beginning of data");
2781 if (new != first) {
2782 sector_t new_relative = new - pe->offset_from_dev_start;
2783 nr_sects += (get_start_sect(p) - new_relative);
2784 set_start_sect(p, new_relative);
2785 set_nr_sects(p, nr_sects);
2786 read_nonempty("Recalculate C/H/S values? (Y/N): ");
2787 if ((line_ptr[0] | 0x20) == 'y')
2788 set_hsc_start_end(p, new, new + nr_sects - 1);
2789 pe->changed = 1;
2790 }
2791}
2792
2793static void
2794xselect(void)
2795{
2796 char c;
2797
2798 while (1) {
2799 bb_putchar('\n');
2800 c = 0x20 | read_nonempty("Expert command (m for help): ");
2801 switch (c) {
2802 case 'a':
2803 if (LABEL_IS_SUN)
2804 sun_set_alt_cyl();
2805 break;
2806 case 'b':
2807 if (LABEL_IS_DOS)
2808 move_begin(get_partition(0, g_partitions));
2809 break;
2810 case 'c':
2811 user_cylinders = g_cylinders =
2812 read_int(1, g_cylinders, 1048576, 0,
2813 "Number of cylinders");
2814 if (LABEL_IS_SUN)
2815 sun_set_ncyl(g_cylinders);
2816 if (LABEL_IS_DOS)
2817 warn_cylinders();
2818 break;
2819 case 'd':
2820 print_raw();
2821 break;
2822 case 'e':
2823 if (LABEL_IS_SGI)
2824 sgi_set_xcyl();
2825 else if (LABEL_IS_SUN)
2826 sun_set_xcyl();
2827 else if (LABEL_IS_DOS)
2828 x_list_table(1);
2829 break;
2830 case 'f':
2831 if (LABEL_IS_DOS)
2832 fix_partition_table_order();
2833 break;
2834 case 'g':
2835#if ENABLE_FEATURE_SGI_LABEL
2836 create_sgilabel();
2837#endif
2838 break;
2839 case 'h':
2840 user_heads = g_heads = read_int(1, g_heads, 256, 0, "Number of heads");
2841 update_units();
2842 break;
2843 case 'i':
2844 if (LABEL_IS_SUN)
2845 sun_set_ilfact();
2846 break;
2847 case 'o':
2848 if (LABEL_IS_SUN)
2849 sun_set_rspeed();
2850 break;
2851 case 'p':
2852 if (LABEL_IS_SUN)
2853 list_table(1);
2854 else
2855 x_list_table(0);
2856 break;
2857 case 'q':
2858 if (ENABLE_FEATURE_CLEAN_UP)
2859 close_dev_fd();
2860 bb_putchar('\n');
2861 exit(EXIT_SUCCESS);
2862 case 'r':
2863 return;
2864 case 's':
2865 user_sectors = g_sectors = read_int(1, g_sectors, 63, 0, "Number of sectors");
2866 if (dos_compatible_flag) {
2867 sector_offset = g_sectors;
2868 puts("Warning: setting sector offset for DOS "
2869 "compatibility");
2870 }
2871 update_units();
2872 break;
2873 case 'v':
2874 verify();
2875 break;
2876 case 'w':
2877 write_table();
2878 break;
2879 case 'y':
2880 if (LABEL_IS_SUN)
2881 sun_set_pcylcount();
2882 break;
2883 default:
2884 xmenu();
2885 }
2886 }
2887}
2888#endif
2889
2890static int
2891is_ide_cdrom_or_tape(const char *device)
2892{
2893 FILE *procf;
2894 char buf[100];
2895 struct stat statbuf;
2896 int is_ide = 0;
2897
2898
2899
2900
2901
2902
2903
2904
2905 if (!is_prefixed_with(device, "/dev/hd"))
2906 return 0;
2907
2908 snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
2909 procf = fopen_for_read(buf);
2910 if (procf != NULL && fgets(buf, sizeof(buf), procf))
2911 is_ide = (is_prefixed_with(buf, "cdrom") ||
2912 is_prefixed_with(buf, "tape"));
2913 else
2914
2915
2916 if (stat(device, &statbuf) == 0)
2917 is_ide = ((statbuf.st_mode & 0222) == 0);
2918
2919 if (procf)
2920 fclose(procf);
2921 return is_ide;
2922}
2923
2924
2925static void
2926open_list_and_close(const char *device, int user_specified)
2927{
2928 int gb;
2929
2930 disk_device = device;
2931 if (setjmp(listingbuf))
2932 return;
2933 if (!user_specified)
2934 if (is_ide_cdrom_or_tape(device))
2935 return;
2936
2937
2938 errno = 0;
2939 gb = get_boot(TRY_ONLY);
2940 if (gb > 0) {
2941
2942
2943
2944 if (user_specified || errno == EACCES)
2945 bb_perror_msg("can't open '%s'", device);
2946 return;
2947 }
2948
2949 if (gb < 0) {
2950 list_disk_geometry();
2951 if (LABEL_IS_AIX)
2952 goto ret;
2953#if ENABLE_FEATURE_OSF_LABEL
2954 if (bsd_trydev(device) < 0)
2955#endif
2956 printf("Disk %s doesn't contain a valid "
2957 "partition table\n", device);
2958 } else {
2959 list_table(0);
2960#if ENABLE_FEATURE_FDISK_WRITABLE
2961 if (!LABEL_IS_SUN && g_partitions > 4) {
2962 delete_partition(ext_index);
2963 }
2964#endif
2965 }
2966 ret:
2967 close_dev_fd();
2968}
2969
2970
2971
2972static int is_whole_disk(const char *disk)
2973{
2974 unsigned len;
2975 int fd = open(disk, O_RDONLY);
2976
2977 if (fd != -1) {
2978 struct hd_geometry geometry;
2979 int err = ioctl(fd, HDIO_GETGEO, &geometry);
2980 close(fd);
2981 if (!err)
2982 return (geometry.start == 0);
2983 }
2984
2985
2986
2987 len = strlen(disk);
2988 if (len != 0 && isdigit(disk[len - 1]))
2989 return 0;
2990
2991 return 1;
2992}
2993
2994
2995
2996static void
2997list_devs_in_proc_partititons(void)
2998{
2999 FILE *procpt;
3000 char line[100], ptname[100], devname[120];
3001 int ma, mi, sz;
3002
3003 procpt = fopen_or_warn("/proc/partitions", "r");
3004
3005 while (fgets(line, sizeof(line), procpt)) {
3006 if (sscanf(line, " %u %u %u %[^\n ]",
3007 &ma, &mi, &sz, ptname) != 4)
3008 continue;
3009
3010 sprintf(devname, "/dev/%s", ptname);
3011 if (is_whole_disk(devname))
3012 open_list_and_close(devname, 0);
3013 }
3014#if ENABLE_FEATURE_CLEAN_UP
3015 fclose(procpt);
3016#endif
3017}
3018
3019#if ENABLE_FEATURE_FDISK_WRITABLE
3020static void
3021unknown_command(int c)
3022{
3023 printf("%c: unknown command\n", c);
3024}
3025#endif
3026
3027int fdisk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
3028int fdisk_main(int argc UNUSED_PARAM, char **argv)
3029{
3030 unsigned opt;
3031
3032
3033
3034
3035
3036
3037
3038
3039 INIT_G();
3040
3041 close_dev_fd();
3042
3043 opt = getopt32(argv, "b:+C:+H:+lS:+u" IF_FEATURE_FDISK_BLKSIZE("s"),
3044 §or_size, &user_cylinders, &user_heads, &user_sectors);
3045 argv += optind;
3046 if (opt & OPT_b) {
3047
3048
3049
3050
3051 if (sector_size < 512
3052 || sector_size > 0x10000
3053 || (sector_size & (sector_size-1))
3054 ) {
3055 bb_show_usage();
3056 }
3057 sector_offset = 2;
3058 user_set_sector_size = 1;
3059 }
3060 if (user_heads <= 0 || user_heads >= 256)
3061 user_heads = 0;
3062 if (user_sectors <= 0 || user_sectors >= 64)
3063 user_sectors = 0;
3064 if (opt & OPT_u)
3065 display_in_cyl_units = 0;
3066
3067#if ENABLE_FEATURE_FDISK_WRITABLE
3068 if (opt & OPT_l) {
3069 nowarn = 1;
3070#endif
3071 if (*argv) {
3072 listing = 1;
3073 do {
3074 open_list_and_close(*argv, 1);
3075 } while (*++argv);
3076 } else {
3077
3078
3079 list_devs_in_proc_partititons();
3080 }
3081 return 0;
3082#if ENABLE_FEATURE_FDISK_WRITABLE
3083 }
3084#endif
3085
3086#if ENABLE_FEATURE_FDISK_BLKSIZE
3087 if (opt & OPT_s) {
3088 int j;
3089
3090 nowarn = 1;
3091 if (!argv[0])
3092 bb_show_usage();
3093 for (j = 0; argv[j]; j++) {
3094 unsigned long long size;
3095 fd = xopen(argv[j], O_RDONLY);
3096 size = bb_BLKGETSIZE_sectors(fd) / 2;
3097 close(fd);
3098 if (argv[1])
3099 printf("%llu\n", size);
3100 else
3101 printf("%s: %llu\n", argv[j], size);
3102 }
3103 return 0;
3104 }
3105#endif
3106
3107#if ENABLE_FEATURE_FDISK_WRITABLE
3108 if (!argv[0] || argv[1])
3109 bb_show_usage();
3110
3111 disk_device = argv[0];
3112 get_boot(OPEN_MAIN);
3113
3114 if (LABEL_IS_OSF) {
3115
3116 printf("Detected an OSF/1 disklabel on %s, entering "
3117 "disklabel mode\n", disk_device);
3118 bsd_select();
3119
3120 current_label_type = LABEL_DOS;
3121
3122 }
3123
3124 while (1) {
3125 int c;
3126 bb_putchar('\n');
3127 c = 0x20 | read_nonempty("Command (m for help): ");
3128 switch (c) {
3129 case 'a':
3130 if (LABEL_IS_DOS)
3131 toggle_active(get_partition(1, g_partitions));
3132 else if (LABEL_IS_SUN)
3133 toggle_sunflags(get_partition(1, g_partitions),
3134 0x01);
3135 else if (LABEL_IS_SGI)
3136 sgi_set_bootpartition(
3137 get_partition(1, g_partitions));
3138 else
3139 unknown_command(c);
3140 break;
3141 case 'b':
3142 if (LABEL_IS_SGI) {
3143 printf("\nThe current boot file is: %s\n",
3144 sgi_get_bootfile());
3145 if (read_maybe_empty("Please enter the name of the "
3146 "new boot file: ") == '\n')
3147 puts("Boot file unchanged");
3148 else
3149 sgi_set_bootfile(line_ptr);
3150 }
3151#if ENABLE_FEATURE_OSF_LABEL
3152 else
3153 bsd_select();
3154#endif
3155 break;
3156 case 'c':
3157 if (LABEL_IS_DOS)
3158 toggle_dos_compatibility_flag();
3159 else if (LABEL_IS_SUN)
3160 toggle_sunflags(get_partition(1, g_partitions),
3161 0x10);
3162 else if (LABEL_IS_SGI)
3163 sgi_set_swappartition(
3164 get_partition(1, g_partitions));
3165 else
3166 unknown_command(c);
3167 break;
3168 case 'd':
3169 {
3170 int j;
3171
3172
3173
3174
3175 if (!LABEL_IS_SGI) {
3176 j = get_existing_partition(1, g_partitions);
3177 } else {
3178 j = get_partition(1, g_partitions);
3179 }
3180 if (j >= 0)
3181 delete_partition(j);
3182 }
3183 break;
3184 case 'i':
3185 if (LABEL_IS_SGI)
3186 create_sgiinfo();
3187 else
3188 unknown_command(c);
3189 case 'l':
3190 list_types(get_sys_types());
3191 break;
3192 case 'm':
3193 menu();
3194 break;
3195 case 'n':
3196 new_partition();
3197 break;
3198 case 'o':
3199 create_doslabel();
3200 break;
3201 case 'p':
3202 list_table(0);
3203 break;
3204 case 'q':
3205 if (ENABLE_FEATURE_CLEAN_UP)
3206 close_dev_fd();
3207 bb_putchar('\n');
3208 return 0;
3209 case 's':
3210#if ENABLE_FEATURE_SUN_LABEL
3211 create_sunlabel();
3212#endif
3213 break;
3214 case 't':
3215 change_sysid();
3216 break;
3217 case 'u':
3218 change_units();
3219 break;
3220 case 'v':
3221 verify();
3222 break;
3223 case 'w':
3224 write_table();
3225 break;
3226#if ENABLE_FEATURE_FDISK_ADVANCED
3227 case 'x':
3228 if (LABEL_IS_SGI) {
3229 puts("\n\tSorry, no experts menu for SGI "
3230 "partition tables available\n");
3231 } else
3232 xselect();
3233 break;
3234#endif
3235 default:
3236 unknown_command(c);
3237 menu();
3238 }
3239 }
3240 return 0;
3241#endif
3242}
3243