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