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