1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34#if ENABLE_FEATURE_OSF_LABEL
35
36#ifndef BSD_DISKMAGIC
37#define BSD_DISKMAGIC ((uint32_t) 0x82564557)
38#endif
39
40#ifndef BSD_MAXPARTITIONS
41#define BSD_MAXPARTITIONS 16
42#endif
43
44#define BSD_LINUX_BOOTDIR "/usr/ucb/mdec"
45
46#if defined(__alpha__) \
47 || defined(__powerpc__) \
48 || defined(__ia64__) \
49 || defined(__hppa__)
50# define BSD_LABELSECTOR 0
51# define BSD_LABELOFFSET 64
52#else
53# define BSD_LABELSECTOR 1
54# define BSD_LABELOFFSET 0
55#endif
56
57#define BSD_BBSIZE 8192
58#define BSD_SBSIZE 8192
59
60struct xbsd_disklabel {
61 uint32_t d_magic;
62 int16_t d_type;
63 int16_t d_subtype;
64 char d_typename[16];
65 char d_packname[16];
66
67 uint32_t d_secsize;
68 uint32_t d_nsectors;
69 uint32_t d_ntracks;
70 uint32_t d_ncylinders;
71 uint32_t d_secpercyl;
72 uint32_t d_secperunit;
73
74
75
76
77
78
79 uint16_t d_sparespertrack;
80 uint16_t d_sparespercyl;
81
82
83
84
85 uint32_t d_acylinders;
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104 uint16_t d_rpm;
105 uint16_t d_interleave;
106 uint16_t d_trackskew;
107 uint16_t d_cylskew;
108 uint32_t d_headswitch;
109 uint32_t d_trkseek;
110 uint32_t d_flags;
111#define NDDATA 5
112 uint32_t d_drivedata[NDDATA];
113#define NSPARE 5
114 uint32_t d_spare[NSPARE];
115 uint32_t d_magic2;
116 uint16_t d_checksum;
117
118 uint16_t d_npartitions;
119 uint32_t d_bbsize;
120 uint32_t d_sbsize;
121 struct xbsd_partition {
122 uint32_t p_size;
123 uint32_t p_offset;
124 uint32_t p_fsize;
125 uint8_t p_fstype;
126 uint8_t p_frag;
127 uint16_t p_cpg;
128 } d_partitions[BSD_MAXPARTITIONS];
129};
130
131
132#define BSD_DTYPE_SMD 1
133#define BSD_DTYPE_MSCP 2
134#define BSD_DTYPE_DEC 3
135#define BSD_DTYPE_SCSI 4
136#define BSD_DTYPE_ESDI 5
137#define BSD_DTYPE_ST506 6
138#define BSD_DTYPE_HPIB 7
139#define BSD_DTYPE_HPFL 8
140#define BSD_DTYPE_FLOPPY 10
141
142
143#define BSD_DSTYPE_INDOSPART 0x8
144#define BSD_DSTYPE_DOSPART(s) ((s) & 3)
145#define BSD_DSTYPE_GEOMETRY 0x10
146
147static const char *const xbsd_dktypenames[] = {
148 "unknown",
149 "SMD",
150 "MSCP",
151 "old DEC",
152 "SCSI",
153 "ESDI",
154 "ST506",
155 "HP-IB",
156 "HP-FL",
157 "type 9",
158 "floppy",
159 0
160};
161
162
163
164
165
166
167
168#define BSD_FS_UNUSED 0
169#define BSD_FS_SWAP 1
170#define BSD_FS_V6 2
171#define BSD_FS_V7 3
172#define BSD_FS_SYSV 4
173#define BSD_FS_V71K 5
174#define BSD_FS_V8 6
175#define BSD_FS_BSDFFS 7
176#define BSD_FS_BSDLFS 9
177#define BSD_FS_OTHER 10
178#define BSD_FS_HPFS 11
179#define BSD_FS_ISO9660 12
180#define BSD_FS_ISOFS BSD_FS_ISO9660
181#define BSD_FS_BOOT 13
182#define BSD_FS_ADOS 14
183#define BSD_FS_HFS 15
184#define BSD_FS_ADVFS 16
185
186
187#ifdef __alpha__
188#define BSD_FS_EXT2 8
189#else
190#define BSD_FS_MSDOS 8
191#endif
192
193static const char *const xbsd_fstypes[] = {
194 "\x00" "unused",
195 "\x01" "swap",
196 "\x02" "Version 6",
197 "\x03" "Version 7",
198 "\x04" "System V",
199 "\x05" "4.1BSD",
200 "\x06" "Eighth Edition",
201 "\x07" "4.2BSD",
202#ifdef __alpha__
203 "\x08" "ext2",
204#else
205 "\x08" "MS-DOS",
206#endif
207 "\x09" "4.4LFS",
208 "\x0a" "unknown",
209 "\x0b" "HPFS",
210 "\x0c" "ISO-9660",
211 "\x0d" "boot",
212 "\x0e" "ADOS",
213 "\x0f" "HFS",
214 "\x10" "AdvFS",
215 NULL
216};
217
218
219
220
221
222#define BSD_D_REMOVABLE 0x01
223#define BSD_D_ECC 0x02
224#define BSD_D_BADSECT 0x04
225#define BSD_D_RAMDISK 0x08
226#define BSD_D_CHAIN 0x10
227#define BSD_D_DOSPART 0x20
228
229
230
231
232
233
234
235
236
237
238#define FREEBSD_PARTITION 0xa5
239#define NETBSD_PARTITION 0xa9
240
241static void xbsd_delete_part(void);
242static void xbsd_new_part(void);
243static void xbsd_write_disklabel(void);
244static int xbsd_create_disklabel(void);
245static void xbsd_edit_disklabel(void);
246static void xbsd_write_bootstrap(void);
247static void xbsd_change_fstype(void);
248static int xbsd_get_part_index(int max);
249static int xbsd_check_new_partition(int *i);
250static void xbsd_list_types(void);
251static uint16_t xbsd_dkcksum(struct xbsd_disklabel *lp);
252static int xbsd_initlabel(struct partition *p);
253static int xbsd_readlabel(struct partition *p);
254static int xbsd_writelabel(struct partition *p);
255
256#if defined(__alpha__)
257static void alpha_bootblock_checksum(char *boot);
258#endif
259
260#if !defined(__alpha__)
261static int xbsd_translate_fstype(int linux_type);
262static void xbsd_link_part(void);
263static struct partition *xbsd_part;
264static int xbsd_part_index;
265#endif
266
267
268
269struct bsd_globals {
270
271
272 char disklabelbuffer[BSD_BBSIZE];
273 struct xbsd_disklabel xbsd_dlabel;
274};
275
276static struct bsd_globals *bsd_globals_ptr;
277
278#define disklabelbuffer (bsd_globals_ptr->disklabelbuffer)
279#define xbsd_dlabel (bsd_globals_ptr->xbsd_dlabel)
280
281
282
283
284#define bsd_cround(n) \
285 (display_in_cyl_units ? ((n)/xbsd_dlabel.d_secpercyl) + 1 : (n))
286
287
288
289
290
291
292
293static int
294check_osf_label(void)
295{
296 if (xbsd_readlabel(NULL) == 0)
297 return 0;
298 return 1;
299}
300
301static int
302bsd_trydev(const char * dev)
303{
304 if (xbsd_readlabel(NULL) == 0)
305 return -1;
306 printf("\nBSD label for device: %s\n", dev);
307 xbsd_print_disklabel(0);
308 return 0;
309}
310
311static void
312bsd_menu(void)
313{
314 puts("Command Action");
315 puts("d\tdelete a BSD partition");
316 puts("e\tedit drive data");
317 puts("i\tinstall bootstrap");
318 puts("l\tlist known filesystem types");
319 puts("n\tadd a new BSD partition");
320 puts("p\tprint BSD partition table");
321 puts("q\tquit without saving changes");
322 puts("r\treturn to main menu");
323 puts("s\tshow complete disklabel");
324 puts("t\tchange a partition's filesystem id");
325 puts("u\tchange units (cylinders/sectors)");
326 puts("w\twrite disklabel to disk");
327#if !defined(__alpha__)
328 puts("x\tlink BSD partition to non-BSD partition");
329#endif
330}
331
332#if !defined(__alpha__)
333static int
334hidden(int type)
335{
336 return type ^ 0x10;
337}
338
339static int
340is_bsd_partition_type(int type)
341{
342 return (type == FREEBSD_PARTITION ||
343 type == hidden(FREEBSD_PARTITION) ||
344 type == NETBSD_PARTITION ||
345 type == hidden(NETBSD_PARTITION));
346}
347#endif
348
349static void
350bsd_select(void)
351{
352#if !defined(__alpha__)
353 int t, ss;
354 struct partition *p;
355
356 for (t = 0; t < 4; t++) {
357 p = get_part_table(t);
358 if (p && is_bsd_partition_type(p->sys_ind)) {
359 xbsd_part = p;
360 xbsd_part_index = t;
361 ss = get_start_sect(xbsd_part);
362 if (ss == 0) {
363 printf("Partition %s has invalid starting sector 0\n",
364 partname(disk_device, t+1, 0));
365 return;
366 }
367 printf("Reading disklabel of %s at sector %u\n",
368 partname(disk_device, t+1, 0), ss + BSD_LABELSECTOR);
369 if (xbsd_readlabel(xbsd_part) == 0) {
370 if (xbsd_create_disklabel() == 0)
371 return;
372 break;
373 }
374 }
375 }
376
377 if (t == 4) {
378 printf("There is no *BSD partition on %s\n", disk_device);
379 return;
380 }
381
382#elif defined(__alpha__)
383
384 if (xbsd_readlabel(NULL) == 0)
385 if (xbsd_create_disklabel() == 0)
386 exit(EXIT_SUCCESS);
387
388#endif
389
390 while (1) {
391 bb_putchar('\n');
392 switch (tolower(read_nonempty("BSD disklabel command (m for help): "))) {
393 case 'd':
394 xbsd_delete_part();
395 break;
396 case 'e':
397 xbsd_edit_disklabel();
398 break;
399 case 'i':
400 xbsd_write_bootstrap();
401 break;
402 case 'l':
403 xbsd_list_types();
404 break;
405 case 'n':
406 xbsd_new_part();
407 break;
408 case 'p':
409 xbsd_print_disklabel(0);
410 break;
411 case 'q':
412 if (ENABLE_FEATURE_CLEAN_UP)
413 close_dev_fd();
414 exit(EXIT_SUCCESS);
415 case 'r':
416 return;
417 case 's':
418 xbsd_print_disklabel(1);
419 break;
420 case 't':
421 xbsd_change_fstype();
422 break;
423 case 'u':
424 change_units();
425 break;
426 case 'w':
427 xbsd_write_disklabel();
428 break;
429#if !defined(__alpha__)
430 case 'x':
431 xbsd_link_part();
432 break;
433#endif
434 default:
435 bsd_menu();
436 break;
437 }
438 }
439}
440
441static void
442xbsd_delete_part(void)
443{
444 int i;
445
446 i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
447 xbsd_dlabel.d_partitions[i].p_size = 0;
448 xbsd_dlabel.d_partitions[i].p_offset = 0;
449 xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
450 if (xbsd_dlabel.d_npartitions == i + 1)
451 while (xbsd_dlabel.d_partitions[xbsd_dlabel.d_npartitions-1].p_size == 0)
452 xbsd_dlabel.d_npartitions--;
453}
454
455static void
456xbsd_new_part(void)
457{
458 off_t begin, end;
459 char mesg[256];
460 int i;
461
462 if (!xbsd_check_new_partition(&i))
463 return;
464
465#if !defined(__alpha__) && !defined(__powerpc__) && !defined(__hppa__)
466 begin = get_start_sect(xbsd_part);
467 end = begin + get_nr_sects(xbsd_part) - 1;
468#else
469 begin = 0;
470 end = xbsd_dlabel.d_secperunit - 1;
471#endif
472
473 snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));
474 begin = read_int(bsd_cround(begin), bsd_cround(begin), bsd_cround(end),
475 0, mesg);
476
477 if (display_in_cyl_units)
478 begin = (begin - 1) * xbsd_dlabel.d_secpercyl;
479
480 snprintf(mesg, sizeof(mesg), "Last %s or +size or +sizeM or +sizeK",
481 str_units(SINGULAR));
482 end = read_int(bsd_cround(begin), bsd_cround(end), bsd_cround(end),
483 bsd_cround(begin), mesg);
484
485 if (display_in_cyl_units)
486 end = end * xbsd_dlabel.d_secpercyl - 1;
487
488 xbsd_dlabel.d_partitions[i].p_size = end - begin + 1;
489 xbsd_dlabel.d_partitions[i].p_offset = begin;
490 xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
491}
492
493static void
494xbsd_print_disklabel(int show_all)
495{
496 struct xbsd_disklabel *lp = &xbsd_dlabel;
497 struct xbsd_partition *pp;
498 int i, j;
499
500 if (show_all) {
501 static const int d_masks[] = { BSD_D_REMOVABLE, BSD_D_ECC, BSD_D_BADSECT };
502
503#if defined(__alpha__)
504 printf("# %s:\n", disk_device);
505#else
506 printf("# %s:\n", partname(disk_device, xbsd_part_index+1, 0));
507#endif
508 if ((unsigned) lp->d_type < ARRAY_SIZE(xbsd_dktypenames)-1)
509 printf("type: %s\n", xbsd_dktypenames[lp->d_type]);
510 else
511 printf("type: %u\n", lp->d_type);
512 printf("disk: %.*s\n", (int) sizeof(lp->d_typename), lp->d_typename);
513 printf("label: %.*s\n", (int) sizeof(lp->d_packname), lp->d_packname);
514 printf("flags: ");
515 print_flags_separated(d_masks, "removable\0""ecc\0""badsect\0", lp->d_flags, " ");
516 bb_putchar('\n');
517
518
519 printf("bytes/sector: %lu\n", (long) lp->d_secsize);
520 printf("sectors/track: %lu\n", (long) lp->d_nsectors);
521 printf("tracks/cylinder: %lu\n", (long) lp->d_ntracks);
522 printf("sectors/cylinder: %lu\n", (long) lp->d_secpercyl);
523 printf("cylinders: %lu\n", (long) lp->d_ncylinders);
524 printf("rpm: %u\n", lp->d_rpm);
525 printf("interleave: %u\n", lp->d_interleave);
526 printf("trackskew: %u\n", lp->d_trackskew);
527 printf("cylinderskew: %u\n", lp->d_cylskew);
528 printf("headswitch: %lu\t\t# milliseconds\n",
529 (long) lp->d_headswitch);
530 printf("track-to-track seek: %lu\t# milliseconds\n",
531 (long) lp->d_trkseek);
532 printf("drivedata: ");
533 for (i = NDDATA - 1; i >= 0; i--)
534 if (lp->d_drivedata[i])
535 break;
536 if (i < 0)
537 i = 0;
538 for (j = 0; j <= i; j++)
539 printf("%lu ", (long) lp->d_drivedata[j]);
540 }
541 printf("\n%u partitions:\n", lp->d_npartitions);
542 printf("# start end size fstype [fsize bsize cpg]\n");
543 pp = lp->d_partitions;
544 for (i = 0; i < lp->d_npartitions; i++, pp++) {
545 if (pp->p_size) {
546 if (display_in_cyl_units && lp->d_secpercyl) {
547 printf(" %c: %8lu%c %8lu%c %8lu%c ",
548 'a' + i,
549 (unsigned long) pp->p_offset / lp->d_secpercyl + 1,
550 (pp->p_offset % lp->d_secpercyl) ? '*' : ' ',
551 (unsigned long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl,
552 ((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ',
553 (long) pp->p_size / lp->d_secpercyl,
554 (pp->p_size % lp->d_secpercyl) ? '*' : ' '
555 );
556 } else {
557 printf(" %c: %8lu %8lu %8lu ",
558 'a' + i,
559 (long) pp->p_offset,
560 (long) pp->p_offset + pp->p_size - 1,
561 (long) pp->p_size
562 );
563 }
564
565 if ((unsigned) pp->p_fstype < ARRAY_SIZE(xbsd_fstypes)-1)
566 printf("%8.8s", xbsd_fstypes[pp->p_fstype]);
567 else
568 printf("%8x", pp->p_fstype);
569
570 switch (pp->p_fstype) {
571 case BSD_FS_UNUSED:
572 printf(" %5lu %5lu %5.5s ",
573 (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, "");
574 break;
575 case BSD_FS_BSDFFS:
576 printf(" %5lu %5lu %5u ",
577 (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, pp->p_cpg);
578 break;
579 default:
580 printf("%22.22s", "");
581 break;
582 }
583 bb_putchar('\n');
584 }
585 }
586}
587
588static void
589xbsd_write_disklabel(void)
590{
591#if defined(__alpha__)
592 printf("Writing disklabel to %s\n", disk_device);
593 xbsd_writelabel(NULL);
594#else
595 printf("Writing disklabel to %s\n",
596 partname(disk_device, xbsd_part_index + 1, 0));
597 xbsd_writelabel(xbsd_part);
598#endif
599 reread_partition_table(0);
600}
601
602static int
603xbsd_create_disklabel(void)
604{
605 char c;
606
607#if defined(__alpha__)
608 printf("%s contains no disklabel\n", disk_device);
609#else
610 printf("%s contains no disklabel\n",
611 partname(disk_device, xbsd_part_index + 1, 0));
612#endif
613
614 while (1) {
615 c = read_nonempty("Do you want to create a disklabel? (y/n) ");
616 if ((c|0x20) == 'y') {
617 if (xbsd_initlabel(
618#if defined(__alpha__) || defined(__powerpc__) || defined(__hppa__) || \
619 defined(__s390__) || defined(__s390x__)
620 NULL
621#else
622 xbsd_part
623#endif
624 ) == 1) {
625 xbsd_print_disklabel(1);
626 return 1;
627 }
628 return 0;
629 }
630 if ((c|0x20) == 'n')
631 return 0;
632 }
633}
634
635static int
636edit_int(int def, const char *mesg)
637{
638 mesg = xasprintf("%s (%u): ", mesg, def);
639 do {
640 if (!read_line(mesg))
641 goto ret;
642 } while (!isdigit(*line_ptr));
643 def = atoi(line_ptr);
644 ret:
645 free((char*)mesg);
646 return def;
647}
648
649static void
650xbsd_edit_disklabel(void)
651{
652 struct xbsd_disklabel *d;
653
654 d = &xbsd_dlabel;
655
656#if defined(__alpha__) || defined(__ia64__)
657 d->d_secsize = edit_int(d->d_secsize , "bytes/sector");
658 d->d_nsectors = edit_int(d->d_nsectors , "sectors/track");
659 d->d_ntracks = edit_int(d->d_ntracks , "tracks/cylinder");
660 d->d_ncylinders = edit_int(d->d_ncylinders , "cylinders");
661#endif
662
663
664 while (1) {
665 d->d_secpercyl = edit_int(d->d_nsectors * d->d_ntracks,
666 "sectors/cylinder");
667 if (d->d_secpercyl <= d->d_nsectors * d->d_ntracks)
668 break;
669
670 printf("Must be <= sectors/track * tracks/cylinder (default)\n");
671 }
672 d->d_rpm = edit_int(d->d_rpm , "rpm");
673 d->d_interleave = edit_int(d->d_interleave, "interleave");
674 d->d_trackskew = edit_int(d->d_trackskew , "trackskew");
675 d->d_cylskew = edit_int(d->d_cylskew , "cylinderskew");
676 d->d_headswitch = edit_int(d->d_headswitch, "headswitch");
677 d->d_trkseek = edit_int(d->d_trkseek , "track-to-track seek");
678
679 d->d_secperunit = d->d_secpercyl * d->d_ncylinders;
680}
681
682static int
683xbsd_get_bootstrap(char *path, void *ptr, int size)
684{
685 int fdb;
686
687 fdb = open_or_warn(path, O_RDONLY);
688 if (fdb < 0) {
689 return 0;
690 }
691 if (full_read(fdb, ptr, size) < 0) {
692 bb_simple_perror_msg(path);
693 close(fdb);
694 return 0;
695 }
696 printf(" ... %s\n", path);
697 close(fdb);
698 return 1;
699}
700
701static void
702sync_disks(void)
703{
704 printf("Syncing disks\n");
705 sync();
706
707}
708
709static void
710xbsd_write_bootstrap(void)
711{
712#ifndef MAXPATHLEN
713# define MAXPATHLEN 1024
714#endif
715 char path[MAXPATHLEN];
716 const char *bootdir = BSD_LINUX_BOOTDIR;
717 const char *dkbasename;
718 struct xbsd_disklabel dl;
719 char *d, *p, *e;
720 int sector;
721
722 if (xbsd_dlabel.d_type == BSD_DTYPE_SCSI)
723 dkbasename = "sd";
724 else
725 dkbasename = "wd";
726
727 snprintf(path, sizeof(path), "Bootstrap: %sboot -> boot%s (%s): ",
728 dkbasename, dkbasename, dkbasename);
729 if (read_line(path)) {
730 dkbasename = line_ptr;
731 }
732 snprintf(path, sizeof(path), "%s/%sboot", bootdir, dkbasename);
733 if (!xbsd_get_bootstrap(path, disklabelbuffer, (int) xbsd_dlabel.d_secsize))
734 return;
735
736
737 d = &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE];
738 memmove(&dl, d, sizeof(struct xbsd_disklabel));
739
740
741 memset(d, 0, sizeof(struct xbsd_disklabel));
742
743 snprintf(path, sizeof(path), "%s/boot%s", bootdir, dkbasename);
744 if (!xbsd_get_bootstrap(path, &disklabelbuffer[xbsd_dlabel.d_secsize],
745 (int) xbsd_dlabel.d_bbsize - xbsd_dlabel.d_secsize))
746 return;
747
748 e = d + sizeof(struct xbsd_disklabel);
749 for (p = d; p < e; p++)
750 if (*p) {
751 printf("Bootstrap overlaps with disk label!\n");
752 exit(EXIT_FAILURE);
753 }
754
755 memmove(d, &dl, sizeof(struct xbsd_disklabel));
756
757#if defined(__powerpc__) || defined(__hppa__)
758 sector = 0;
759#elif defined(__alpha__)
760 sector = 0;
761 alpha_bootblock_checksum(disklabelbuffer);
762#else
763 sector = get_start_sect(xbsd_part);
764#endif
765
766 seek_sector(sector);
767 xwrite(dev_fd, disklabelbuffer, BSD_BBSIZE);
768
769#if defined(__alpha__)
770 printf("Bootstrap installed on %s\n", disk_device);
771#else
772 printf("Bootstrap installed on %s\n",
773 partname(disk_device, xbsd_part_index+1, 0));
774#endif
775
776 sync_disks();
777}
778
779static void
780xbsd_change_fstype(void)
781{
782 int i;
783
784 i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
785 xbsd_dlabel.d_partitions[i].p_fstype = read_hex(xbsd_fstypes);
786}
787
788static int
789xbsd_get_part_index(int max)
790{
791 char prompt[sizeof("Partition (a-%c): ") + 16];
792 char l;
793
794 snprintf(prompt, sizeof(prompt), "Partition (a-%c): ", 'a' + max - 1);
795 do
796 l = tolower(read_nonempty(prompt));
797 while (l < 'a' || l > 'a' + max - 1);
798 return l - 'a';
799}
800
801static int
802xbsd_check_new_partition(int *i)
803{
804
805 if (xbsd_dlabel.d_npartitions == BSD_MAXPARTITIONS) {
806 int t;
807
808 for (t = 0; t < BSD_MAXPARTITIONS; t++)
809 if (xbsd_dlabel.d_partitions[t].p_size == 0)
810 break;
811
812 if (t == BSD_MAXPARTITIONS) {
813 printf("The maximum number of partitions has been created\n");
814 return 0;
815 }
816 }
817
818 *i = xbsd_get_part_index(BSD_MAXPARTITIONS);
819
820 if (*i >= xbsd_dlabel.d_npartitions)
821 xbsd_dlabel.d_npartitions = (*i) + 1;
822
823 if (xbsd_dlabel.d_partitions[*i].p_size != 0) {
824 printf("This partition already exists\n");
825 return 0;
826 }
827
828 return 1;
829}
830
831static void
832xbsd_list_types(void)
833{
834 list_types(xbsd_fstypes);
835}
836
837static uint16_t
838xbsd_dkcksum(struct xbsd_disklabel *lp)
839{
840 uint16_t *start, *end;
841 uint16_t sum = 0;
842
843 start = (uint16_t *) lp;
844 end = (uint16_t *) &lp->d_partitions[lp->d_npartitions];
845 while (start < end)
846 sum ^= *start++;
847 return sum;
848}
849
850static int
851xbsd_initlabel(struct partition *p)
852{
853 struct xbsd_disklabel *d = &xbsd_dlabel;
854 struct xbsd_partition *pp;
855
856 get_geometry();
857 memset(d, 0, sizeof(struct xbsd_disklabel));
858
859 d->d_magic = BSD_DISKMAGIC;
860
861 if (is_prefixed_with(disk_device, "/dev/sd"))
862 d->d_type = BSD_DTYPE_SCSI;
863 else
864 d->d_type = BSD_DTYPE_ST506;
865
866#if !defined(__alpha__)
867 d->d_flags = BSD_D_DOSPART;
868#else
869 d->d_flags = 0;
870#endif
871 d->d_secsize = SECTOR_SIZE;
872 d->d_nsectors = g_sectors;
873 d->d_ntracks = g_heads;
874 d->d_ncylinders = g_cylinders;
875 d->d_secpercyl = g_sectors * g_heads;
876 if (d->d_secpercyl == 0)
877 d->d_secpercyl = 1;
878 d->d_secperunit = d->d_secpercyl * d->d_ncylinders;
879
880 d->d_rpm = 3600;
881 d->d_interleave = 1;
882 d->d_trackskew = 0;
883 d->d_cylskew = 0;
884 d->d_headswitch = 0;
885 d->d_trkseek = 0;
886
887 d->d_magic2 = BSD_DISKMAGIC;
888 d->d_bbsize = BSD_BBSIZE;
889 d->d_sbsize = BSD_SBSIZE;
890
891#if !defined(__alpha__)
892 d->d_npartitions = 4;
893 pp = &d->d_partitions[2];
894
895 pp->p_offset = get_start_sect(p);
896 pp->p_size = get_nr_sects(p);
897 pp->p_fstype = BSD_FS_UNUSED;
898 pp = &d->d_partitions[3];
899
900 pp->p_offset = 0;
901 pp->p_size = d->d_secperunit;
902 pp->p_fstype = BSD_FS_UNUSED;
903#else
904 d->d_npartitions = 3;
905 pp = &d->d_partitions[2];
906 pp->p_offset = 0;
907 pp->p_size = d->d_secperunit;
908 pp->p_fstype = BSD_FS_UNUSED;
909#endif
910
911 return 1;
912}
913
914
915
916
917
918static int
919xbsd_readlabel(struct partition *p)
920{
921 struct xbsd_disklabel *d;
922 int t, sector;
923
924 if (!bsd_globals_ptr)
925 bsd_globals_ptr = xzalloc(sizeof(*bsd_globals_ptr));
926
927 d = &xbsd_dlabel;
928
929
930#if !defined(__alpha__)
931 sector = (p ? get_start_sect(p) : 0);
932#else
933 sector = 0;
934#endif
935
936 seek_sector(sector);
937 if (BSD_BBSIZE != full_read(dev_fd, disklabelbuffer, BSD_BBSIZE))
938 fdisk_fatal(unable_to_read);
939
940 memmove(d, &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET],
941 sizeof(struct xbsd_disklabel));
942
943 if (d->d_magic != BSD_DISKMAGIC || d->d_magic2 != BSD_DISKMAGIC)
944 return 0;
945
946 for (t = d->d_npartitions; t < BSD_MAXPARTITIONS; t++) {
947 d->d_partitions[t].p_size = 0;
948 d->d_partitions[t].p_offset = 0;
949 d->d_partitions[t].p_fstype = BSD_FS_UNUSED;
950 }
951
952 if (d->d_npartitions > BSD_MAXPARTITIONS)
953 printf("Warning: too many partitions (%u, maximum is %u)\n",
954 d->d_npartitions, BSD_MAXPARTITIONS);
955 return 1;
956}
957
958static int
959xbsd_writelabel(struct partition *p)
960{
961 struct xbsd_disklabel *d = &xbsd_dlabel;
962 unsigned int sector;
963
964#if !defined(__alpha__) && !defined(__powerpc__) && !defined(__hppa__)
965 sector = get_start_sect(p) + BSD_LABELSECTOR;
966#else
967 (void)p;
968 sector = BSD_LABELSECTOR;
969#endif
970
971 d->d_checksum = 0;
972 d->d_checksum = xbsd_dkcksum(d);
973
974
975
976
977 memmove(&disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET],
978 d, sizeof(struct xbsd_disklabel));
979
980#if defined(__alpha__) && BSD_LABELSECTOR == 0
981 alpha_bootblock_checksum(disklabelbuffer);
982 seek_sector(0);
983 xwrite(dev_fd, disklabelbuffer, BSD_BBSIZE);
984#else
985 seek_sector(sector);
986 lseek(dev_fd, BSD_LABELOFFSET, SEEK_CUR);
987 xwrite(dev_fd, d, sizeof(*d));
988#endif
989 sync_disks();
990 return 1;
991}
992
993
994#if !defined(__alpha__)
995static int
996xbsd_translate_fstype(int linux_type)
997{
998 switch (linux_type) {
999 case 0x01:
1000 case 0x04:
1001 case 0x06:
1002 case 0xe1:
1003 case 0xe3:
1004 case 0xf2:
1005 return BSD_FS_MSDOS;
1006 case 0x07:
1007 return BSD_FS_HPFS;
1008 default:
1009 return BSD_FS_OTHER;
1010 }
1011}
1012
1013static void
1014xbsd_link_part(void)
1015{
1016 int k, i;
1017 struct partition *p;
1018
1019 k = get_partition(1, g_partitions);
1020
1021 if (!xbsd_check_new_partition(&i))
1022 return;
1023
1024 p = get_part_table(k);
1025
1026 xbsd_dlabel.d_partitions[i].p_size = get_nr_sects(p);
1027 xbsd_dlabel.d_partitions[i].p_offset = get_start_sect(p);
1028 xbsd_dlabel.d_partitions[i].p_fstype = xbsd_translate_fstype(p->sys_ind);
1029}
1030#endif
1031
1032#if defined(__alpha__)
1033static void
1034alpha_bootblock_checksum(char *boot)
1035{
1036 uint64_t *dp, sum;
1037 int i;
1038
1039 dp = (uint64_t *)boot;
1040 sum = 0;
1041 for (i = 0; i < 63; i++)
1042 sum += dp[i];
1043 dp[63] = sum;
1044}
1045#endif
1046
1047
1048#undef disklabelbuffer
1049#undef xbsd_dlabel
1050
1051#endif
1052