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