1 /* fdisk.c - fdisk program to modify partitions on disk.
2 *
3 * Copyright 2012 Ashwini Kumar <ak.ashwini@gmail.com>
4 * Copyright 2013 Kyungwan Han <asura321@gmail.com>
5 *
6 * No Standard.
7
8 USE_FDISK(NEWTOY(fdisk, "C#<0H#<0S#<0b#<512ul", TOYFLAG_SBIN))
9
10 config FDISK
11 bool "fdisk"
12 default n
13 help
14 usage: fdisk [-lu] [-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SECTSZ] DISK
15
16 Change partition table
17
18 -u Start and End are in sectors (instead of cylinders)
19 -l Show partition table for each DISK, then exit
20 -b size sector size (512, 1024, 2048 or 4096)
21 -C CYLINDERS Set number of cylinders/heads/sectors
22 -H HEADS
23 -S SECTORS
24 */
25
26 #define FOR_fdisk
27 #include "toys.h"
28 #include <linux/hdreg.h>
29
30 GLOBALS(
31 long sect_sz;
32 long sectors;
33 long heads;
34 long cylinders;
35 )
36
37 #define EXTENDED 0x05
38 #define WIN98_EXTENDED 0x0f
39 #define LINUX_NATIVE 0x83
40 #define LINUX_EXTENDED 0x85
41
42 #define SECTOR_SIZE 512
43 #define ONE_K 1024
44 #define PARTITION_MAX 60 //partition max is modifiable
45 #define IS_EXTENDED(i) ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
46 #define sector(s) ((s) & 0x3f)
47 #define cylinder(s, c) ((c) | (((s) & 0xc0) << 2))
48
49 typedef off_t sector_t;
50
51 struct partition {
52 unsigned char boot_ind, head, sector, cyl, sys_ind, end_head,
53 end_sector, end_cyl, start4[4], size4[4];
54 };
55
56 struct part_entry {
57 struct partition *part;
58 char *sec_buffer;
59 sector_t start_offset;
60 int modified;
61 };
62
63 struct part_types {
64 int id;
65 char type[24];
66 } sys_types[] = {
67 {0x00, "Empty"}, {0x01, "FAT12"}, {0x04, "FAT16 <32M"}, {0x05, "Extended"},
68 {0x06, "FAT16"}, {0x07, "HPFS/NTFS"}, {0x0a, "OS/2 Boot Manager"},
69 {0x0b, "Win95 FAT32"}, {0x0c, "Win95 FAT32 (LBA)"}, {0x0e, "Win95 FAT16 (LBA)"},
70 {0x0f, "Win95 Ext'd (LBA)"}, {0x11, "Hidden FAT12"}, {0x12, "Compaq diagnostics"},
71 {0x14, "Hidden FAT16 <32M"}, {0x16, "Hidden FAT16"}, {0x17, "Hidden HPFS/NTFS"},
72 {0x1b, "Hidden Win95 FAT32"}, {0x1c, "Hidden W95 FAT32 (LBA)"}, {0x1e, "Hidden W95 FAT16 (LBA)"},
73 {0x3c, "Part.Magic recovery"}, {0x41, "PPC PReP Boot"}, {0x42, "SFS"},
74 {0x63, "GNU HURD or SysV"}, {0x80, "Old Minix"}, {0x81, "Minix / old Linux"},
75 {0x82, "Linux swap"}, {0x83, "Linux"}, {0x84, "OS/2 hidden C: drive"},
76 {0x85, "Linux extended"}, {0x86, "NTFS volume set"}, {0x87, "NTFS volume set"},
77 {0x8e, "Linux LVM"}, {0x9f, "BSD/OS"}, {0xa0, "Thinkpad hibernation"},
78 {0xa5, "FreeBSD"}, {0xa6, "OpenBSD"}, {0xa8, "Darwin UFS"}, {0xa9, "NetBSD"},
79 {0xab, "Darwin boot"}, {0xb7, "BSDI fs"}, {0xb8, "BSDI swap"},
80 {0xbe, "Solaris boot"}, {0xeb, "BeOS fs"}, {0xee, "EFI GPT"},
81 {0xef, "EFI (FAT-12/16/32)"}, {0xf0, "Linux/PA-RISC boot"},
82 {0xf2, "DOS secondary"}, {0xfd, "Linux raid autodetect"},
83 };
84
85 static int num_parts, disp_unit_cyl, dos_flag, dev_fd = 3;
86 static long g_cylinders, g_heads, g_sectors, g_sect_size;
87 static sector_t total_number_sectors, extended_offset;
88 static char MBRbuf[2048], *disk_device;
89 struct part_entry partitions[PARTITION_MAX];
90
part_offset(char * secbuf,int i)91 static struct partition* part_offset(char *secbuf, int i)
92 {
93 return (struct partition*)(secbuf + 0x1be + i*(sizeof(struct partition)));
94 }
95
set_levalue(unsigned char * cp,sector_t value)96 static void set_levalue(unsigned char *cp, sector_t value )
97 {
98 uint32_t val = SWAP_LE32(value);
99 memcpy(cp, (void*)&val, 4);
100 }
101
set_hsc(struct partition * p,sector_t start,sector_t end)102 static void set_hsc(struct partition *p, sector_t start, sector_t end)
103 {
104 if (dos_flag && (start / (g_sectors * g_heads) > 1023))
105 start = g_heads * g_sectors * ONE_K - 1;
106 p->sector = (start % g_sectors) + 1;
107 start /= g_sectors;
108 p->head = start % g_heads;
109 start /= g_heads;
110 p->cyl = start & 0xFF;
111 p->sector |= (start >> 2) & 0xc0;
112
113 if (dos_flag && (end / (g_sectors * g_heads) > 1023))
114 end = g_heads * g_sectors * ONE_K - 1;
115 p->end_sector = (end % g_sectors) + 1;
116 end /= g_sectors;
117 p->end_head = end % g_heads;
118 end /= g_heads;
119 p->end_cyl = end & 0xFF;
120 p->end_sector |= (end >> 2) & 0xc0;
121 }
122
chs_warn(void)123 static int chs_warn(void)
124 {
125 if (g_heads && g_sectors && g_cylinders)
126 return 0;
127
128 printf("Unknown value(s) for:");
129 if (!g_heads) printf(" heads");
130 if (!g_sectors) printf(" sectors");
131 if (!g_cylinders) printf(" cylinders");
132 printf(". can set in the expert menu.\n");
133 return 1;
134 }
135
list_types(void)136 static void list_types(void)
137 {
138 int i, adjust = 0, size = ARRAY_LEN(sys_types);
139
140 if(size % 2) adjust = 1;
141 for (i = 0; i < (size - adjust); i+=2)
142 xprintf("%2x %-22s\t\t%2x %-22.22s\n", sys_types[i].id, sys_types[i].type,
143 sys_types[i+1].id, sys_types[i+1].type);
144 if (adjust) xprintf("%2x %-22s\n",sys_types[size-1].id, sys_types[size-1].type);
145 xputc('\n');
146 }
147
read_sec_sz()148 static void read_sec_sz()
149 {
150 int arg;
151 if (ioctl(dev_fd, BLKSSZGET, &arg) == 0) g_sect_size = arg;
152 if (toys.optflags & FLAG_b) {
153 if (TT.sect_sz != 512 && TT.sect_sz != 1024 && TT.sect_sz != 2048 &&
154 TT.sect_sz != 4096)
155 {
156 help_exit("bad sector size");
157 }
158 g_sect_size = TT.sect_sz;
159 }
160 }
161
read_size()162 static sector_t read_size()
163 {
164 uint64_t sec64 = 0;
165 unsigned long sectors = 0;
166 if (ioctl(dev_fd, BLKGETSIZE64, &sec64) == 0) {
167 sec64 = sec64 >> 9; //convert to 512 block size.
168 if (sec64 != (uint32_t) sec64) {
169 perror_msg("device has more than 2^32 sectors, can't use all of them");
170 sec64 = (uint32_t) - 1L;
171 }
172 return sec64;
173 }
174 if (ioctl(dev_fd, BLKGETSIZE, §ors) == 0)
175 if (sizeof(long) > sizeof(sector_t) && sectors != (sector_t)sectors)
176 sectors = (uint32_t) - 1L;
177 return sectors;
178 }
179
validate_part_buff(char * buffer)180 static int validate_part_buff(char *buffer)
181 {
182 if ((buffer[510] != 0x55) || (buffer[511] != 0xAA)) return 0;
183 return 1;
184 }
185
is_partition_clear(struct partition * p)186 static int is_partition_clear(struct partition* p)
187 {
188 int i = 0;
189 unsigned char res = 0;
190 const char *ptr = (const char*)p;
191
192 for (i = 0; i < sizeof(struct partition); i++) res |= (unsigned char)ptr[i];
193 return (res == 0x00);
194 }
195
swap_le32toh(unsigned char * cp)196 static uint32_t swap_le32toh(unsigned char *cp)
197 {
198 uint32_t val;
199 memcpy((void*)&val, cp, 4);
200 return le32toh(val);
201 }
202
check_order(void)203 static int check_order(void)
204 {
205 sector_t first[num_parts], last_seen_val = 0;
206 int i;
207 struct part_entry *pe;
208 struct partition *px;
209
210 for (i = 0; i < num_parts; i++) {
211 if (i == 4) last_seen_val = 0;
212 pe = &partitions[i];
213 px = pe->part;
214 if (px->sys_ind) {
215 first[i] = swap_le32toh(px->start4) + pe->start_offset;
216 if (last_seen_val > first[i]) return 1;
217 last_seen_val = first[i];
218 }
219 }
220 return 0;
221 }
222
read_geometry(struct hd_geometry * disk)223 static void read_geometry(struct hd_geometry *disk)
224 {
225 struct hd_geometry geometry;
226
227 if (ioctl(dev_fd, HDIO_GETGEO, &geometry)) return;
228 disk->heads = geometry.heads;
229 disk->sectors = geometry.sectors;
230 }
231
232 /* Read the extended boot record for the
233 * logical partion details.
234 */
read_ebr(int idx)235 static void read_ebr(int idx)
236 {
237 char *sec_buf = NULL;
238 sector_t offset = 0, local_start_off = 0;
239 struct partition *p, *q;
240
241 q = p = partitions[idx].part;
242 local_start_off = swap_le32toh(p->start4);
243
244 if (!extended_offset) extended_offset = local_start_off;
245 do {
246 if (num_parts >= 60) {
247 xprintf("Warning: deleting partitions after 60\n");
248 memset(q, 0, sizeof(struct partition)); //clear_partition
249 partitions[num_parts-1].modified = 1;
250 break;
251 }
252
253 sec_buf = xzalloc(g_sect_size);
254 partitions[num_parts].part = part_offset(sec_buf, 0);
255 partitions[num_parts].sec_buffer = sec_buf;
256 offset = swap_le32toh(q->start4);
257
258 if (num_parts > 4) offset += local_start_off;
259 partitions[num_parts].start_offset = offset;
260 xlseek(dev_fd, (off_t)(offset * g_sect_size), SEEK_SET);
261
262 if (g_sect_size != readall(dev_fd, sec_buf, g_sect_size)) {
263 close(dev_fd);
264 error_exit("Couldn't read sector zero\n");
265 }
266 num_parts++; //extended partions present.
267 q = part_offset(sec_buf, 1);
268 } while (!is_partition_clear(q) && IS_EXTENDED(q->sys_ind));
269 }
270
physical_HS(int * h,int * s)271 static void physical_HS(int* h, int *s)
272 {
273 struct partition *p;
274 int i, end_h, end_s, e_hh = 0, e_ss = 0, ini = 1, dirty = 0;
275 const unsigned char *bufp = (const unsigned char *)MBRbuf;
276
277 if (!(validate_part_buff((char*)bufp))) return;
278
279 for (i = 0; i < 4; i++) {
280 p = part_offset((char*)bufp, i);
281 if (p->sys_ind) {
282 end_h = p->end_head + 1;
283 end_s = (p->end_sector & 077);
284 if (ini) {
285 e_hh = end_h;
286 e_ss = end_s;
287 ini = 0;
288 } else if (e_hh !=end_h || e_ss != end_s)
289 dirty = 1;
290 }
291 }
292 if (!dirty && !ini) {
293 *h = e_hh;
294 *s = e_ss;
295 }
296 }
297
298 //Reset the primary partition table
reset_boot(int change)299 static void reset_boot(int change)
300 {
301 int i;
302 for(i = 0; i < 4; i++) {
303 struct part_entry *pe = &partitions[i];
304 pe->part = part_offset(MBRbuf, i);
305 pe->start_offset = 0;
306 pe->sec_buffer = MBRbuf;
307 pe->modified = change;
308 }
309 }
310
write_table_flag(char * buf)311 static inline void write_table_flag(char *buf)
312 {
313 buf[510] = 0x55;
314 buf[511] = 0xaa;
315 }
316
317 /* free the buffers used for holding details of
318 * extended logical partions
319 */
free_bufs(void)320 static void free_bufs(void)
321 {
322 int i = 4;
323 for (; i < num_parts; i++) free(partitions[i].sec_buffer);
324 }
325
create_empty_doslabel(void)326 static void create_empty_doslabel(void)
327 {
328 xprintf("Building a new DOS Disklabel. The changes will\n"
329 "remain in memory only, until you write it.\n");
330
331 num_parts = 4;
332 extended_offset = 0;
333 memset(&MBRbuf[510 - 4*16], 0, 4*16);
334 write_table_flag(MBRbuf);
335 partitions[0].modified = 1;
336 reset_boot(1);
337 }
338
339 /* Read the Master Boot sector of the device for the
340 * partition table entries/details.
341 * If any extended partition is found then read the EBR
342 * for logical partition details
343 */
read_mbr(char * device,int validate)344 static int read_mbr(char *device, int validate)
345 {
346 int fd, sector_fac, i, h = 0, s = 0;
347 struct hd_geometry disk;
348 fd = open(device, O_RDWR);
349 if(fd < 0) {
350 perror_msg("can't open '%s'",device);
351 return 1;
352 }
353
354 disk_device = strdup(device);
355 if(fd != dev_fd) {
356 if(dup2(fd, dev_fd) != dev_fd) perror_exit("Can't dup2");
357 close(fd);
358 }
359
360 //read partition table - MBR
361 if (SECTOR_SIZE != readall(dev_fd, MBRbuf, SECTOR_SIZE)) {
362 close(dev_fd);
363 perror_exit("Couldn't read sector zero\n");
364 }
365 if (validate && !validate_part_buff(MBRbuf)) {
366 xprintf("Device contains neither a valid DOS "
367 "partition table, nor Sun, SGI, OSF or GPT "
368 "disklabel\n");
369 create_empty_doslabel();
370 }
371
372 disk.heads = disk.sectors = 0;
373 read_geometry(&disk); //CHS values
374 total_number_sectors = read_size(); //Device size
375 read_sec_sz();
376 sector_fac = g_sect_size/SECTOR_SIZE; //512 is hardware sector size.
377 physical_HS(&h, &s); //physical dimensions may be diferent from HDIO_GETGEO
378 g_sectors = (toys.optflags & FLAG_S && TT.sectors)? TT.sectors : s? s : disk.sectors?disk.sectors : 63;
379 g_heads = (toys.optflags & FLAG_H && TT.heads)? TT.heads : h? h : disk.heads? disk.heads : 255;
380 g_cylinders = total_number_sectors/(g_heads * g_sectors * sector_fac);
381
382 if (!g_cylinders) g_cylinders = toys.optflags & FLAG_C? TT.cylinders : 0;
383 if ((g_cylinders > ONE_K) && !(toys.optflags & (FLAG_l | FLAG_S)))
384 xprintf("\nThe number of cylinders for this disk is set to %lu.\n"
385 "There is nothing wrong with that, but this is larger than 1024,\n"
386 "and could in certain setups cause problems.\n", g_cylinders);
387 for (i = 0; i < num_parts; i++) {
388 if (IS_EXTENDED(partitions[i].part->sys_ind)) {
389 read_ebr(i);
390 break;
391 }
392 }
393 chs_warn();
394
395 return 0;
396 }
397
get_type(int sys_ind)398 static char* get_type(int sys_ind)
399 {
400 int i, size = ARRAY_LEN(sys_types);
401 for (i = 0; i < size; i++)
402 if (sys_ind == sys_types[i].id)
403 return sys_types[i].type;
404 return "Unknown";
405 }
406
consistency_check(const struct partition * p,int partition)407 static void consistency_check(const struct partition *p, int partition)
408 {
409 unsigned physbc, physbh, physbs, physec, physeh, physes;
410 unsigned lbc, lbh, lbs, lec, leh, les;
411 sector_t start, end;
412
413 if (!g_heads || !g_sectors || (partition >= 4)) return;
414 // physical beginning c, h, s
415 physbc = cylinder(p->sector,p->cyl);
416 physbh = p->head;
417 physbs = sector(p->sector);
418 // physical ending c, h, s
419 physec = cylinder(p->end_sector, p->end_cyl);
420 physeh = p->end_head;
421 physes = sector(p->end_sector);
422 // logical begin and end CHS values
423 start = swap_le32toh((unsigned char*)(p->start4));
424 end = start + swap_le32toh((unsigned char*)(p->size4)) -1;
425
426 lbc = start/(g_sectors * g_heads);
427 lbh = (start/g_sectors) % g_heads;
428 lbs = (start % g_sectors) + 1;
429
430 lec = end/(g_sectors * g_heads);
431 leh = (end/g_sectors) % g_heads;
432 les = (end % g_sectors) + 1;
433
434 //Logical and Physical diff
435 if (g_cylinders <= ONE_K && (physbc != lbc || physbh != lbh || physbs != lbs)) {
436 xprintf("Partition %u has different physical/logical beginings (Non-Linux?): \n", partition+1);
437 xprintf("phys = (%u %u %u) ",physbc, physbh, physbs);
438 xprintf("logical = (%u %u %u)\n", lbc, lbh, lbs);
439 }
440 if (g_cylinders <= ONE_K && (physec != lec || physeh != leh || physes != les)) {
441 xprintf("Partition %u has different physical/logical endings: \n", partition+1);
442 xprintf("phys = (%u %u %u) ",physec, physeh, physes);
443 xprintf("logical = (%u %u %u)\n", lec, leh, les);
444 }
445 // Ending on cylinder boundary?
446 if (physeh != (g_heads - 1) || physes != g_sectors)
447 xprintf("Partition %u does not end on cylinder boundary\n", partition + 1);
448 }
449
450 // List the partition details
list_partitions(int validate)451 static void list_partitions(int validate)
452 {
453 struct partition *p;
454 uint32_t start_cyl, end_cyl, start_sec, end_sec, blocks, secs;
455 char boot, lastchar = '\0', *dev = disk_device;
456 int i = 0, len = strlen(disk_device), odds = 0;
457
458 if (validate && !validate_part_buff(MBRbuf)) {
459 close(dev_fd);
460 toys.exitval = 1;
461 xprintf("Device %s: doesn't contain a valid partition table\n", disk_device);
462 return;
463 }
464 if (isdigit(dev[len - 1])) lastchar = 'p';
465
466 xprintf("%*s Boot Start End Blocks Id System\n", len+1, "Device");
467 for (i = 0; i < num_parts; i++) {
468 p = partitions[i].part;
469 if (is_partition_clear(p)) continue;
470
471 boot = ((p->boot_ind == 0x80)?'*':(!p->boot_ind)?' ':'?');
472 start_sec = swap_le32toh(p->start4) + partitions[i].start_offset;
473 secs = swap_le32toh(p->size4);
474
475 if ((start_sec + secs) == 0) end_sec = 0;
476 else end_sec = start_sec + secs -1;
477 start_cyl = start_sec/(g_heads * g_sectors) + 1;
478 end_cyl = end_sec/(g_heads * g_sectors) + 1;
479 blocks = secs;
480 if (g_sect_size < ONE_K) {
481 blocks /= (ONE_K/g_sect_size);
482 odds = secs %(ONE_K/g_sect_size);
483 } else if (g_sect_size > ONE_K) blocks *= (g_sect_size/ONE_K);
484
485 if (lastchar) xprintf("%s%c%d",dev, lastchar, i+1);
486 else xprintf("%s%d",dev, i+1);
487
488 xprintf(" %c %11u %11u %11u%c %2x %s\n",
489 boot,
490 disp_unit_cyl == 0? start_sec: start_cyl,
491 disp_unit_cyl == 0? end_sec: end_cyl,
492 blocks,odds?'+':' ', p->sys_ind, get_type(p->sys_ind));
493
494 consistency_check(p, i);
495 }
496 if (check_order()) xprintf("\nPartition table entries are not in disk order");
497 }
498
499 //Print device details
print_mbr(int validate)500 static void print_mbr(int validate)
501 {
502 unsigned long long bytes = ((unsigned long long)total_number_sectors << 9);
503 long mbytes = bytes/1000000;
504
505 if (mbytes < 10000) xprintf("Disk %s: %lu MB, %llu bytes\n", disk_device, mbytes, bytes);
506 else xprintf("Disk %s: %lu.%lu GB, %llu bytes\n", disk_device, mbytes/1000, (mbytes/100)%10, bytes);
507 xprintf("%ld heads, %ld sectors/track, %ld cylinders", g_heads, g_sectors, g_cylinders);
508 if (!disp_unit_cyl) {
509 xprintf(", total %lld sectors\n", total_number_sectors/(g_sect_size/SECTOR_SIZE));
510 xprintf("Units = sectors of 1 * %ld = %ld bytes\n",g_sect_size, g_sect_size);
511 } else xprintf("\nUnits = cylinders of %ld * %ld = %ld bytes\n\n",
512 g_heads * g_sectors, g_sect_size, g_heads * g_sectors * g_sect_size);
513 list_partitions(validate);
514 xputc('\n');
515 }
516
init_members(void)517 static void init_members(void)
518 {
519 int i = 0;
520 num_parts = 4; //max of primaries in a part table
521 disp_unit_cyl = dos_flag = 1;
522 extended_offset = 0;
523 g_sect_size = SECTOR_SIZE;
524 for (i = 0; i < num_parts; i++) {
525 partitions[i].part = part_offset(MBRbuf, i);
526 partitions[i].sec_buffer = MBRbuf;
527 partitions[i].modified = 0;
528 partitions[i].start_offset = 0;
529 }
530 }
531
read_input(char * mesg,char * outp)532 static int read_input(char *mesg, char *outp)
533 {
534 char *p;
535 int size = 0;
536 do {
537 xprintf("%s", mesg);
538 p = fgets(toybuf, 80, stdin);
539
540 if (!p || !(size = strlen(p))) exit(0);
541 if (p[size-1] == '\n') p[--size] = '\0';
542 } while (!size);
543
544 while (*p != '\0' && *p <= ' ') p++;
545 if (outp) memcpy(outp, p, strlen(p) + 1); //1 for nul
546 return *p;
547 }
548
read_hex(char * mesg)549 static int read_hex(char *mesg)
550 {
551 int val;
552 char input[80], *endp;
553 while (1) {
554 read_input(mesg, input);
555 if ((*input | 0x20) == 'l') {
556 list_types();
557 memset(input, 0, 80);
558 continue;
559 }
560 val = strtoul(input, &endp, 16);
561 if (endp && *endp) continue;
562 if (val <= 0xff) return val;
563 }
564 }
565
566 /* Delete an exiting partition,
567 * if its primary, then just clear the partition details
568 * if extended, then clear the partition details, also for logical
569 * if only logical, then move the later partitions backwards 1 step
570 */
delete_partition(int i)571 void delete_partition(int i)
572 {
573 int sys_id, looper = 0;
574 struct partition *p, *q, *ext_p, *ext_q;
575 sector_t new_start;
576 struct part_entry *pe = &partitions[i];
577
578 if (chs_warn()) return;
579 p = pe->part;
580 sys_id = p->sys_ind;
581 if (!sys_id) xprintf("Partition %u is empty\n", i+1);
582
583 if (i < 4 && !IS_EXTENDED(sys_id)) {
584 memset(p, 0, sizeof(struct partition)); //clear_partition
585 pe->modified = 1;
586 } else if (i < 4 && IS_EXTENDED(sys_id)) {
587 memset(p, 0, sizeof(struct partition)); //clear_partition
588 pe->modified = 1;
589 for (looper = 4; looper < num_parts; looper++) {
590 pe = &partitions[looper];
591 p = pe->part;
592 if (is_partition_clear(p)) break;
593 else {
594 memset(p, 0, sizeof(struct partition)); //clear_partition
595 pe->modified = 1;
596 free(pe->sec_buffer);
597 }
598 }
599 extended_offset = 0;
600 num_parts = 4;
601 } else {
602 //only logical is delete, need to move the rest of them backwards
603 if (i == 4) { //move partiton# 6 to 5.
604 partitions[i].modified = 1;
605 if (num_parts > i+1) {
606 q = partitions[i + 1].part;
607 *p = *q; //copy the part table
608 ext_p = part_offset(partitions[i].sec_buffer, 1);
609 ext_q = part_offset(partitions[i + 1].sec_buffer, 1);
610 *ext_p = *ext_q; //copy the extended info pointer
611 // change the start of the 4th partiton.
612 new_start = partitions[i + 1].start_offset + swap_le32toh(q->start4) - extended_offset;
613 new_start = SWAP_LE32(new_start);
614 memcpy(p->start4, (void *)&new_start, 4);
615 } else {
616 memset(partitions[i].part, 0, sizeof(struct partition));
617 return; //only logical
618 }
619 } else if (i > 4) {
620 ext_p = part_offset(partitions[i-1].sec_buffer, 1);
621 ext_q = part_offset(partitions[i].sec_buffer, 1);
622 memcpy((void*)ext_p, (void *)ext_q, sizeof(struct partition));
623 partitions[i-1].modified = 1;
624 }
625 if (i == 4) looper = i+2;
626 else if (i > 4) looper = i+1;
627 for (; looper < num_parts; looper++)
628 partitions[looper-1] = partitions[looper];
629 num_parts--;
630 }
631 }
632
ask_partition(int num_parts)633 static int ask_partition(int num_parts)
634 {
635 int val;
636 while (1) {
637 do {
638 xprintf("Partition (%u - %u):", 1, num_parts);
639 fgets(toybuf, 80, stdin);
640 } while (!isdigit(*toybuf));
641 val = atoi(toybuf);
642 if (val > 0 && val <= num_parts) return val;
643 else xprintf("Invalid number entered\n");
644 }
645 }
646
toggle_active_flag(int i)647 static void toggle_active_flag(int i)
648 {
649 struct partition *p = partitions[i].part;
650 if (is_partition_clear(p)) xprintf("Partition %u is empty\n", i+1);
651
652 if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
653 xprintf("WARNING: Partition %u is an extended partition\n", i + 1);
654 p->boot_ind = p->boot_ind == 0x80?0 : 0x80;
655 partitions[i].modified = 1;
656 }
657
658 //Write the partition details from Buffer to Disk.
write_table(void)659 void write_table(void)
660 {
661 int i =0;
662 struct part_entry *pe;
663 sector_t offset;
664
665 for (i = 0; i < 4; i++)
666 if (partitions[i].modified) partitions[3].modified = 1;
667
668 for (i = 3; i < num_parts; i++) {
669 pe = &partitions[i];
670 write_table_flag(pe->sec_buffer);
671 offset = pe->start_offset;
672 if (pe->modified == 1) {
673 xlseek(dev_fd, offset * g_sect_size, SEEK_SET);
674 xwrite(dev_fd, pe->sec_buffer, g_sect_size);
675 }
676 }
677 xprintf("The partition table has been altered.\n");
678 xprintf("Calling ioctl() to re-read partition table\n");
679 sync();
680 for (i = 4; i < num_parts; i++) free(partitions[i].sec_buffer);
681 if(ioctl(dev_fd, BLKRRPART, NULL) < 0)
682 perror_exit("WARNING: rereading partition table failed, kernel still uses old table");
683
684 }
685
686 /* try to find a partition for deletion, if only
687 * one, then select the same, else ask from USER
688 */
get_non_free_partition(int max)689 static int get_non_free_partition(int max)
690 {
691 int num = -1, i = 0;
692
693 for (i = 0; i < max; i++) {
694 if (!is_partition_clear(partitions[i].part)) {
695 if (num >= 0)
696 return ask_partition(num_parts)-1;
697 num = i;
698 }
699 }
700 (num >= 0) ? xprintf("Selected partition %d\n",num+1):
701 xprintf("No partition is defined yet!\n");
702 return num;
703 }
704
705 /* a try at autodetecting an empty partition table entry,
706 * if multiple options then get USER's choce.
707 */
get_free_partition(int max)708 static int get_free_partition(int max)
709 {
710 int num = -1, i = 0;
711
712 for (i = 0; i < max; i++) {
713 if (is_partition_clear(partitions[i].part)) {
714 if (num >= 0)
715 return ask_partition(4)-1;
716 num = i;
717 }
718 }
719 (num >= 0) ? xprintf("Selected partition %d\n",num+1):
720 xprintf("All primary partitions have been defined already!\n");
721 return num;
722 }
723
724 //taking user input for partition start/end sectors/cyinders
ask_value(char * mesg,sector_t left,sector_t right,sector_t defalt)725 static uint32_t ask_value(char *mesg, sector_t left, sector_t right, sector_t defalt)
726 {
727 char *str = toybuf;
728 uint32_t val;
729 int use_default = 1;
730
731 while (1) {
732 use_default = 1;
733 do {
734 xprintf("%s",mesg);
735 fgets(str, 80, stdin);
736 } while (!isdigit(*str) && (*str != '\n')
737 && (*str != '-') && (*str != '+') && (!isblank(*str)));
738 while (isblank(*str)) str++; //remove leading white spaces
739 if (*str == '+' || *str == '-') {
740 int minus = (*str == '-');
741 int absolute = 0;
742
743 val = atoi(str + 1);
744 while (isdigit(*++str)) use_default = 0;
745
746 switch (*str) {
747 case 'c':
748 case 'C':
749 if (!disp_unit_cyl) val *= g_heads * g_sectors;
750 break;
751 case 'K':
752 absolute = ONE_K;
753 break;
754 case 'k':
755 absolute = 1000;
756 break;
757 case 'm':
758 case 'M':
759 absolute = 1000000;
760 break;
761 case 'g':
762 case 'G':
763 absolute = 1000000000;
764 break;
765 default:
766 break;
767 }
768 if (absolute) {
769 unsigned long long bytes = (unsigned long long) val * absolute;
770 unsigned long unit = (disp_unit_cyl && (g_heads * g_sectors))? g_heads * g_sectors : 1;
771
772 unit = unit * g_sect_size;
773 bytes += unit/2; // rounding
774 bytes /= unit;
775 val = bytes;
776 }
777 if (minus)
778 val = -val;
779 val += left;
780 } else {
781 val = atoi(str);
782 while (isdigit(*str)) {
783 str++;
784 use_default = 0;
785 }
786 }
787 if(use_default) {
788 val = defalt;
789 xprintf("Using default value %lld\n", defalt);
790 }
791 if (val >= left && val <= right) return val;
792 else xprintf("Value out of range\n");
793 }
794 }
795
796 //validating if the start given falls in a limit or not
validate(int start_index,sector_t * begin,sector_t * end,sector_t start,int asked)797 static int validate(int start_index, sector_t* begin,sector_t* end, sector_t start
798 , int asked)
799 {
800 int i, valid = 0;
801 for (i = start_index; i < num_parts; i++) {
802 if (start >= begin[i] && start <= end[i]) {
803 if (asked) xprintf("Sector %lld is already allocated\n",start);
804 valid = 0;
805 break;
806 } else valid = 1;
807 }
808 return valid;
809 }
810
811 //get the start sector/cylinder of a new partition
ask_start_sector(int idx,sector_t * begin,sector_t * end,int ext_idx)812 static sector_t ask_start_sector(int idx, sector_t* begin, sector_t* end, int ext_idx)
813 {
814 sector_t start, limit, temp = 0, start_cyl, limit_cyl, offset = 1;
815 char mesg[256];
816 int i, asked = 0, valid = 0, start_index = 0;
817
818 if (dos_flag) offset = g_sectors;
819 start = offset;
820 if (disp_unit_cyl) limit = (sector_t)g_sectors * g_heads * g_cylinders - 1;
821 else limit = total_number_sectors - 1;
822
823 if (disp_unit_cyl) //make the begin of every partition to cylnder boundary
824 for (i = 0; i < num_parts; i++)
825 begin[i] = (begin[i]/(g_heads* g_sectors)) * (g_heads* g_sectors);
826
827 if (idx >= 4) {
828 if (!begin[ext_idx] && extended_offset) begin[ext_idx] = extended_offset;
829 start = begin[ext_idx] + offset;
830 limit = end[ext_idx];
831 start_index = 4;
832 }
833 do {
834 if (asked) valid = validate(start_index, begin, end, start, asked);
835 if (valid) break;
836
837 do {
838 for (i = start_index; i < num_parts; i++)
839 if (start >= begin[i] && start <= end[i])
840 start = end[i] + 1 + ((idx >= 4)? offset : 0);
841 } while (!validate(start_index, begin, end, start, 0));
842
843 start_cyl = start/(g_sectors * g_heads) + 1;
844 limit_cyl = limit/(g_sectors * g_heads) + 1;
845
846 if (start > limit) break;
847 sprintf(mesg, "First %s (%lld - %lld, default %lld): ", disp_unit_cyl? "cylinder" : "sector",
848 (long long int)(disp_unit_cyl? start_cyl : start),
849 (long long int)(disp_unit_cyl? limit_cyl : limit),
850 (long long int)(disp_unit_cyl? start_cyl : start));
851 temp = ask_value(mesg, disp_unit_cyl? start_cyl : start,
852 disp_unit_cyl? limit_cyl : limit, disp_unit_cyl? start_cyl : start);
853 asked = 1;
854
855 if (disp_unit_cyl) {
856 // point to the cylinder start sector
857 temp = (temp-1) * g_heads * g_sectors;
858 if (temp < start) //the boundary is falling in the already used sectors.
859 temp = start;
860 }
861 start = temp;
862 } while (asked && !valid);
863 return start;
864 }
865
866 //get the end sector/cylinder of a new partition
ask_end_sector(int idx,sector_t * begin,sector_t * end,int ext_idx,sector_t start_sec)867 static sector_t ask_end_sector(int idx, sector_t* begin, sector_t* end, int ext_idx, sector_t start_sec)
868 {
869 sector_t limit, temp = 0, start_cyl, limit_cyl, start = start_sec;
870 char mesg[256];
871 int i;
872
873 if (disp_unit_cyl) limit = (sector_t)g_sectors * g_heads * g_cylinders - 1;
874 else limit = total_number_sectors - 1;
875
876 if (disp_unit_cyl) //make the begin of every partition to cylnder boundary
877 for (i = 0; i < num_parts; i++)
878 begin[i] = (begin[i]/(g_heads* g_sectors)) * (g_heads* g_sectors);
879
880 if (idx >= 4) limit = end[ext_idx];
881
882 for (i = 0; i < num_parts; i++) {
883 struct part_entry *pe = &partitions[i];
884 if (start < pe->start_offset && limit >= pe->start_offset) limit = pe->start_offset - 1;
885 if (start < begin[i] && limit >= begin[i]) limit = begin[i] - 1;
886 }
887
888 start_cyl = start/(g_sectors * g_heads) + 1;
889 limit_cyl = limit/(g_sectors * g_heads) + 1;
890 if (limit < start) { //the boundary is falling in the already used sectors.
891 xprintf("No Free sectors available\n");
892 return 0;
893 }
894 sprintf(mesg, "Last %s or +size or +sizeM or +sizeK (%lld - %lld, default %lld): ",
895 disp_unit_cyl? "cylinder" : "sector",
896 (long long int)(disp_unit_cyl? start_cyl : start),
897 (long long int)(disp_unit_cyl? limit_cyl : limit),
898 (long long int)(disp_unit_cyl? limit_cyl : limit));
899 temp = ask_value(mesg, disp_unit_cyl? start_cyl : start,
900 disp_unit_cyl? limit_cyl : limit, disp_unit_cyl? limit_cyl : limit);
901
902 if (disp_unit_cyl) { // point to the cylinder start sector
903 temp = temp * g_heads * g_sectors - 1;
904 if (temp > limit) temp = limit;
905 }
906 if (temp < start) { //the boundary is falling in the already used sectors.
907 xprintf("No Free sectors available\n");
908 return 0;
909 }
910 return temp;
911 }
912
913 // add a new partition to the partition table
add_partition(int idx,int sys_id)914 static int add_partition(int idx, int sys_id)
915 {
916 int i, ext_idx = -1;
917 sector_t start, end, begin_sec[num_parts], end_sec[num_parts];
918 struct part_entry *pe = &partitions[idx];
919 struct partition *p = pe->part;
920
921 if (p && !is_partition_clear(p)) {
922 xprintf("Partition %u is already defined, delete it to re-add\n", idx+1);
923 return 0;
924 }
925 for (i = 0; i < num_parts; i++) {
926 pe = &partitions[i];
927 p = pe->part;
928 if (is_partition_clear(p)) {
929 begin_sec[i] = 0xffffffff;
930 end_sec[i] = 0;
931 } else {
932 begin_sec[i] = swap_le32toh(p->start4) + pe->start_offset;
933 end_sec[i] = begin_sec[i] + swap_le32toh(p->size4) - 1;
934 }
935 if (IS_EXTENDED(p->sys_ind)) ext_idx = i;
936 }
937 start = ask_start_sector(idx, begin_sec, end_sec, ext_idx);
938 end = ask_end_sector(idx, begin_sec, end_sec, ext_idx, start);
939 if (!end) return 0;
940 //Populate partition table entry - 16 bytes
941 pe = &partitions[idx];
942 p = pe->part;
943
944 if (idx > 4) {
945 if (dos_flag) pe->start_offset = start - (sector_t)g_sectors;
946 else pe->start_offset = start - 1;
947 if (pe->start_offset == extended_offset) pe->start_offset++;
948 if (!dos_flag) start++;
949 }
950
951 set_levalue(p->start4, start - pe->start_offset);
952 set_levalue(p->size4, end - start + 1);
953 set_hsc(p, start, end);
954 p->boot_ind = 0;
955 p->sys_ind = sys_id;
956 pe->modified = 1;
957
958 if (idx > 4) {
959 p = partitions[idx-1].part + 1; //extended pointer for logical partitions
960 set_levalue(p->start4, pe->start_offset - extended_offset);
961 set_levalue(p->size4, end - start + 1 + (dos_flag? g_sectors: 1));
962 set_hsc(p, pe->start_offset, end);
963 p->boot_ind = 0;
964 p->sys_ind = EXTENDED;
965 partitions[idx-1].modified = 1;
966 }
967 if (IS_EXTENDED(sys_id)) {
968 pe = &partitions[4];
969 pe->modified = 1;
970 pe->sec_buffer = xzalloc(g_sect_size);
971 pe->part = part_offset(pe->sec_buffer, 0);
972 pe->start_offset = extended_offset = start;
973 num_parts = 5;
974 }
975 return 1;
976 }
977
add_logical_partition(void)978 static void add_logical_partition(void)
979 {
980 struct part_entry *pe;
981 if (num_parts > 5 || !is_partition_clear(partitions[4].part)) {
982 pe = &partitions[num_parts];
983 pe->modified = 1;
984 pe->sec_buffer = xzalloc(g_sect_size);
985 pe->part = part_offset(pe->sec_buffer, 0);
986 pe->start_offset = 0;
987 num_parts++;
988 if (!add_partition(num_parts - 1, LINUX_NATIVE)) {
989 num_parts--;
990 free(pe->sec_buffer);
991 }
992 }
993 else add_partition(num_parts -1, LINUX_NATIVE);
994 }
995
996 /* Add a new partiton to the partition table.
997 * MAX partitions limit is taken to be 60, can be changed
998 */
add_new_partition(void)999 static void add_new_partition(void)
1000 {
1001 int choice, idx, i, free_part = 0;
1002 char *msg = NULL;
1003
1004 if (chs_warn()) return;
1005 for (i = 0; i < 4; i++) if(is_partition_clear(partitions[i].part)) free_part++;
1006
1007 if (!free_part && num_parts >= 60) {
1008 xprintf("The maximum number of partitions has been created\n");
1009 return;
1010 }
1011 if (!free_part) {
1012 if (extended_offset) add_logical_partition();
1013 else xprintf("You must delete some partition and add "
1014 "an extended partition first\n");
1015 return;
1016 }
1017
1018 msg = xmprintf(" %s\n p primary partition(1-4)\n",
1019 extended_offset? "l logical (5 or over)" : "e extended");
1020
1021 choice = 0x20 | read_input(msg, NULL);
1022 free(msg);
1023 if (choice == 'p') {
1024 idx = get_free_partition(4);
1025 if (idx >= 0) add_partition(idx, LINUX_NATIVE);
1026 return;
1027 }
1028 if (choice =='l' && extended_offset) {
1029 add_logical_partition();
1030 return;
1031 }
1032 if (choice == 'e' && !extended_offset) {
1033 idx = get_free_partition(4);
1034 if (idx >= 0) add_partition(idx, EXTENDED);
1035 return;
1036 }
1037 }
1038
change_systype(void)1039 static void change_systype(void )
1040 {
1041 int i, sys_id;
1042 struct partition *p;
1043 struct part_entry *pe;
1044
1045 i = ask_partition(num_parts);
1046 pe = &partitions[i-1];
1047 p = pe->part;
1048 if (is_partition_clear(p)) {
1049 xprintf("Partition %d doesn't exist yet!\n", i);
1050 return;
1051 }
1052 sys_id = read_hex("Hex code (L to list codes): ");
1053 if ((IS_EXTENDED(p->sys_ind) && !IS_EXTENDED(sys_id)) ||
1054 (!IS_EXTENDED(p->sys_ind) && IS_EXTENDED(sys_id))) {
1055 xprintf("you can't change a partition to an extended or vice-versa\n");
1056 return;
1057 }
1058
1059 xprintf("Changed system type of partition %u to %0x (%s)\n",i, sys_id, get_type(sys_id));
1060 p->sys_ind = sys_id;
1061 pe->modified = 1;
1062 }
1063
check(int n,unsigned h,unsigned s,unsigned c,sector_t start)1064 static void check(int n, unsigned h, unsigned s, unsigned c, sector_t start)
1065 {
1066 sector_t total, real_s, real_c;
1067
1068 real_s = sector(s) - 1;
1069 real_c = cylinder(s, c);
1070 total = (real_c * g_sectors + real_s) * g_heads + h;
1071 if (!total) xprintf("Partition %u contains sector 0\n", n);
1072 if (h >= g_heads)
1073 xprintf("Partition %u: head %u greater than maximum %lu\n", n, h + 1, g_heads);
1074 if (real_s >= g_sectors)
1075 xprintf("Partition %u: sector %u greater than maximum %lu\n", n, s, g_sectors);
1076 if (real_c >= g_cylinders)
1077 xprintf("Partition %u: cylinder %lld greater than maximum %lu\n", n, real_c + 1, g_cylinders);
1078 if (g_cylinders <= ONE_K && start != total)
1079 xprintf("Partition %u: previous sectors %lld disagrees with total %lld\n", n, start, total);
1080 }
1081
verify_table(void)1082 static void verify_table(void)
1083 {
1084 int i, j, ext_idx = -1;
1085 sector_t begin_sec[num_parts], end_sec[num_parts], total = 1;
1086 struct part_entry *pe;
1087 struct partition *p;
1088
1089 for (i = 0; i < num_parts; i++) {
1090 pe = &partitions[i];
1091 p = pe->part;
1092 if (is_partition_clear(p) || IS_EXTENDED(p->sys_ind)) {
1093 begin_sec[i] = 0xffffffff;
1094 end_sec[i] = 0;
1095 } else {
1096 begin_sec[i] = swap_le32toh(p->start4) + pe->start_offset;
1097 end_sec[i] = begin_sec[i] + swap_le32toh(p->size4) - 1;
1098 }
1099 if (IS_EXTENDED(p->sys_ind)) ext_idx = i;
1100 }
1101 for (i = 0; i < num_parts; i++) {
1102 pe = &partitions[i];
1103 p = pe->part;
1104 if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
1105 consistency_check(p, i);
1106 if ((swap_le32toh(p->start4) + pe->start_offset) < begin_sec[i])
1107 xprintf("Warning: bad start-of-data in partition %u\n", i + 1);
1108 check(i + 1, p->end_head, p->end_sector, p->end_cyl, end_sec[i]);
1109 total += end_sec[i] + 1 - begin_sec[i];
1110 for (j = 0; j < i; j++) {
1111 if ((begin_sec[i] >= begin_sec[j] && begin_sec[i] <= end_sec[j])
1112 || ((end_sec[i] <= end_sec[j] && end_sec[i] >= begin_sec[j]))) {
1113 xprintf("Warning: partition %u overlaps partition %u\n", j + 1, i + 1);
1114 total += begin_sec[i] >= begin_sec[j] ? begin_sec[i] : begin_sec[j];
1115 total -= end_sec[i] <= end_sec[j] ? end_sec[i] : end_sec[j];
1116 }
1117 }
1118 }
1119 }
1120 if (extended_offset) {
1121 struct part_entry *pex = &partitions[ext_idx];
1122 sector_t e_last = swap_le32toh(pex->part->start4) +
1123 swap_le32toh(pex->part->size4) - 1;
1124
1125 for (i = 4; i < num_parts; i++) {
1126 total++;
1127 p = partitions[i].part;
1128 if (!p->sys_ind) {
1129 if (i != 4 || i + 1 < num_parts)
1130 xprintf("Warning: partition %u is empty\n", i + 1);
1131 } else if (begin_sec[i] < extended_offset || end_sec[i] > e_last)
1132 xprintf("Logical partition %u not entirely in partition %u\n", i + 1, ext_idx + 1);
1133 }
1134 }
1135 if (total > g_heads * g_sectors * g_cylinders)
1136 xprintf("Total allocated sectors %lld greater than the maximum "
1137 "%lu\n", total, g_heads * g_sectors * g_cylinders);
1138 else {
1139 total = g_heads * g_sectors * g_cylinders - total;
1140 if (total) xprintf("%lld unallocated sectors\n", total);
1141 }
1142 }
1143
move_begning(int idx)1144 static void move_begning(int idx)
1145 {
1146 sector_t start, num, new_start, end;
1147 char mesg[256];
1148 struct part_entry *pe = &partitions[idx];
1149 struct partition *p = pe->part;
1150
1151 if (chs_warn()) return;
1152 start = swap_le32toh(p->start4) + pe->start_offset;
1153 num = swap_le32toh(p->size4);
1154 end = start + num -1;
1155
1156 if (!num || IS_EXTENDED(p->sys_ind)) {
1157 xprintf("Partition %u doesn't have data area\n", idx+1);
1158 return;
1159 }
1160 sprintf(mesg, "New begining of data (0 - %lld, default %lld): ",
1161 (long long int)(end), (long long int)(start));
1162 new_start = ask_value(mesg, 0, end, start);
1163 if (new_start != start) {
1164 set_levalue(p->start4, new_start - pe->start_offset);
1165 set_levalue(p->size4, end - new_start +1);
1166 if ((read_input("Recalculate C/H/S (Y/n): ", NULL) | 0x20) == 'y')
1167 set_hsc(p, new_start, end);
1168 pe->modified = 1;
1169 }
1170 }
1171
print_raw_sectors()1172 static void print_raw_sectors()
1173 {
1174 int i, j;
1175 struct part_entry *pe;
1176
1177 xprintf("Device: %s\n", disk_device);
1178 for (i = 3; i < num_parts; i++) {
1179 pe = &partitions[i];
1180 for (j = 0; j < g_sect_size; j++) {
1181 if (!(j % 16)) xprintf("\n0x%03X: ",j);
1182 xprintf("%02X ",pe->sec_buffer[j]);
1183 }
1184 xputc('\n');
1185 }
1186 }
1187
print_partitions_list(int ext)1188 static void print_partitions_list(int ext)
1189 {
1190 int i;
1191 struct part_entry *pe;
1192 struct partition *p;
1193
1194 xprintf("Disk %s: %lu heads, %lu sectors, %lu cylinders\n\n", disk_device, g_heads, g_sectors, g_cylinders);
1195 xprintf("Nr AF Hd Sec Cyl Hd Sec Cyl Start Size ID\n");
1196
1197 for (i = 0; i < num_parts; i++) {
1198 pe = &partitions[i];
1199 p = pe->part;
1200 if (p) {
1201 if (ext && (i >= 4)) p = pe->part + 1;
1202 if(ext && i < 4 && !IS_EXTENDED(p->sys_ind)) continue;
1203
1204 xprintf("%2u %02x%4u%4u%5u%4u%4u%5u%11u%11u %02x\n",
1205 i+1, p->boot_ind, p->head,
1206 sector(p->sector), cylinder(p->sector, p->cyl),
1207 p->end_head,
1208 sector(p->end_sector), cylinder(p->end_sector, p->end_cyl),
1209 swap_le32toh(p->start4),
1210 swap_le32toh(p->size4),
1211 p->sys_ind);
1212 if (p->sys_ind) consistency_check(p, i);
1213 }
1214 }
1215 }
1216
1217 //fix the partition table order to ascending
fix_order(void)1218 static void fix_order(void)
1219 {
1220 sector_t first[num_parts], min;
1221 int i, j, oj, ojj, sj, sjj;
1222 struct part_entry *pe;
1223 struct partition *px, *py, temp, *pj, *pjj, tmp;
1224
1225 for (i = 0; i < num_parts; i++) {
1226 pe = &partitions[i];
1227 px = pe->part;
1228 if (is_partition_clear(px)) first[i] = 0xffffffff;
1229 else first[i] = swap_le32toh(px->start4) + pe->start_offset;
1230 }
1231
1232 if (!check_order()) {
1233 xprintf("Ordering is already correct\n\n");
1234 return;
1235 }
1236 for (i = 0; i < 4; i++) {
1237 for (j = 0; j < 3; j++) {
1238 if (first[j] > first[j+1]) {
1239 py = partitions[j+1].part;
1240 px = partitions[j].part;
1241 memcpy(&temp, py, sizeof(struct partition));
1242 memcpy(py, px, sizeof(struct partition));
1243 memcpy(px, &temp, sizeof(struct partition));
1244 min = first[j+1];
1245 first[j+1] = first[j];
1246 first[j] = min;
1247 partitions[j].modified = 1;
1248 }
1249 }
1250 }
1251 for (i = 5; i < num_parts; i++) {
1252 for (j = 5; j < num_parts - 1; j++) {
1253 oj = partitions[j].start_offset;
1254 ojj = partitions[j+1].start_offset;
1255 if (oj > ojj) {
1256 partitions[j].start_offset = ojj;
1257 partitions[j+1].start_offset = oj;
1258 pj = partitions[j].part;
1259 set_levalue(pj->start4, swap_le32toh(pj->start4)+oj-ojj);
1260 pjj = partitions[j+1].part;
1261 set_levalue(pjj->start4, swap_le32toh(pjj->start4)+ojj-oj);
1262 set_levalue((partitions[j-1].part+1)->start4, ojj-extended_offset);
1263 set_levalue((partitions[j].part+1)->start4, oj-extended_offset);
1264 }
1265 }
1266 }
1267 for (i = 4; i < num_parts; i++) {
1268 for (j = 4; j < num_parts - 1; j++) {
1269 pj = partitions[j].part;
1270 pjj = partitions[j+1].part;
1271 sj = swap_le32toh(pj->start4);
1272 sjj = swap_le32toh(pjj->start4);
1273 oj = partitions[j].start_offset;
1274 ojj = partitions[j+1].start_offset;
1275 if (oj+sj > ojj+sjj) {
1276 tmp = *pj;
1277 *pj = *pjj;
1278 *pjj = tmp;
1279 set_levalue(pj->start4, ojj+sjj-oj);
1280 set_levalue(pjj->start4, oj+sj-ojj);
1281 }
1282 }
1283 }
1284 // If anything changed
1285 for (j = 4; j < num_parts; j++) partitions[j].modified = 1;
1286 xprintf("Done!\n");
1287 }
1288
print_menu(void)1289 static void print_menu(void)
1290 {
1291 xprintf("a\ttoggle a bootable flag\n"
1292 "b\tedit bsd disklabel\n"
1293 "c\ttoggle the dos compatibility flag\n"
1294 "d\tdelete a partition\n"
1295 "l\tlist known partition types\n"
1296 "n\tadd a new partition\n"
1297 "o\tcreate a new empty DOS partition table\n"
1298 "p\tprint the partition table\n"
1299 "q\tquit without saving changes\n"
1300 "s\tcreate a new empty Sun disklabel\n"
1301 "t\tchange a partition's system id\n"
1302 "u\tchange display/entry units\n"
1303 "v\tverify the partition table\n"
1304 "w\twrite table to disk and exit\n"
1305 "x\textra functionality (experts only)\n");
1306 }
1307
print_xmenu(void)1308 static void print_xmenu(void)
1309 {
1310 xprintf("b\tmove beginning of data in a partition\n"
1311 "c\tchange number of cylinders\n"
1312 "d\tprint the raw data in the partition table\n"
1313 "e\tlist extended partitions\n"
1314 "f\tfix partition order\n"
1315 "h\tchange number of heads\n"
1316 "p\tprint the partition table\n"
1317 "q\tquit without saving changes\n"
1318 "r\treturn to main menu\n"
1319 "s\tchange number of sectors/track\n"
1320 "v\tverify the partition table\n"
1321 "w\twrite table to disk and exit\n");
1322 }
1323
expert_menu(void)1324 static void expert_menu(void)
1325 {
1326 int choice, idx;
1327 sector_t value;
1328 char mesg[256];
1329
1330 while (1) {
1331 xputc('\n');
1332 char *msg = "Expert Command ('m' for help): ";
1333 choice = 0x20 | read_input(msg, NULL);
1334 switch (choice) {
1335 case 'b': //move data begining in partition
1336 idx = ask_partition(num_parts);
1337 move_begning(idx - 1);
1338 break;
1339 case 'c': //change cylinders
1340 sprintf(mesg, "Number of cylinders (1 - 1048576, default %lu): ", g_cylinders);
1341 value = ask_value(mesg, 1, 1048576, g_cylinders);
1342 g_cylinders = TT.cylinders = value;
1343 toys.optflags |= FLAG_C;
1344 if(g_cylinders > ONE_K)
1345 xprintf("\nThe number of cylinders for this disk is set to %lu.\n"
1346 "There is nothing wrong with that, but this is larger than 1024,\n"
1347 "and could in certain setups cause problems.\n", g_cylinders);
1348 break;
1349 case 'd': //print raw data in part tables
1350 print_raw_sectors();
1351 break;
1352 case 'e': //list extended partitions
1353 print_partitions_list(1);
1354 break;
1355 case 'f': //fix part order
1356 fix_order();
1357 break;
1358 case 'h': //change number of heads
1359 sprintf(mesg, "Number of heads (1 - 256, default %lu): ", g_heads);
1360 value = ask_value(mesg, 1, 256, g_heads);
1361 g_heads = TT.heads = value;
1362 toys.optflags |= FLAG_H;
1363 break;
1364 case 'p': //print partition table
1365 print_partitions_list(0);
1366 break;
1367 case 'q':
1368 free_bufs();
1369 close(dev_fd);
1370 xputc('\n');
1371 exit(0);
1372 break;
1373 case 'r':
1374 return;
1375 break;
1376 case 's': //change sector/track
1377 sprintf(mesg, "Number of sectors (1 - 63, default %lu): ", g_sectors);
1378 value = ask_value(mesg, 1, 63, g_sectors);
1379 g_sectors = TT.sectors = value;
1380 toys.optflags |= FLAG_H;
1381 break;
1382 case 'v':
1383 verify_table();
1384 break;
1385 case 'w':
1386 write_table();
1387 toys.exitval = 0;
1388 exit(0);
1389 break;
1390 case 'm':
1391 print_xmenu();
1392 break;
1393 default:
1394 xprintf("Unknown command '%c'\n",choice);
1395 print_xmenu();
1396 break;
1397 }
1398 } //while(1)
1399 }
1400
disk_proper(const char * device)1401 static int disk_proper(const char *device)
1402 {
1403 unsigned length;
1404 int fd = open(device, O_RDONLY);
1405
1406 if (fd != -1) {
1407 struct hd_geometry dev_geo;
1408 dev_geo.heads = 0;
1409 dev_geo.sectors = 0;
1410 int err = ioctl(fd, HDIO_GETGEO, &dev_geo);
1411 close(fd);
1412 if (!err) return (dev_geo.start == 0);
1413 }
1414 length = strlen(device);
1415 if (length != 0 && isdigit(device[length - 1])) return 0;
1416 return 1;
1417 }
1418
reset_entries()1419 static void reset_entries()
1420 {
1421 int i;
1422
1423 memset(MBRbuf, 0, sizeof(MBRbuf));
1424 for (i = 4; i < num_parts; i++)
1425 memset(&partitions[i], 0, sizeof(struct part_entry));
1426 }
1427
1428 //this will keep dev_fd = 3 always alive
move_fd()1429 static void move_fd()
1430 {
1431 int fd = xopen("/dev/null", O_RDONLY);
1432 if(fd != dev_fd) {
1433 if(dup2(fd, dev_fd) != dev_fd) perror_exit("Can't dup2");
1434 close(fd);
1435 }
1436 }
1437
1438 /* Read proc/partitions and then print the details
1439 * for partitions on each device
1440 */
read_and_print_parts()1441 static void read_and_print_parts()
1442 {
1443 unsigned int ma, mi, sz;
1444 char *name = toybuf, *buffer = toybuf + ONE_K, *device = toybuf + 2048;
1445 FILE* fp = xfopen("/proc/partitions", "r");
1446
1447 while (fgets(buffer, ONE_K, fp)) {
1448 reset_entries();
1449 num_parts = 4;
1450 memset(name, 0, sizeof(name));
1451 if (sscanf(buffer, " %u %u %u %[^\n ]", &ma, &mi, &sz, name) != 4)
1452 continue;
1453
1454 sprintf(device,"/dev/%s",name);
1455 if (disk_proper(device)) {
1456 if (read_mbr(device, 0)) continue;
1457 print_mbr(1);
1458 move_fd();
1459 }
1460 }
1461 fclose(fp);
1462 }
1463
fdisk_main(void)1464 void fdisk_main(void)
1465 {
1466 int choice, p;
1467
1468 init_members();
1469 move_fd();
1470 if (TT.heads >= 256) TT.heads = 0;
1471 if (TT.sectors >= 64) TT.sectors = 0;
1472 if (toys.optflags & FLAG_u) disp_unit_cyl = 0;
1473 if (toys.optflags & FLAG_l) {
1474 if (!toys.optc) read_and_print_parts();
1475 else {
1476 while(*toys.optargs){
1477 if (read_mbr(*toys.optargs, 0)) {
1478 toys.optargs++;
1479 continue;
1480 }
1481 print_mbr(1);
1482 move_fd();
1483 toys.optargs++;
1484 }
1485 }
1486 toys.exitval = 0;
1487 return;
1488 } else {
1489 if (toys.optc != 1) help_exit(0);
1490 if (read_mbr(toys.optargs[0], 1)) return;
1491 while (1) {
1492 xputc('\n');
1493 char *msg = "Command ('m' for help): ";
1494 choice = 0x20 | read_input(msg, NULL);
1495 switch (choice) {
1496 case 'a':
1497 p = ask_partition(num_parts);
1498 toggle_active_flag(p - 1); //partition table index start from 0.
1499 break;
1500 case 'b':
1501 break;
1502 case 'c':
1503 dos_flag = !dos_flag;
1504 xprintf("Dos compatible flag is %s\n", dos_flag?"Set" : "Not set");
1505 break;
1506 case 'd':
1507 p = get_non_free_partition(num_parts); //4 was here
1508 if(p >= 0) delete_partition(p);
1509 break;
1510 case 'l':
1511 list_types();
1512 break;
1513 case 'n': //add new partition
1514 add_new_partition();
1515 break;
1516 case 'o':
1517 create_empty_doslabel();
1518 break;
1519 case 'p':
1520 print_mbr(0);
1521 break;
1522 case 'q':
1523 free_bufs();
1524 close(dev_fd);
1525 xputc('\n');
1526 exit(0);
1527 break;
1528 case 's':
1529 break;
1530 case 't':
1531 change_systype();
1532 break;
1533 case 'u':
1534 disp_unit_cyl = !disp_unit_cyl;
1535 xprintf("Changing Display/Entry units to %s\n",disp_unit_cyl?"cylinders" : "sectors");
1536 break;
1537 case 'v':
1538 verify_table();
1539 break;
1540 case 'w':
1541 write_table();
1542 toys.exitval = 0;
1543 return;
1544 break;
1545 case 'x':
1546 expert_menu();
1547 break;
1548 case 'm':
1549 print_menu();
1550 break;
1551 default:
1552 xprintf("%c: Unknown command\n",choice);
1553 break;
1554 }
1555 } //while(1)
1556 }
1557 }
1558