Deleted Added
sdiff udiff text old ( 145748 ) new ( 145765 )
full compact
fdisk.c (145748) fdisk.c (145765)
1/*
2 * Mach Operating System
3 * Copyright (c) 1992 Carnegie Mellon University
4 * All Rights Reserved.
5 *
6 * Permission to use, copy, modify and distribute this software and its
7 * documentation is hereby granted, provided that both the copyright
8 * notice and this permission notice appear in all copies of the

--- 11 unchanged lines hidden (view full) ---

20 * Carnegie Mellon University
21 * Pittsburgh PA 15213-3890
22 *
23 * any improvements or extensions that they make and grant Carnegie Mellon
24 * the rights to redistribute these changes.
25 */
26
27#include <sys/cdefs.h>
1/*
2 * Mach Operating System
3 * Copyright (c) 1992 Carnegie Mellon University
4 * All Rights Reserved.
5 *
6 * Permission to use, copy, modify and distribute this software and its
7 * documentation is hereby granted, provided that both the copyright
8 * notice and this permission notice appear in all copies of the

--- 11 unchanged lines hidden (view full) ---

20 * Carnegie Mellon University
21 * Pittsburgh PA 15213-3890
22 *
23 * any improvements or extensions that they make and grant Carnegie Mellon
24 * the rights to redistribute these changes.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: head/sbin/fdisk_pc98/fdisk.c 145748 2005-05-01 05:04:05Z nyan $");
28__FBSDID("$FreeBSD: head/sbin/fdisk_pc98/fdisk.c 145765 2005-05-01 10:08:35Z nyan $");
29
30#include <sys/disk.h>
31#include <sys/disklabel.h>
32#include <sys/diskpc98.h>
33#include <sys/param.h>
34#include <sys/stat.h>
35#include <sys/mount.h>
36#include <ctype.h>

--- 8 unchanged lines hidden (view full) ---

45#include <string.h>
46#include <unistd.h>
47
48int iotest;
49
50#define LBUF 100
51static char lbuf[LBUF];
52
29
30#include <sys/disk.h>
31#include <sys/disklabel.h>
32#include <sys/diskpc98.h>
33#include <sys/param.h>
34#include <sys/stat.h>
35#include <sys/mount.h>
36#include <ctype.h>

--- 8 unchanged lines hidden (view full) ---

45#include <string.h>
46#include <unistd.h>
47
48int iotest;
49
50#define LBUF 100
51static char lbuf[LBUF];
52
53#ifndef PC98
54#define MBRSIGOFF 510
55#endif
56
57/*
58 *
59 * Ported to 386bsd by Julian Elischer Thu Oct 15 20:26:46 PDT 1992
60 *
61 * 14-Dec-89 Robert Baron (rvb) at Carnegie-Mellon University
62 * Copyright (c) 1989 Robert. V. Baron
63 * Created.
64 */

--- 6 unchanged lines hidden (view full) ---

71#define MAX_SEC_SIZE 2048 /* maximum section size that is supported */
72#define MIN_SEC_SIZE 512 /* the sector size to start sensing at */
73static int secsize = 0; /* the sensed sector size */
74
75static char *disk;
76
77static int cyls, sectors, heads, cylsecs, disksecs;
78
53/*
54 *
55 * Ported to 386bsd by Julian Elischer Thu Oct 15 20:26:46 PDT 1992
56 *
57 * 14-Dec-89 Robert Baron (rvb) at Carnegie-Mellon University
58 * Copyright (c) 1989 Robert. V. Baron
59 * Created.
60 */

--- 6 unchanged lines hidden (view full) ---

67#define MAX_SEC_SIZE 2048 /* maximum section size that is supported */
68#define MIN_SEC_SIZE 512 /* the sector size to start sensing at */
69static int secsize = 0; /* the sensed sector size */
70
71static char *disk;
72
73static int cyls, sectors, heads, cylsecs, disksecs;
74
79#ifdef PC98
80struct mboot {
81 unsigned char padding[2]; /* force the longs to be long aligned */
82 unsigned char bootinst[510];
83 unsigned short int signature;
84 struct pc98_partition parts[8];
85 unsigned char large_sector_overflow[MAX_SEC_SIZE-MIN_SEC_SIZE];
86};
75struct mboot {
76 unsigned char padding[2]; /* force the longs to be long aligned */
77 unsigned char bootinst[510];
78 unsigned short int signature;
79 struct pc98_partition parts[8];
80 unsigned char large_sector_overflow[MAX_SEC_SIZE-MIN_SEC_SIZE];
81};
87#else /* PC98 */
88struct mboot {
89 unsigned char padding[2]; /* force the longs to be long aligned */
90 unsigned char *bootinst; /* boot code */
91 off_t bootinst_size;
92 struct dos_partition parts[4];
93};
94#endif /* PC98 */
95
96static struct mboot mboot;
97static int fd, fdw;
98
99#define ACTIVE 0x80
82
83static struct mboot mboot;
84static int fd, fdw;
85
86#define ACTIVE 0x80
100#define BOOT_MAGIC 0xAA55
101
102static uint dos_cyls;
103static uint dos_heads;
104static uint dos_sectors;
105static uint dos_cylsecs;
106
87
88static uint dos_cyls;
89static uint dos_heads;
90static uint dos_sectors;
91static uint dos_cylsecs;
92
107#ifndef PC98
108#define DOSSECT(s,c) ((s & 0x3f) | ((c >> 2) & 0xc0))
109#define DOSCYL(c) (c & 0xff)
110#endif
111
112#define MAX_ARGS 10
113
93#define MAX_ARGS 10
94
114static int current_line_number;
115
116typedef struct cmd {
117 char cmd;
118 int n_args;
119 struct arg {
120 char argtype;
121 int arg_val;
122 } args[MAX_ARGS];
123} CMD;
124
125static int B_flag = 0; /* replace boot code */
95typedef struct cmd {
96 char cmd;
97 int n_args;
98 struct arg {
99 char argtype;
100 int arg_val;
101 } args[MAX_ARGS];
102} CMD;
103
104static int B_flag = 0; /* replace boot code */
126#ifndef PC98
127static int I_flag = 0; /* use entire disk for FreeBSD */
128#endif
129static int a_flag = 0; /* set active partition */
105static int a_flag = 0; /* set active partition */
130#ifndef PC98
131static char *b_flag = NULL; /* path to boot code */
132#endif
133static int i_flag = 0; /* replace partition data */
134static int u_flag = 0; /* update partition data */
135static int s_flag = 0; /* Print a summary and exit */
136static int t_flag = 0; /* test only */
137static char *f_flag = NULL; /* Read config info from file */
138static int v_flag = 0; /* Be verbose */
139
140static struct part_type
141{
142 unsigned char type;
143 const char *name;
144} part_types[] = {
106static int i_flag = 0; /* replace partition data */
107static int u_flag = 0; /* update partition data */
108static int s_flag = 0; /* Print a summary and exit */
109static int t_flag = 0; /* test only */
110static char *f_flag = NULL; /* Read config info from file */
111static int v_flag = 0; /* Be verbose */
112
113static struct part_type
114{
115 unsigned char type;
116 const char *name;
117} part_types[] = {
145#ifdef PC98
146 {0x00, "unused"}
147 ,{0x01, "Primary DOS with 12 bit FAT"}
148 ,{0x11, "MSDOS"}
149 ,{0x20, "MSDOS"}
150 ,{0x21, "MSDOS"}
151 ,{0x22, "MSDOS"}
152 ,{0x23, "MSDOS"}
153 ,{0x02, "XENIX / file system"}

--- 14 unchanged lines hidden (view full) ---

168 ,{0x52, "CP/M or Microport SysV/AT"}
169 ,{0x56, "GB"}
170 ,{0x61, "Speed"}
171 ,{0x63, "ISC UNIX, other System V/386, GNU HURD or Mach"}
172 ,{0x64, "Novell Netware 2.xx"}
173 ,{0x65, "Novell Netware 3.xx"}
174 ,{0x75, "PCIX"}
175 ,{0x40, "Minix"}
118 {0x00, "unused"}
119 ,{0x01, "Primary DOS with 12 bit FAT"}
120 ,{0x11, "MSDOS"}
121 ,{0x20, "MSDOS"}
122 ,{0x21, "MSDOS"}
123 ,{0x22, "MSDOS"}
124 ,{0x23, "MSDOS"}
125 ,{0x02, "XENIX / file system"}

--- 14 unchanged lines hidden (view full) ---

140 ,{0x52, "CP/M or Microport SysV/AT"}
141 ,{0x56, "GB"}
142 ,{0x61, "Speed"}
143 ,{0x63, "ISC UNIX, other System V/386, GNU HURD or Mach"}
144 ,{0x64, "Novell Netware 2.xx"}
145 ,{0x65, "Novell Netware 3.xx"}
146 ,{0x75, "PCIX"}
147 ,{0x40, "Minix"}
176#endif
177};
178
179static void print_s0(int which);
180static void print_part(int i);
181static void init_sector0(unsigned long start);
182static void init_boot(void);
183static void change_part(int i);
184static void print_params(void);
185static void change_active(int which);
186static void change_code(void);
187static void get_params_to_use(void);
188static char *get_rootdisk(void);
148};
149
150static void print_s0(int which);
151static void print_part(int i);
152static void init_sector0(unsigned long start);
153static void init_boot(void);
154static void change_part(int i);
155static void print_params(void);
156static void change_active(int which);
157static void change_code(void);
158static void get_params_to_use(void);
159static char *get_rootdisk(void);
189#ifdef PC98
190static void dos(int sec, int size,
191 unsigned short *c, unsigned char *s, unsigned char *h);
192#else
193static void dos(struct dos_partition *partp);
194#endif
160static void dos(u_int32_t start, u_int32_t size, struct pc98_partition *partp);
195static int open_disk(int flag);
196static ssize_t read_disk(off_t sector, void *buf);
197static ssize_t write_disk(off_t sector, void *buf);
198static int get_params(void);
199static int read_s0(void);
200static int write_s0(void);
201static int ok(const char *str);
202static int decimal(const char *str, int *num, int deflt);
203static const char *get_type(int type);
161static int open_disk(int flag);
162static ssize_t read_disk(off_t sector, void *buf);
163static ssize_t write_disk(off_t sector, void *buf);
164static int get_params(void);
165static int read_s0(void);
166static int write_s0(void);
167static int ok(const char *str);
168static int decimal(const char *str, int *num, int deflt);
169static const char *get_type(int type);
204static int read_config(char *config_file);
205static void reset_boot(void);
206#ifndef PC98
207static int sanitize_partition(struct dos_partition *);
208#endif
209static void usage(void);
170static void usage(void);
210#ifdef PC98
211static int string(char *str, char **ans);
212#endif
171static int string(const char *str, char **ans);
213
214int
215main(int argc, char *argv[])
216{
217 struct stat sb;
218 int c, i;
219 int partition = -1;
220 struct pc98_partition *partp;
221
172
173int
174main(int argc, char *argv[])
175{
176 struct stat sb;
177 int c, i;
178 int partition = -1;
179 struct pc98_partition *partp;
180
222#ifdef PC98
223 while ((c = getopt(argc, argv, "Ba:f:istuv12345678")) != -1)
181 while ((c = getopt(argc, argv, "Ba:f:istuv12345678")) != -1)
224#else
225 while ((c = getopt(argc, argv, "BIab:f:istuv1234")) != -1)
226#endif
227 switch (c) {
228 case 'B':
229 B_flag = 1;
230 break;
182 switch (c) {
183 case 'B':
184 B_flag = 1;
185 break;
231#ifndef PC98
232 case 'I':
233 I_flag = 1;
234 break;
235#endif
236 case 'a':
237 a_flag = 1;
238 break;
186 case 'a':
187 a_flag = 1;
188 break;
239#ifndef PC98
240 case 'b':
241 b_flag = optarg;
242 break;
243#endif
244 case 'f':
245 f_flag = optarg;
246 break;
247 case 'i':
248 i_flag = 1;
249 break;
250 case 's':
251 s_flag = 1;

--- 6 unchanged lines hidden (view full) ---

258 break;
259 case 'v':
260 v_flag = 1;
261 break;
262 case '1':
263 case '2':
264 case '3':
265 case '4':
189 case 'f':
190 f_flag = optarg;
191 break;
192 case 'i':
193 i_flag = 1;
194 break;
195 case 's':
196 s_flag = 1;

--- 6 unchanged lines hidden (view full) ---

203 break;
204 case 'v':
205 v_flag = 1;
206 break;
207 case '1':
208 case '2':
209 case '3':
210 case '4':
266#ifdef PC98
267 case '5':
268 case '6':
269 case '7':
270 case '8':
211 case '5':
212 case '6':
213 case '7':
214 case '8':
271#endif
272 partition = c - '0';
273 break;
274 default:
275 usage();
276 }
277 if (f_flag || i_flag)
278 u_flag = 1;
279 if (t_flag)

--- 15 unchanged lines hidden (view full) ---

295 } else {
296 /* other stat error, let it fail below */
297 disk = argv[0];
298 }
299 }
300 if (open_disk(u_flag) < 0)
301 err(1, "cannot open disk %s", disk);
302
215 partition = c - '0';
216 break;
217 default:
218 usage();
219 }
220 if (f_flag || i_flag)
221 u_flag = 1;
222 if (t_flag)

--- 15 unchanged lines hidden (view full) ---

238 } else {
239 /* other stat error, let it fail below */
240 disk = argv[0];
241 }
242 }
243 if (open_disk(u_flag) < 0)
244 err(1, "cannot open disk %s", disk);
245
303#ifndef PC98
304 /* (abu)use mboot.bootinst to probe for the sector size */
305 if ((mboot.bootinst = malloc(MAX_SEC_SIZE)) == NULL)
306 err(1, "cannot allocate buffer to determine disk sector size");
307 read_disk(0, mboot.bootinst);
308 free(mboot.bootinst);
309 mboot.bootinst = NULL;
310#endif
311
312 if (s_flag) {
313 if (read_s0())
314 err(1, "read_s0");
315 printf("%s: %d cyl %d hd %d sec\n", disk, dos_cyls, dos_heads,
316 dos_sectors);
246 if (s_flag) {
247 if (read_s0())
248 err(1, "read_s0");
249 printf("%s: %d cyl %d hd %d sec\n", disk, dos_cyls, dos_heads,
250 dos_sectors);
317#ifdef PC98
318 printf("Part %11s %11s SID\n", "Start", "Size");
319 for (i = 0; i < NDOSPART; i++) {
320 partp = ((struct pc98_partition *) &mboot.parts) + i;
321 if (partp->dp_sid == 0)
322 continue;
251 printf("Part %11s %11s SID\n", "Start", "Size");
252 for (i = 0; i < NDOSPART; i++) {
253 partp = ((struct pc98_partition *) &mboot.parts) + i;
254 if (partp->dp_sid == 0)
255 continue;
323 printf("%4d: %11lu %11lu 0x%02x\n", i + 1,
256 printf("%4d: %11u %11u 0x%02x\n", i + 1,
324 partp->dp_scyl * cylsecs,
325 (partp->dp_ecyl - partp->dp_scyl + 1) * cylsecs,
326 partp->dp_sid);
257 partp->dp_scyl * cylsecs,
258 (partp->dp_ecyl - partp->dp_scyl + 1) * cylsecs,
259 partp->dp_sid);
327#else
328 printf("Part %11s %11s Type Flags\n", "Start", "Size");
329 for (i = 0; i < NDOSPART; i++) {
330 partp = ((struct dos_partition *) &mboot.parts) + i;
331 if (partp->dp_start == 0 && partp->dp_size == 0)
332 continue;
333 printf("%4d: %11lu %11lu 0x%02x 0x%02x\n", i + 1,
334 (u_long) partp->dp_start,
335 (u_long) partp->dp_size, partp->dp_typ,
336 partp->dp_flag);
337#endif
338 }
339 exit(0);
340 }
341
342 printf("******* Working on device %s *******\n",disk);
343
260 }
261 exit(0);
262 }
263
264 printf("******* Working on device %s *******\n",disk);
265
344#ifndef PC98
345 if (I_flag) {
346 read_s0();
347 reset_boot();
348 partp = (struct dos_partition *) (&mboot.parts[0]);
349 partp->dp_typ = DOSPTYP_386BSD;
350 partp->dp_flag = ACTIVE;
351 partp->dp_start = dos_sectors;
352 partp->dp_size = (disksecs / dos_cylsecs) * dos_cylsecs -
353 dos_sectors;
354 dos(partp);
355 if (v_flag)
356 print_s0(-1);
357 if (!t_flag)
358 write_s0();
359 exit(0);
360 }
361#endif
362 if (f_flag) {
266 if (f_flag) {
363#ifndef PC98
364 if (read_s0() || i_flag)
365 reset_boot();
366 if (!read_config(f_flag))
367 exit(1);
368#endif
369 if (v_flag)
370 print_s0(-1);
371 if (!t_flag)
372 write_s0();
373 } else {
374 if(u_flag)
375 get_params_to_use();
376 else

--- 70 unchanged lines hidden (view full) ---

447
448 if (!bcmp(partp, &mtpart, sizeof (struct pc98_partition))) {
449 printf("<UNUSED>\n");
450 return;
451 }
452 /*
453 * Be careful not to overflow.
454 */
267 if (v_flag)
268 print_s0(-1);
269 if (!t_flag)
270 write_s0();
271 } else {
272 if(u_flag)
273 get_params_to_use();
274 else

--- 70 unchanged lines hidden (view full) ---

345
346 if (!bcmp(partp, &mtpart, sizeof (struct pc98_partition))) {
347 printf("<UNUSED>\n");
348 return;
349 }
350 /*
351 * Be careful not to overflow.
352 */
455#ifdef PC98
456 part_sz = (partp->dp_ecyl - partp->dp_scyl + 1) * cylsecs;
457 part_mb = part_sz * secsize;
458 part_mb /= (1024 * 1024);
459 printf("sysmid %d (%#04x),(%s)\n", partp->dp_mid, partp->dp_mid,
460 get_type(partp->dp_mid));
461 printf(" start %lu, size %lu (%ju Meg), sid %d\n",
462 (u_long)(partp->dp_scyl * cylsecs), (u_long)part_sz,
463 (uintmax_t)part_mb, partp->dp_sid);
353 part_sz = (partp->dp_ecyl - partp->dp_scyl + 1) * cylsecs;
354 part_mb = part_sz * secsize;
355 part_mb /= (1024 * 1024);
356 printf("sysmid %d (%#04x),(%s)\n", partp->dp_mid, partp->dp_mid,
357 get_type(partp->dp_mid));
358 printf(" start %lu, size %lu (%ju Meg), sid %d\n",
359 (u_long)(partp->dp_scyl * cylsecs), (u_long)part_sz,
360 (uintmax_t)part_mb, partp->dp_sid);
464#else
465 part_mb = partp->dp_size;
466 part_mb *= secsize;
467 part_mb /= (1024 * 1024);
468 printf("sysid %d (%#04x),(%s)\n", partp->dp_typ, partp->dp_typ,
469 get_type(partp->dp_typ));
470 printf(" start %lu, size %lu (%ju Meg), flag %x%s\n",
471 (u_long)partp->dp_start,
472 (u_long)partp->dp_size,
473 (uintmax_t)part_mb,
474 partp->dp_flag,
475 partp->dp_flag == ACTIVE ? " (active)" : "");
476#endif
477 printf("\tbeg: cyl %d/ head %d/ sector %d;\n\tend: cyl %d/ head %d/ sector %d\n"
478 ,partp->dp_scyl
479 ,partp->dp_shd
480 ,partp->dp_ssect
481 ,partp->dp_ecyl
482 ,partp->dp_ehd
483 ,partp->dp_esect);
361 printf("\tbeg: cyl %d/ head %d/ sector %d;\n\tend: cyl %d/ head %d/ sector %d\n"
362 ,partp->dp_scyl
363 ,partp->dp_shd
364 ,partp->dp_ssect
365 ,partp->dp_ecyl
366 ,partp->dp_ehd
367 ,partp->dp_esect);
484#ifdef PC98
485 printf ("\tsystem Name %.16s\n",partp->dp_name);
486#endif
368 printf ("\tsystem Name %.16s\n", partp->dp_name);
487}
488
489
490static void
491init_boot(void)
492{
369}
370
371
372static void
373init_boot(void)
374{
493#ifdef PC98
494 mboot.signature = BOOT_MAGIC;
495#else
496 const char *fname;
497 int fdesc, n;
498 struct stat sb;
499
375
500 fname = b_flag ? b_flag : "/boot/mbr";
501 if ((fdesc = open(fname, O_RDONLY)) == -1 ||
502 fstat(fdesc, &sb) == -1)
503 err(1, "%s", fname);
504 if ((mboot.bootinst_size = sb.st_size) % secsize != 0)
505 errx(1, "%s: length must be a multiple of sector size", fname);
506 if (mboot.bootinst != NULL)
507 free(mboot.bootinst);
508 if ((mboot.bootinst = malloc(mboot.bootinst_size = sb.st_size)) == NULL)
509 errx(1, "%s: unable to allocate read buffer", fname);
510 if ((n = read(fdesc, mboot.bootinst, mboot.bootinst_size)) == -1 ||
511 close(fdesc))
512 err(1, "%s", fname);
513 if (n != mboot.bootinst_size)
514 errx(1, "%s: short read", fname);
515#endif
376 mboot.signature = DOSMAGIC;
516}
517
518
519static void
520init_sector0(unsigned long start)
521{
377}
378
379
380static void
381init_sector0(unsigned long start)
382{
522#ifdef PC98
523 struct pc98_partition *partp =
383 struct pc98_partition *partp =
524 (struct pc98_partition *)(&mboot.parts[3]);
525 unsigned long size = disksecs - start;
384 (struct pc98_partition *)(&mboot.parts[0]);
526
527 init_boot();
528
529 partp->dp_mid = DOSMID_386BSD;
530 partp->dp_sid = DOSSID_386BSD;
531
385
386 init_boot();
387
388 partp->dp_mid = DOSMID_386BSD;
389 partp->dp_sid = DOSSID_386BSD;
390
532 dos(start, size, &partp->dp_scyl, &partp->dp_ssect, &partp->dp_shd);
533 partp->dp_ipl_cyl = partp->dp_scyl;
534 partp->dp_ipl_sct = partp->dp_ssect;
535 partp->dp_ipl_head = partp->dp_shd;
536 dos(start+size-cylsecs, size,
537 &partp->dp_ecyl, &partp->dp_esect, &partp->dp_ehd);
538#else
539 struct dos_partition *partp = (struct dos_partition *) (&mboot.parts[3]);
540
541 init_boot();
542
543 partp->dp_typ = DOSPTYP_386BSD;
544 partp->dp_flag = ACTIVE;
545 start = ((start + dos_sectors - 1) / dos_sectors) * dos_sectors;
546 if(start == 0)
547 start = dos_sectors;
548 partp->dp_start = start;
549 partp->dp_size = (disksecs / dos_cylsecs) * dos_cylsecs - start;
550
551 dos(partp);
552#endif
391 dos(start, disksecs - start, partp);
553}
554
555static void
556change_part(int i)
557{
558 struct pc98_partition *partp =
559 ((struct pc98_partition *) &mboot.parts) + i - 1;
560
561 printf("The data for partition %d is:\n", i);
562 print_part(i);
563
564 if (u_flag && ok("Do you want to change it?")) {
565 int tmp;
566
567 if (i_flag) {
568 bzero((char *)partp, sizeof (struct pc98_partition));
392}
393
394static void
395change_part(int i)
396{
397 struct pc98_partition *partp =
398 ((struct pc98_partition *) &mboot.parts) + i - 1;
399
400 printf("The data for partition %d is:\n", i);
401 print_part(i);
402
403 if (u_flag && ok("Do you want to change it?")) {
404 int tmp;
405
406 if (i_flag) {
407 bzero((char *)partp, sizeof (struct pc98_partition));
569 if (i == 4) {
408 if (i == 1) {
570 init_sector0(1);
409 init_sector0(1);
571 printf("\nThe static data for the DOS partition 4 has been reinitialized to:\n");
410 printf("\nThe static data for the slice 1 has been reinitialized to:\n");
572 print_part(i);
573 }
574 }
575
576 do {
411 print_part(i);
412 }
413 }
414
415 do {
577#ifdef PC98
578 int x_start = partp->dp_scyl * cylsecs ;
579 int x_size = (partp->dp_ecyl - partp->dp_scyl + 1) * cylsecs;
580 Decimal("sysmid", partp->dp_mid, tmp);
581 Decimal("syssid", partp->dp_sid, tmp);
582 String ("system name", partp->dp_name, 16);
583 Decimal("start", x_start, tmp);
584 Decimal("size", x_size, tmp);
416 int x_start = partp->dp_scyl * cylsecs ;
417 int x_size = (partp->dp_ecyl - partp->dp_scyl + 1) * cylsecs;
418 Decimal("sysmid", partp->dp_mid, tmp);
419 Decimal("syssid", partp->dp_sid, tmp);
420 String ("system name", partp->dp_name, 16);
421 Decimal("start", x_start, tmp);
422 Decimal("size", x_size, tmp);
585#else
586 Decimal("sysid (165=FreeBSD)", partp->dp_typ, tmp);
587 Decimal("start", partp->dp_start, tmp);
588 Decimal("size", partp->dp_size, tmp);
589 if (!sanitize_partition(partp)) {
590 warnx("ERROR: failed to adjust; setting sysid to 0");
591 partp->dp_typ = 0;
592 }
593#endif
594
595 if (ok("Explicitly specify beg/end address ?"))
596 {
597 int tsec,tcyl,thd;
598 tcyl = partp->dp_scyl;
599 thd = partp->dp_shd;
600 tsec = partp->dp_ssect;
601 Decimal("beginning cylinder", tcyl, tmp);
602 Decimal("beginning head", thd, tmp);
603 Decimal("beginning sector", tsec, tmp);
423
424 if (ok("Explicitly specify beg/end address ?"))
425 {
426 int tsec,tcyl,thd;
427 tcyl = partp->dp_scyl;
428 thd = partp->dp_shd;
429 tsec = partp->dp_ssect;
430 Decimal("beginning cylinder", tcyl, tmp);
431 Decimal("beginning head", thd, tmp);
432 Decimal("beginning sector", tsec, tmp);
604#ifdef PC98
605 partp->dp_scyl = tcyl;
606 partp->dp_ssect = tsec;
607 partp->dp_shd = thd;
608 partp->dp_ipl_cyl = partp->dp_scyl;
609 partp->dp_ipl_sct = partp->dp_ssect;
610 partp->dp_ipl_head = partp->dp_shd;
433 partp->dp_scyl = tcyl;
434 partp->dp_ssect = tsec;
435 partp->dp_shd = thd;
436 partp->dp_ipl_cyl = partp->dp_scyl;
437 partp->dp_ipl_sct = partp->dp_ssect;
438 partp->dp_ipl_head = partp->dp_shd;
611#else
612 partp->dp_scyl = DOSCYL(tcyl);
613 partp->dp_ssect = DOSSECT(tsec,tcyl);
614 partp->dp_shd = thd;
615#endif
616
617 tcyl = partp->dp_ecyl;
618 thd = partp->dp_ehd;
619 tsec = partp->dp_esect;
620 Decimal("ending cylinder", tcyl, tmp);
621 Decimal("ending head", thd, tmp);
622 Decimal("ending sector", tsec, tmp);
439
440 tcyl = partp->dp_ecyl;
441 thd = partp->dp_ehd;
442 tsec = partp->dp_esect;
443 Decimal("ending cylinder", tcyl, tmp);
444 Decimal("ending head", thd, tmp);
445 Decimal("ending sector", tsec, tmp);
623#ifdef PC98
624 partp->dp_ecyl = tcyl;
625 partp->dp_esect = tsec;
626 partp->dp_ehd = thd;
446 partp->dp_ecyl = tcyl;
447 partp->dp_esect = tsec;
448 partp->dp_ehd = thd;
627#else
628 partp->dp_ecyl = DOSCYL(tcyl);
629 partp->dp_esect = DOSSECT(tsec,tcyl);
630 partp->dp_ehd = thd;
631#endif
632#ifdef PC98
633 } else {
634 dos(x_start, x_size, &partp->dp_scyl,
635 &partp->dp_ssect, &partp->dp_shd);
636 partp->dp_ipl_cyl = partp->dp_scyl;
637 partp->dp_ipl_sct = partp->dp_ssect;
638 partp->dp_ipl_head = partp->dp_shd;
639 dos(x_start+x_size - cylsecs, x_size, &partp->dp_ecyl,
640 &partp->dp_esect, &partp->dp_ehd);
641 }
642#else
643 } else
449 } else
644 dos(partp);
645#endif
450 dos(x_start, x_size, partp);
646
647 print_part(i);
648 } while (!ok("Are we happy with this entry?"));
649 }
650}
651
652static void
653print_params()
654{
655 printf("parameters extracted from in-core disklabel are:\n");
656 printf("cylinders=%d heads=%d sectors/track=%d (%d blks/cyl)\n\n"
657 ,cyls,heads,sectors,cylsecs);
451
452 print_part(i);
453 } while (!ok("Are we happy with this entry?"));
454 }
455}
456
457static void
458print_params()
459{
460 printf("parameters extracted from in-core disklabel are:\n");
461 printf("cylinders=%d heads=%d sectors/track=%d (%d blks/cyl)\n\n"
462 ,cyls,heads,sectors,cylsecs);
658#ifndef PC98
659 if((dos_sectors > 63) || (dos_cyls > 1023) || (dos_heads > 255))
463 if (dos_cyls > 65535 || dos_heads > 255 || dos_sectors > 255)
660 printf("Figures below won't work with BIOS for partitions not in cyl 1\n");
464 printf("Figures below won't work with BIOS for partitions not in cyl 1\n");
661#endif
662 printf("parameters to be used for BIOS calculations are:\n");
663 printf("cylinders=%d heads=%d sectors/track=%d (%d blks/cyl)\n\n"
664 ,dos_cyls,dos_heads,dos_sectors,dos_cylsecs);
665}
666
667static void
668change_active(int which)
669{
465 printf("parameters to be used for BIOS calculations are:\n");
466 printf("cylinders=%d heads=%d sectors/track=%d (%d blks/cyl)\n\n"
467 ,dos_cyls,dos_heads,dos_sectors,dos_cylsecs);
468}
469
470static void
471change_active(int which)
472{
670#ifdef PC98
671 struct pc98_partition *partp = ((struct pc98_partition *) &mboot.parts);
672 int active, i, tmp;
673
674 active = 8;
675#else
676 struct dos_partition *partp = &mboot.parts[0];
473 struct pc98_partition *partp = &mboot.parts[0];
677 int active, i, new, tmp;
678
679 active = -1;
680 for (i = 0; i < NDOSPART; i++) {
474 int active, i, new, tmp;
475
476 active = -1;
477 for (i = 0; i < NDOSPART; i++) {
681 if ((partp[i].dp_flag & ACTIVE) == 0)
478 if ((partp[i].dp_sid & ACTIVE) == 0)
682 continue;
683 printf("Partition %d is marked active\n", i + 1);
684 if (active == -1)
685 active = i + 1;
686 }
479 continue;
480 printf("Partition %d is marked active\n", i + 1);
481 if (active == -1)
482 active = i + 1;
483 }
687#endif
688 if (a_flag && which != -1)
689 active = which;
484 if (a_flag && which != -1)
485 active = which;
690#ifndef PC98
691 else if (active == -1)
692 active = 1;
486 else if (active == -1)
487 active = 1;
693#endif
694
695 if (!ok("Do you want to change the active partition?"))
696 return;
697setactive:
488
489 if (!ok("Do you want to change the active partition?"))
490 return;
491setactive:
698#ifdef PC98
699 active = 4;
700 do {
492 do {
701 Decimal("active partition", active, tmp);
702 if (active < 1 || 8 < active) {
703 printf("Active partition number must be in range 1-8."
704 " Try again.\n");
705 goto setactive;
706 }
707 } while (!ok("Are you happy with this choice"));
708 partp[active].dp_sid |= ACTIVE;
709#else
710 do {
711 new = active;
712 Decimal("active partition", new, tmp);
493 new = active;
494 Decimal("active partition", new, tmp);
713 if (new < 1 || new > 4) {
714 printf("Active partition number must be in range 1-4."
495 if (new < 1 || new > 8) {
496 printf("Active partition number must be in range 1-8."
715 " Try again.\n");
716 goto setactive;
717 }
718 active = new;
719 } while (!ok("Are you happy with this choice"));
497 " Try again.\n");
498 goto setactive;
499 }
500 active = new;
501 } while (!ok("Are you happy with this choice"));
720 for (i = 0; i < NDOSPART; i++)
721 partp[i].dp_flag = 0;
722 if (active > 0 && active <= NDOSPART)
723 partp[active-1].dp_flag = ACTIVE;
724#endif
502 if (active > 0 && active <= 8)
503 partp[active-1].dp_sid |= ACTIVE;
725}
726
727static void
728change_code()
729{
730 if (ok("Do you want to change the boot code?"))
731 init_boot();
732}

--- 16 unchanged lines hidden (view full) ---

749 while(!ok("Are you happy with this choice"));
750 }
751}
752
753
754/***********************************************\
755* Change real numbers into strange dos numbers *
756\***********************************************/
504}
505
506static void
507change_code()
508{
509 if (ok("Do you want to change the boot code?"))
510 init_boot();
511}

--- 16 unchanged lines hidden (view full) ---

528 while(!ok("Are you happy with this choice"));
529 }
530}
531
532
533/***********************************************\
534* Change real numbers into strange dos numbers *
535\***********************************************/
757#ifdef PC98
758static void
536static void
759dos(int sec, int size, unsigned short *c, unsigned char *s, unsigned char *h)
537dos(u_int32_t start, u_int32_t size, struct pc98_partition *partp)
760{
538{
761 int cy, hd;
762
763 if (sec == 0 && size == 0) {
764 *s = *c = *h = 0;
765 return;
766 }
767
768 cy = sec / ( dos_cylsecs );
769 sec = sec - cy * ( dos_cylsecs );
770
771 hd = sec / dos_sectors;
772 sec = (sec - hd * dos_sectors);
773
774 *h = hd;
775 *c = cy;
776 *s = sec;
777}
778#else
779static void
780dos(struct dos_partition *partp)
781{
782 int cy, sec;
783 u_int32_t end;
784
539 u_int32_t end;
540
785 if (partp->dp_typ == 0 && partp->dp_start == 0 && partp->dp_size == 0) {
541 if (partp->dp_mid == 0 && partp->dp_sid == 0 &&
542 start == 0 && size == 0) {
786 memcpy(partp, &mtpart, sizeof(*partp));
787 return;
788 }
789
790 /* Start c/h/s. */
543 memcpy(partp, &mtpart, sizeof(*partp));
544 return;
545 }
546
547 /* Start c/h/s. */
791 partp->dp_shd = partp->dp_start % dos_cylsecs / dos_sectors;
792 cy = partp->dp_start / dos_cylsecs;
793 sec = partp->dp_start % dos_sectors + 1;
794 partp->dp_scyl = DOSCYL(cy);
795 partp->dp_ssect = DOSSECT(sec, cy);
548 partp->dp_scyl = partp->dp_ipl_cyl = start / dos_cylsecs;
549 partp->dp_shd = partp->dp_ipl_head = start % dos_cylsecs / dos_sectors;
550 partp->dp_ssect = partp->dp_ipl_sct = start % dos_sectors;
796
797 /* End c/h/s. */
551
552 /* End c/h/s. */
798 end = partp->dp_start + partp->dp_size - 1;
553 end = start + size - cylsecs;
554 partp->dp_ecyl = end / dos_cylsecs;
799 partp->dp_ehd = end % dos_cylsecs / dos_sectors;
555 partp->dp_ehd = end % dos_cylsecs / dos_sectors;
800 cy = end / dos_cylsecs;
801 sec = end % dos_sectors + 1;
802 partp->dp_ecyl = DOSCYL(cy);
803 partp->dp_esect = DOSSECT(sec, cy);
556 partp->dp_esect = end % dos_sectors;
804}
557}
805#endif
806
807static int
808open_disk(int flag)
809{
810 struct stat st;
811 int rwmode, p;
812 char *s;
813
814 fdw = -1;
815 if (stat(disk, &st) == -1) {
816 if (errno == ENOENT)
817 return -2;
818 warnx("can't get file status of %s", disk);
819 return -1;
820 }
821 if ( !(st.st_mode & S_IFCHR) )
822 warnx("device %s is not character special", disk);
558
559static int
560open_disk(int flag)
561{
562 struct stat st;
563 int rwmode, p;
564 char *s;
565
566 fdw = -1;
567 if (stat(disk, &st) == -1) {
568 if (errno == ENOENT)
569 return -2;
570 warnx("can't get file status of %s", disk);
571 return -1;
572 }
573 if ( !(st.st_mode & S_IFCHR) )
574 warnx("device %s is not character special", disk);
823#ifdef PC98
824 rwmode = a_flag || B_flag || flag ? O_RDWR : O_RDONLY;
575 rwmode = a_flag || B_flag || flag ? O_RDWR : O_RDONLY;
825#else
826 rwmode = a_flag || I_flag || B_flag || flag ? O_RDWR : O_RDONLY;
827#endif
828 fd = open(disk, rwmode);
829 if (fd == -1 && errno == ENXIO)
830 return -2;
831 if (fd == -1 && errno == EPERM && rwmode == O_RDWR) {
832 fd = open(disk, O_RDONLY);
833 if (fd == -1)
834 return -3;
835 for (p = 0; p < NDOSPART; p++) {

--- 16 unchanged lines hidden (view full) ---

852 return -1;
853 }
854 return fd;
855}
856
857static ssize_t
858read_disk(off_t sector, void *buf)
859{
576 fd = open(disk, rwmode);
577 if (fd == -1 && errno == ENXIO)
578 return -2;
579 if (fd == -1 && errno == EPERM && rwmode == O_RDWR) {
580 fd = open(disk, O_RDONLY);
581 if (fd == -1)
582 return -3;
583 for (p = 0; p < NDOSPART; p++) {

--- 16 unchanged lines hidden (view full) ---

600 return -1;
601 }
602 return fd;
603}
604
605static ssize_t
606read_disk(off_t sector, void *buf)
607{
860 lseek(fd,(sector * 512), 0);
861#ifdef PC98
608
609 lseek(fd, (sector * 512), 0);
862 return read(fd, buf,
863 secsize > MIN_SEC_SIZE ? secsize : MIN_SEC_SIZE * 2);
610 return read(fd, buf,
611 secsize > MIN_SEC_SIZE ? secsize : MIN_SEC_SIZE * 2);
864#else
865 if( secsize == 0 )
866 for( secsize = MIN_SEC_SIZE; secsize <= MAX_SEC_SIZE; secsize *= 2 )
867 {
868 /* try the read */
869 int size = read(fd, buf, secsize);
870 if( size == secsize )
871 /* it worked so return */
872 return secsize;
873 }
874 else
875 return read( fd, buf, secsize );
876
877 /* we failed to read at any of the sizes */
878 return -1;
879#endif
880}
881
882static ssize_t
883write_disk(off_t sector, void *buf)
884{
885
612}
613
614static ssize_t
615write_disk(off_t sector, void *buf)
616{
617
886#ifdef PC98
887 if (fdw != -1) {
888 return ioctl(fdw, DIOCSPC98, buf);
889 } else {
618 if (fdw != -1) {
619 return ioctl(fdw, DIOCSPC98, buf);
620 } else {
890 lseek(fd,(sector * 512), 0);
621 lseek(fd, (sector * 512), 0);
891 /* write out in the size that the read_disk found worked */
892 return write(fd, buf,
893 secsize > MIN_SEC_SIZE ? secsize : MIN_SEC_SIZE * 2);
894 }
622 /* write out in the size that the read_disk found worked */
623 return write(fd, buf,
624 secsize > MIN_SEC_SIZE ? secsize : MIN_SEC_SIZE * 2);
625 }
895#else
896 if (fdw != -1) {
897 return ioctl(fdw, DIOCSMBR, buf);
898 } else {
899 lseek(fd,(sector * 512), 0);
900 /* write out in the size that the read_disk found worked */
901 return write(fd, buf, secsize);
902 }
903#endif
904}
905
906static int
907get_params()
908{
909 int error;
910 u_int u;
911 off_t o;
912
913 error = ioctl(fd, DIOCGFWSECTORS, &u);
914 if (error == 0)
915 sectors = dos_sectors = u;
916 else
626}
627
628static int
629get_params()
630{
631 int error;
632 u_int u;
633 off_t o;
634
635 error = ioctl(fd, DIOCGFWSECTORS, &u);
636 if (error == 0)
637 sectors = dos_sectors = u;
638 else
917 sectors = dos_sectors = 63;
639 sectors = dos_sectors = 17;
918
919 error = ioctl(fd, DIOCGFWHEADS, &u);
920 if (error == 0)
921 heads = dos_heads = u;
922 else
640
641 error = ioctl(fd, DIOCGFWHEADS, &u);
642 if (error == 0)
643 heads = dos_heads = u;
644 else
923 heads = dos_heads = 255;
645 heads = dos_heads = 8;
924
925 dos_cylsecs = cylsecs = heads * sectors;
926 disksecs = cyls * heads * sectors;
927
928 error = ioctl(fd, DIOCGSECTORSIZE, &u);
929 if (error != 0 || u == 0)
930 u = 512;
646
647 dos_cylsecs = cylsecs = heads * sectors;
648 disksecs = cyls * heads * sectors;
649
650 error = ioctl(fd, DIOCGSECTORSIZE, &u);
651 if (error != 0 || u == 0)
652 u = 512;
931#ifdef PC98
932 secsize = u;
653 secsize = u;
933#endif
934
935 error = ioctl(fd, DIOCGMEDIASIZE, &o);
936 if (error == 0) {
937 disksecs = o / u;
938 cyls = dos_cyls = o / (u * dos_heads * dos_sectors);
939 }
940
941 return (disksecs);
942}
943
944
945static int
946read_s0()
947{
654
655 error = ioctl(fd, DIOCGMEDIASIZE, &o);
656 if (error == 0) {
657 disksecs = o / u;
658 cyls = dos_cyls = o / (u * dos_heads * dos_sectors);
659 }
660
661 return (disksecs);
662}
663
664
665static int
666read_s0()
667{
948#ifdef PC98
668
949 if (read_disk(0, (char *) mboot.bootinst) == -1) {
950 warnx("can't read fdisk partition table");
951 return -1;
952 }
669 if (read_disk(0, (char *) mboot.bootinst) == -1) {
670 warnx("can't read fdisk partition table");
671 return -1;
672 }
953 if (mboot.signature != BOOT_MAGIC) {
673 if (mboot.signature != DOSMAGIC) {
954 warnx("invalid fdisk partition table found");
955 /* So should we initialize things */
956 return -1;
957 }
674 warnx("invalid fdisk partition table found");
675 /* So should we initialize things */
676 return -1;
677 }
958#else
959 mboot.bootinst_size = secsize;
960 if (mboot.bootinst != NULL)
961 free(mboot.bootinst);
962 if ((mboot.bootinst = malloc(mboot.bootinst_size)) == NULL) {
963 warnx("unable to allocate buffer to read fdisk "
964 "partition table");
965 return -1;
966 }
967 if (read_disk(0, mboot.bootinst) == -1) {
968 warnx("can't read fdisk partition table");
969 return -1;
970 }
971 if (*(uint16_t *)(void *)&mboot.bootinst[MBRSIGOFF] != BOOT_MAGIC) {
972 warnx("invalid fdisk partition table found");
973 /* So should we initialize things */
974 return -1;
975 }
976 memcpy(mboot.parts, &mboot.bootinst[DOSPARTOFF], sizeof(mboot.parts));
977#endif
678
978 return 0;
979}
980
981static int
982write_s0()
983{
679 return 0;
680}
681
682static int
683write_s0()
684{
984#ifndef PC98
985 int sector;
986#endif
987
988 if (iotest) {
989 print_s0(-1);
990 return 0;
991 }
685
686 if (iotest) {
687 print_s0(-1);
688 return 0;
689 }
992#ifndef PC98
993 memcpy(&mboot.bootinst[DOSPARTOFF], mboot.parts, sizeof(mboot.parts));
994#endif
690
995 /*
996 * write enable label sector before write (if necessary),
997 * disable after writing.
998 * needed if the disklabel protected area also protects
999 * sector 0. (e.g. empty disk)
1000 */
691 /*
692 * write enable label sector before write (if necessary),
693 * disable after writing.
694 * needed if the disklabel protected area also protects
695 * sector 0. (e.g. empty disk)
696 */
1001#ifdef PC98
1002 if (write_disk(0, (char *) mboot.bootinst) == -1) {
1003 warn("can't write fdisk partition table");
1004 return -1;
1005 }
697 if (write_disk(0, (char *) mboot.bootinst) == -1) {
698 warn("can't write fdisk partition table");
699 return -1;
700 }
1006#else
1007 for(sector = 0; sector < mboot.bootinst_size / secsize; sector++)
1008 if (write_disk(sector,
1009 &mboot.bootinst[sector * secsize]) == -1) {
1010 warn("can't write fdisk partition table");
1011 return -1;
1012 }
1013#endif
701
1014 return(0);
1015}
1016
1017
1018static int
1019ok(const char *str)
1020{
1021 printf("%s [n] ", str);

--- 43 unchanged lines hidden (view full) ---

1065 return 1;
1066 } else
1067 printf("%s is an invalid decimal number. Try again.\n",
1068 lbuf);
1069 }
1070
1071}
1072
702 return(0);
703}
704
705
706static int
707ok(const char *str)
708{
709 printf("%s [n] ", str);

--- 43 unchanged lines hidden (view full) ---

753 return 1;
754 } else
755 printf("%s is an invalid decimal number. Try again.\n",
756 lbuf);
757 }
758
759}
760
1073#ifdef PC98
1074static int
761static int
1075string(char *str, char **ans)
762string(const char *str, char **ans)
1076{
1077 int i, c;
1078 char *cp = lbuf;
1079
1080 while (1) {
1081 printf("Supply a string value for \"%s\" [%s] ", str, *ans);
1082 fgets(lbuf, LBUF, stdin);
1083 lbuf[strlen(lbuf)-1] = 0;

--- 13 unchanged lines hidden (view full) ---

1097
1098 for (i = strlen(*ans); i < 16; i++)
1099 (*ans)[i] = ' ';
1100 (*ans)[16] = 0;
1101
1102 return 1;
1103 }
1104}
763{
764 int i, c;
765 char *cp = lbuf;
766
767 while (1) {
768 printf("Supply a string value for \"%s\" [%s] ", str, *ans);
769 fgets(lbuf, LBUF, stdin);
770 lbuf[strlen(lbuf)-1] = 0;

--- 13 unchanged lines hidden (view full) ---

784
785 for (i = strlen(*ans); i < 16; i++)
786 (*ans)[i] = ' ';
787 (*ans)[16] = 0;
788
789 return 1;
790 }
791}
1105#endif
1106
1107static const char *
1108get_type(int type)
1109{
1110 int numentries = (sizeof(part_types)/sizeof(struct part_type));
1111 int counter = 0;
1112 struct part_type *ptr = part_types;
1113
1114
1115 while(counter < numentries) {
792
793static const char *
794get_type(int type)
795{
796 int numentries = (sizeof(part_types)/sizeof(struct part_type));
797 int counter = 0;
798 struct part_type *ptr = part_types;
799
800
801 while(counter < numentries) {
1116#ifdef PC98
1117 if(ptr->type == (type & 0x7f))
1118 return(ptr->name);
802 if(ptr->type == (type & 0x7f))
803 return(ptr->name);
1119#else
1120 if(ptr->type == type)
1121 return(ptr->name);
1122#endif
1123 ptr++;
1124 counter++;
1125 }
1126 return("unknown");
1127}
1128
804 ptr++;
805 counter++;
806 }
807 return("unknown");
808}
809
1129#ifndef PC98
1130static int
1131sanitize_partition(struct dos_partition *partp)
1132{
1133 u_int32_t prev_head_boundary, prev_cyl_boundary;
1134 u_int32_t max_end, size, start;
1135
1136 start = partp->dp_start;
1137 size = partp->dp_size;
1138 max_end = start + size;
1139 /* Only allow a zero size if the partition is being marked unused. */
1140 if (size == 0) {
1141 if (start == 0 && partp->dp_typ == 0)
1142 return (1);
1143 warnx("ERROR: size of partition is zero");
1144 return (0);
1145 }
1146 /* Return if no adjustment is necessary. */
1147 if (start % dos_sectors == 0 && (start + size) % dos_sectors == 0)
1148 return (1);
1149
1150 if (start % dos_sectors != 0)
1151 warnx("WARNING: partition does not start on a head boundary");
1152 if ((start +size) % dos_sectors != 0)
1153 warnx("WARNING: partition does not end on a cylinder boundary");
1154 warnx("WARNING: this may confuse the BIOS or some operating systems");
1155 if (!ok("Correct this automatically?"))
1156 return (1);
1157
1158 /*
1159 * Adjust start upwards, if necessary, to fall on a head boundary.
1160 */
1161 if (start % dos_sectors != 0) {
1162 prev_head_boundary = start / dos_sectors * dos_sectors;
1163 if (max_end < dos_sectors ||
1164 prev_head_boundary >= max_end - dos_sectors) {
1165 /*
1166 * Can't go past end of partition
1167 */
1168 warnx(
1169 "ERROR: unable to adjust start of partition to fall on a head boundary");
1170 return (0);
1171 }
1172 start = prev_head_boundary + dos_sectors;
1173 }
1174
1175 /*
1176 * Adjust size downwards, if necessary, to fall on a cylinder
1177 * boundary.
1178 */
1179 prev_cyl_boundary = ((start + size) / dos_cylsecs) * dos_cylsecs;
1180 if (prev_cyl_boundary > start)
1181 size = prev_cyl_boundary - start;
1182 else {
1183 warnx("ERROR: could not adjust partition to start on a head boundary\n\
1184 and end on a cylinder boundary.");
1185 return (0);
1186 }
1187
1188 /* Finally, commit any changes to partp and return. */
1189 if (start != partp->dp_start) {
1190 warnx("WARNING: adjusting start offset of partition to %u",
1191 (u_int)start);
1192 partp->dp_start = start;
1193 }
1194 if (size != partp->dp_size) {
1195 warnx("WARNING: adjusting size of partition to %u", (u_int)size);
1196 partp->dp_size = size;
1197 }
1198
1199 return (1);
1200}
1201#endif /* PC98 */
1202
1203/*
1204 * Try figuring out the root device's canonical disk name.
1205 * The following choices are considered:
1206 * /dev/ad0s1a => /dev/ad0
1207 * /dev/da0a => /dev/da0
1208 * /dev/vinum/root => /dev/vinum/root
1209 */
1210static char *

--- 27 unchanged lines hidden --- 		810/*
811 * Try figuring out the root device's canonical disk name.
812 * The following choices are considered:
813 * /dev/ad0s1a => /dev/ad0
814 * /dev/da0a => /dev/da0
815 * /dev/vinum/root => /dev/vinum/root
816 */
817static char *

--- 27 unchanged lines hidden ---