initial commit
[freebsd-arm:freebsd-arm.git] / boot / i386 / libi386 / biosdisk.c
1 /*-
2  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 /*
31  * BIOS disk device handling.
32  * 
33  * Ideas and algorithms from:
34  *
35  * - NetBSD libi386/biosdisk.c
36  * - FreeBSD biosboot/disk.c
37  *
38  */
39
40 #include <stand.h>
41
42 #include <sys/disklabel.h>
43 #include <sys/diskmbr.h>
44 #include <sys/gpt.h>
45 #include <machine/bootinfo.h>
46
47 #include <stdarg.h>
48 #include <uuid.h>
49
50 #include <bootstrap.h>
51 #include <btxv86.h>
52 #include "libi386.h"
53
54 #define BIOS_NUMDRIVES          0x475
55 #define BIOSDISK_SECSIZE        512
56 #define BUFSIZE                 (1 * BIOSDISK_SECSIZE)
57 #define MAXBDDEV                MAXDEV
58
59 #define DT_ATAPI                0x10            /* disk type for ATAPI floppies */
60 #define WDMAJOR                 0               /* major numbers for devices we frontend for */
61 #define WFDMAJOR                1
62 #define FDMAJOR                 2
63 #define DAMAJOR                 4
64
65 #ifdef DISK_DEBUG
66 # define DEBUG(fmt, args...)    printf("%s: " fmt "\n" , __func__ , ## args)
67 #else
68 # define DEBUG(fmt, args...)
69 #endif
70
71 #ifdef LOADER_GPT_SUPPORT
72 struct gpt_part {
73     int         gp_index;
74     uuid_t      gp_type;
75     uint64_t    gp_start;
76     uint64_t    gp_end;
77 };
78 #endif
79
80 struct open_disk {
81     int                 od_dkunit;              /* disk unit number */
82     int                 od_unit;                /* BIOS unit number */
83     int                 od_cyl;                 /* BIOS geometry */
84     int                 od_hds;
85     int                 od_sec;
86     daddr_t                     od_boff;                /* block offset from beginning of BIOS disk */
87     int                 od_flags;
88 #define BD_MODEINT13            0x0000
89 #define BD_MODEEDD1             0x0001
90 #define BD_MODEEDD3             0x0002
91 #define BD_MODEMASK             0x0003
92 #define BD_FLOPPY               0x0004
93 #define BD_LABELOK              0x0008
94 #define BD_PARTTABOK            0x0010
95 #ifdef LOADER_GPT_SUPPORT
96 #define BD_GPTOK                0x0020
97 #endif
98     union {
99         struct {
100             struct disklabel            mbr_disklabel;
101             int                         mbr_nslices;    /* slice count */
102             struct dos_partition        mbr_slicetab[NEXTDOSPART];
103         } _mbr;
104 #ifdef LOADER_GPT_SUPPORT
105         struct {
106             int                         gpt_nparts;             
107             struct gpt_part             *gpt_partitions;
108         } _gpt;
109 #endif
110     } _data;
111 };
112
113 #define od_disklabel            _data._mbr.mbr_disklabel
114 #define od_nslices              _data._mbr.mbr_nslices
115 #define od_slicetab             _data._mbr.mbr_slicetab
116 #ifdef LOADER_GPT_SUPPORT
117 #define od_nparts               _data._gpt.gpt_nparts
118 #define od_partitions           _data._gpt.gpt_partitions
119 #endif
120
121 /*
122  * List of BIOS devices, translation from disk unit number to
123  * BIOS unit number.
124  */
125 static struct bdinfo
126 {
127     int         bd_unit;                /* BIOS unit number */
128     int         bd_flags;
129     int         bd_type;                /* BIOS 'drive type' (floppy only) */
130 } bdinfo [MAXBDDEV];
131 static int nbdinfo = 0;
132
133 static int      bd_getgeom(struct open_disk *od);
134 static int      bd_read(struct open_disk *od, daddr_t dblk, int blks,
135                     caddr_t dest);
136 static int      bd_write(struct open_disk *od, daddr_t dblk, int blks,
137                     caddr_t dest);
138
139 static int      bd_int13probe(struct bdinfo *bd);
140
141 #ifdef LOADER_GPT_SUPPORT
142 static void     bd_printgptpart(struct open_disk *od, struct gpt_part *gp,
143                     char *prefix, int verbose);
144 #endif
145 static void     bd_printslice(struct open_disk *od, struct dos_partition *dp,
146                     char *prefix, int verbose);
147 static void     bd_printbsdslice(struct open_disk *od, daddr_t offset,
148                     char *prefix, int verbose);
149
150 static int      bd_init(void);
151 static int      bd_strategy(void *devdata, int flag, daddr_t dblk,
152                     size_t size, char *buf, size_t *rsize);
153 static int      bd_realstrategy(void *devdata, int flag, daddr_t dblk,
154                     size_t size, char *buf, size_t *rsize);
155 static int      bd_open(struct open_file *f, ...);
156 static int      bd_close(struct open_file *f);
157 static void     bd_print(int verbose);
158
159 struct devsw biosdisk = {
160     "disk", 
161     DEVT_DISK, 
162     bd_init,
163     bd_strategy, 
164     bd_open, 
165     bd_close, 
166     noioctl,
167     bd_print,
168     NULL
169 };
170
171 static int      bd_opendisk(struct open_disk **odp, struct i386_devdesc *dev);
172 static void     bd_closedisk(struct open_disk *od);
173 static int      bd_open_mbr(struct open_disk *od, struct i386_devdesc *dev);
174 static int      bd_bestslice(struct open_disk *od);
175 static void     bd_checkextended(struct open_disk *od, int slicenum);
176 #ifdef LOADER_GPT_SUPPORT
177 static int      bd_open_gpt(struct open_disk *od, struct i386_devdesc *dev);
178 static struct gpt_part *bd_best_gptpart(struct open_disk *od);
179 #endif
180
181 /*
182  * Translate between BIOS device numbers and our private unit numbers.
183  */
184 int
185 bd_bios2unit(int biosdev)
186 {
187     int         i;
188     
189     DEBUG("looking for bios device 0x%x", biosdev);
190     for (i = 0; i < nbdinfo; i++) {
191         DEBUG("bd unit %d is BIOS device 0x%x", i, bdinfo[i].bd_unit);
192         if (bdinfo[i].bd_unit == biosdev)
193             return(i);
194     }
195     return(-1);
196 }
197
198 int
199 bd_unit2bios(int unit)
200 {
201     if ((unit >= 0) && (unit < nbdinfo))
202         return(bdinfo[unit].bd_unit);
203     return(-1);
204 }
205
206 /*    
207  * Quiz the BIOS for disk devices, save a little info about them.
208  */
209 static int
210 bd_init(void) 
211 {
212     int         base, unit, nfd = 0;
213
214     /* sequence 0, 0x80 */
215     for (base = 0; base <= 0x80; base += 0x80) {
216         for (unit = base; (nbdinfo < MAXBDDEV); unit++) {
217             /* check the BIOS equipment list for number of fixed disks */
218             if((base == 0x80) &&
219                (nfd >= *(unsigned char *)PTOV(BIOS_NUMDRIVES)))
220                 break;
221
222             bdinfo[nbdinfo].bd_unit = unit;
223             bdinfo[nbdinfo].bd_flags = (unit < 0x80) ? BD_FLOPPY : 0;
224
225             if (!bd_int13probe(&bdinfo[nbdinfo]))
226                 break;
227
228             /* XXX we need "disk aliases" to make this simpler */
229             printf("BIOS drive %c: is disk%d\n", 
230                    (unit < 0x80) ? ('A' + unit) : ('C' + unit - 0x80), nbdinfo);
231             nbdinfo++;
232             if (base == 0x80)
233                 nfd++;
234         }
235     }
236     return(0);
237 }
238
239 /*
240  * Try to detect a device supported by the legacy int13 BIOS
241  */
242 static int
243 bd_int13probe(struct bdinfo *bd)
244 {
245     v86.ctl = V86_FLAGS;
246     v86.addr = 0x13;
247     v86.eax = 0x800;
248     v86.edx = bd->bd_unit;
249     v86int();
250     
251     if (!(v86.efl & 0x1) &&                             /* carry clear */
252         ((v86.edx & 0xff) > ((unsigned)bd->bd_unit & 0x7f))) {  /* unit # OK */
253         if ((v86.ecx & 0x3f) == 0) {                    /* absurd sector size */
254                 DEBUG("Invalid geometry for unit %d", bd->bd_unit);
255                 return(0);                              /* skip device */
256         }
257         bd->bd_flags |= BD_MODEINT13;
258         bd->bd_type = v86.ebx & 0xff;
259
260         /* Determine if we can use EDD with this device. */
261         v86.eax = 0x4100;
262         v86.edx = bd->bd_unit;
263         v86.ebx = 0x55aa;
264         v86int();
265         if (!(v86.efl & 0x1) &&                         /* carry clear */
266             ((v86.ebx & 0xffff) == 0xaa55) &&           /* signature */
267             (v86.ecx & 0x1)) {                          /* packets mode ok */
268             bd->bd_flags |= BD_MODEEDD1;
269             if((v86.eax & 0xff00) >= 0x3000)
270                 bd->bd_flags |= BD_MODEEDD3;
271         }
272         return(1);
273     }
274     return(0);
275 }
276
277 /*
278  * Print information about disks
279  */
280 static void
281 bd_print(int verbose)
282 {
283     int                         i, j;
284     char                        line[80];
285     struct i386_devdesc         dev;
286     struct open_disk            *od;
287     struct dos_partition        *dptr;
288     
289     for (i = 0; i < nbdinfo; i++) {
290         sprintf(line, "    disk%d:   BIOS drive %c:\n", i, 
291                 (bdinfo[i].bd_unit < 0x80) ? ('A' + bdinfo[i].bd_unit) : ('C' + bdinfo[i].bd_unit - 0x80));
292         pager_output(line);
293
294         /* try to open the whole disk */
295         dev.d_unit = i;
296         dev.d_kind.biosdisk.slice = -1;
297         dev.d_kind.biosdisk.partition = -1;
298         
299         if (!bd_opendisk(&od, &dev)) {
300
301 #ifdef LOADER_GPT_SUPPORT
302             /* Do we have a GPT table? */
303             if (od->od_flags & BD_GPTOK) {
304                 for (j = 0; j < od->od_nparts; j++) {
305                     sprintf(line, "      disk%dp%d", i,
306                         od->od_partitions[j].gp_index);
307                     bd_printgptpart(od, &od->od_partitions[j], line, verbose);
308                 }
309             } else
310 #endif
311             /* Do we have a partition table? */
312             if (od->od_flags & BD_PARTTABOK) {
313                 dptr = &od->od_slicetab[0];
314
315                 /* Check for a "dedicated" disk */
316                 if ((dptr[3].dp_typ == DOSPTYP_386BSD) &&
317                     (dptr[3].dp_start == 0) &&
318                     (dptr[3].dp_size == 50000)) {
319                     sprintf(line, "      disk%d", i);
320                     bd_printbsdslice(od, 0, line, verbose);
321                 } else {
322                     for (j = 0; j < od->od_nslices; j++) {
323                         sprintf(line, "      disk%ds%d", i, j + 1);
324                         bd_printslice(od, &dptr[j], line, verbose);
325                     }
326                 }
327             }
328             bd_closedisk(od);
329         }
330     }
331 }
332
333 /* Given a size in 512 byte sectors, convert it to a human-readable number. */
334 static char *
335 display_size(uint64_t size)
336 {
337     static char buf[80];
338     char unit;
339
340     size /= 2;
341     unit = 'K';
342     if (size >= 10485760000LL) {
343         size /= 1073741824;
344         unit = 'T';
345     } else if (size >= 10240000) {
346         size /= 1048576;
347         unit = 'G';
348     } else if (size >= 10000) {
349         size /= 1024;
350         unit = 'M';
351     }
352     sprintf(buf, "%.6ld%cB", (long)size, unit);
353     return (buf);
354 }
355
356 #ifdef LOADER_GPT_SUPPORT
357 static uuid_t efi = GPT_ENT_TYPE_EFI;
358 static uuid_t freebsd_boot = GPT_ENT_TYPE_FREEBSD_BOOT;
359 static uuid_t freebsd_ufs = GPT_ENT_TYPE_FREEBSD_UFS;
360 static uuid_t freebsd_swap = GPT_ENT_TYPE_FREEBSD_SWAP;
361 static uuid_t freebsd_zfs = GPT_ENT_TYPE_FREEBSD_ZFS;
362 static uuid_t ms_basic_data = GPT_ENT_TYPE_MS_BASIC_DATA;
363
364 static void
365 bd_printgptpart(struct open_disk *od, struct gpt_part *gp, char *prefix,
366     int verbose)
367 {
368     char stats[80];
369     char line[96];
370
371     if (verbose)
372         sprintf(stats, " %s", display_size(gp->gp_end + 1 - gp->gp_start));
373     else
374         stats[0] = '\0';
375
376     if (uuid_equal(&gp->gp_type, &efi, NULL))
377         sprintf(line, "%s: EFI         %s\n", prefix, stats);
378     else if (uuid_equal(&gp->gp_type, &ms_basic_data, NULL))
379         sprintf(line, "%s: FAT/NTFS    %s\n", prefix, stats);
380     else if (uuid_equal(&gp->gp_type, &freebsd_boot, NULL))
381         sprintf(line, "%s: FreeBSD boot%s\n", prefix, stats);
382     else if (uuid_equal(&gp->gp_type, &freebsd_ufs, NULL))
383         sprintf(line, "%s: FreeBSD UFS %s\n", prefix, stats);
384     else if (uuid_equal(&gp->gp_type, &freebsd_zfs, NULL))
385         sprintf(line, "%s: FreeBSD ZFS %s\n", prefix, stats);
386     else if (uuid_equal(&gp->gp_type, &freebsd_swap, NULL))
387         sprintf(line, "%s: FreeBSD swap%s\n", prefix, stats);
388     else
389         sprintf(line, "%s: %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x%s\n",
390             prefix,
391             gp->gp_type.time_low, gp->gp_type.time_mid,
392             gp->gp_type.time_hi_and_version,
393             gp->gp_type.clock_seq_hi_and_reserved, gp->gp_type.clock_seq_low,
394             gp->gp_type.node[0], gp->gp_type.node[1], gp->gp_type.node[2],
395             gp->gp_type.node[3], gp->gp_type.node[4], gp->gp_type.node[5],
396             stats);
397     pager_output(line);
398 }
399 #endif
400
401 /*
402  * Print information about slices on a disk.  For the size calculations we
403  * assume a 512 byte sector.
404  */
405 static void
406 bd_printslice(struct open_disk *od, struct dos_partition *dp, char *prefix,
407         int verbose)
408 {
409         char stats[80];
410         char line[80];
411
412         if (verbose)
413                 sprintf(stats, " %s (%d - %d)", display_size(dp->dp_size),
414                     dp->dp_start, dp->dp_start + dp->dp_size);
415         else
416                 stats[0] = '\0';
417
418         switch (dp->dp_typ) {
419         case DOSPTYP_386BSD:
420                 bd_printbsdslice(od, (daddr_t)dp->dp_start, prefix, verbose);
421                 return;
422         case DOSPTYP_LINSWP:
423                 sprintf(line, "%s: Linux swap%s\n", prefix, stats);
424                 break;
425         case DOSPTYP_LINUX:
426                 /*
427                  * XXX
428                  * read the superblock to confirm this is an ext2fs partition?
429                  */
430                 sprintf(line, "%s: ext2fs%s\n", prefix, stats);
431                 break;
432         case 0x00:                              /* unused partition */
433         case DOSPTYP_EXT:
434                 return;
435         case 0x01:
436                 sprintf(line, "%s: FAT-12%s\n", prefix, stats);
437                 break;
438         case 0x04:
439         case 0x06:
440         case 0x0e:
441                 sprintf(line, "%s: FAT-16%s\n", prefix, stats);
442                 break;
443         case 0x07:
444                 sprintf(line, "%s: NTFS/HPFS%s\n", prefix, stats);
445                 break;
446         case 0x0b:
447         case 0x0c:
448                 sprintf(line, "%s: FAT-32%s\n", prefix, stats);
449                 break;
450         default:
451                 sprintf(line, "%s: Unknown fs: 0x%x %s\n", prefix, dp->dp_typ,
452                     stats);
453         }
454         pager_output(line);
455 }
456
457 /*
458  * Print out each valid partition in the disklabel of a FreeBSD slice.
459  * For size calculations, we assume a 512 byte sector size.
460  */
461 static void
462 bd_printbsdslice(struct open_disk *od, daddr_t offset, char *prefix,
463     int verbose)
464 {
465     char                line[80];
466     char                buf[BIOSDISK_SECSIZE];
467     struct disklabel    *lp;
468     int                 i;
469
470     /* read disklabel */
471     if (bd_read(od, offset + LABELSECTOR, 1, buf))
472         return;
473     lp =(struct disklabel *)(&buf[0]);
474     if (lp->d_magic != DISKMAGIC) {
475         sprintf(line, "%s: FFS  bad disklabel\n", prefix);
476         pager_output(line);
477         return;
478     }
479     
480     /* Print partitions */
481     for (i = 0; i < lp->d_npartitions; i++) {
482         /*
483          * For each partition, make sure we know what type of fs it is.  If
484          * not, then skip it.  However, since floppies often have bogus
485          * fstypes, print the 'a' partition on a floppy even if it is marked
486          * unused.
487          */
488         if ((lp->d_partitions[i].p_fstype == FS_BSDFFS) ||
489             (lp->d_partitions[i].p_fstype == FS_SWAP) ||
490             (lp->d_partitions[i].p_fstype == FS_VINUM) ||
491             ((lp->d_partitions[i].p_fstype == FS_UNUSED) && 
492              (od->od_flags & BD_FLOPPY) && (i == 0))) {
493
494             /* Only print out statistics in verbose mode */
495             if (verbose)
496                 sprintf(line, "  %s%c: %s %s (%d - %d)\n", prefix, 'a' + i,
497                     (lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap " : 
498                     (lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
499                     "FFS  ",
500                     display_size(lp->d_partitions[i].p_size),
501                     lp->d_partitions[i].p_offset,
502                     lp->d_partitions[i].p_offset + lp->d_partitions[i].p_size);
503             else
504                 sprintf(line, "  %s%c: %s\n", prefix, 'a' + i,
505                     (lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap" : 
506                     (lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
507                     "FFS");
508             pager_output(line);
509         }
510     }
511 }
512
513
514 /*
515  * Attempt to open the disk described by (dev) for use by (f).
516  *
517  * Note that the philosophy here is "give them exactly what
518  * they ask for".  This is necessary because being too "smart"
519  * about what the user might want leads to complications.
520  * (eg. given no slice or partition value, with a disk that is
521  *  sliced - are they after the first BSD slice, or the DOS
522  *  slice before it?)
523  */
524 static int 
525 bd_open(struct open_file *f, ...)
526 {
527     va_list                     ap;
528     struct i386_devdesc         *dev;
529     struct open_disk            *od;
530     int                         error;
531
532     va_start(ap, f);
533     dev = va_arg(ap, struct i386_devdesc *);
534     va_end(ap);
535     if ((error = bd_opendisk(&od, dev)))
536         return(error);
537     
538     /*
539      * Save our context
540      */
541     ((struct i386_devdesc *)(f->f_devdata))->d_kind.biosdisk.data = od;
542     DEBUG("open_disk %p, partition at 0x%x", od, od->od_boff);
543     return(0);
544 }
545
546 static int
547 bd_opendisk(struct open_disk **odp, struct i386_devdesc *dev)
548 {
549     struct open_disk            *od;
550     int                         error;
551
552     if (dev->d_unit >= nbdinfo) {
553         DEBUG("attempt to open nonexistent disk");
554         return(ENXIO);
555     }
556     
557     od = (struct open_disk *)malloc(sizeof(struct open_disk));
558     if (!od) {
559         DEBUG("no memory");
560         return (ENOMEM);
561     }
562
563     /* Look up BIOS unit number, intialise open_disk structure */
564     od->od_dkunit = dev->d_unit;
565     od->od_unit = bdinfo[od->od_dkunit].bd_unit;
566     od->od_flags = bdinfo[od->od_dkunit].bd_flags;
567     od->od_boff = 0;
568     error = 0;
569     DEBUG("open '%s', unit 0x%x slice %d partition %d",
570              i386_fmtdev(dev), dev->d_unit, 
571              dev->d_kind.biosdisk.slice, dev->d_kind.biosdisk.partition);
572
573     /* Get geometry for this open (removable device may have changed) */
574     if (bd_getgeom(od)) {
575         DEBUG("can't get geometry");
576         error = ENXIO;
577         goto out;
578     }
579
580     /* Determine disk layout. */
581 #ifdef LOADER_GPT_SUPPORT
582     error = bd_open_gpt(od, dev);
583     if (error)
584 #endif
585         error = bd_open_mbr(od, dev);
586     
587  out:
588     if (error) {
589         free(od);
590     } else {
591         *odp = od;      /* return the open disk */
592     }
593     return(error);
594 }
595
596 static int
597 bd_open_mbr(struct open_disk *od, struct i386_devdesc *dev)
598 {
599     struct dos_partition        *dptr;
600     struct disklabel            *lp;
601     int                         sector, slice, i;
602     int                         error;
603     char                        buf[BUFSIZE];
604
605     /*
606      * Following calculations attempt to determine the correct value
607      * for d->od_boff by looking for the slice and partition specified,
608      * or searching for reasonable defaults.
609      */
610
611     /*
612      * Find the slice in the DOS slice table.
613      */
614     od->od_nslices = 0;
615     if (bd_read(od, 0, 1, buf)) {
616         DEBUG("error reading MBR");
617         return (EIO);
618     }
619
620     /* 
621      * Check the slice table magic.
622      */
623     if (((u_char)buf[0x1fe] != 0x55) || ((u_char)buf[0x1ff] != 0xaa)) {
624         /* If a slice number was explicitly supplied, this is an error */
625         if (dev->d_kind.biosdisk.slice > 0) {
626             DEBUG("no slice table/MBR (no magic)");
627             return (ENOENT);
628         }
629         sector = 0;
630         goto unsliced;          /* may be a floppy */
631     }
632
633     /*
634      * copy the partition table, then pick up any extended partitions.
635      */
636     bcopy(buf + DOSPARTOFF, &od->od_slicetab,
637       sizeof(struct dos_partition) * NDOSPART);
638     od->od_nslices = 4;                 /* extended slices start here */
639     for (i = 0; i < NDOSPART; i++)
640         bd_checkextended(od, i);
641     od->od_flags |= BD_PARTTABOK;
642     dptr = &od->od_slicetab[0];
643
644     /* Is this a request for the whole disk? */
645     if (dev->d_kind.biosdisk.slice == -1) {
646         sector = 0;
647         goto unsliced;
648     }
649
650     /*
651      * if a slice number was supplied but not found, this is an error.
652      */
653     if (dev->d_kind.biosdisk.slice > 0) {
654         slice = dev->d_kind.biosdisk.slice - 1;
655         if (slice >= od->od_nslices) {
656             DEBUG("slice %d not found", slice);
657             return (ENOENT);
658         }
659     }
660
661     /*
662      * Check for the historically bogus MBR found on true dedicated disks
663      */
664     if ((dptr[3].dp_typ == DOSPTYP_386BSD) &&
665       (dptr[3].dp_start == 0) &&
666       (dptr[3].dp_size == 50000)) {
667         sector = 0;
668         goto unsliced;
669     }
670
671     /* Try to auto-detect the best slice; this should always give a slice number */
672     if (dev->d_kind.biosdisk.slice == 0) {
673         slice = bd_bestslice(od);
674         if (slice == -1) {
675             return (ENOENT);
676         }
677         dev->d_kind.biosdisk.slice = slice;
678     }
679
680     dptr = &od->od_slicetab[0];
681     /*
682      * Accept the supplied slice number unequivocally (we may be looking
683      * at a DOS partition).
684      */
685     dptr += (dev->d_kind.biosdisk.slice - 1);   /* we number 1-4, offsets are 0-3 */
686     sector = dptr->dp_start;
687     DEBUG("slice entry %d at %d, %d sectors", dev->d_kind.biosdisk.slice - 1, sector, dptr->dp_size);
688
689     /*
690      * If we are looking at a BSD slice, and the partition is < 0, assume the 'a' partition
691      */
692     if ((dptr->dp_typ == DOSPTYP_386BSD) && (dev->d_kind.biosdisk.partition < 0))
693         dev->d_kind.biosdisk.partition = 0;
694
695  unsliced:
696     /* 
697      * Now we have the slice offset, look for the partition in the disklabel if we have
698      * a partition to start with.
699      *
700      * XXX we might want to check the label checksum.
701      */
702     if (dev->d_kind.biosdisk.partition < 0) {
703         od->od_boff = sector;           /* no partition, must be after the slice */
704         DEBUG("opening raw slice");
705     } else {
706         
707         if (bd_read(od, sector + LABELSECTOR, 1, buf)) {
708             DEBUG("error reading disklabel");
709             return (EIO);
710         }
711         DEBUG("copy %d bytes of label from %p to %p", sizeof(struct disklabel), buf + LABELOFFSET, &od->od_disklabel);
712         bcopy(buf + LABELOFFSET, &od->od_disklabel, sizeof(struct disklabel));
713         lp = &od->od_disklabel;
714         od->od_flags |= BD_LABELOK;
715
716         if (lp->d_magic != DISKMAGIC) {
717             DEBUG("no disklabel");
718             return (ENOENT);
719         }
720         if (dev->d_kind.biosdisk.partition >= lp->d_npartitions) {
721             DEBUG("partition '%c' exceeds partitions in table (a-'%c')",
722                   'a' + dev->d_kind.biosdisk.partition, 'a' + lp->d_npartitions);
723             return (EPART);
724         }
725
726 #ifdef DISK_DEBUG
727         /* Complain if the partition is unused unless this is a floppy. */
728         if ((lp->d_partitions[dev->d_kind.biosdisk.partition].p_fstype == FS_UNUSED) &&
729             !(od->od_flags & BD_FLOPPY))
730             DEBUG("warning, partition marked as unused");
731 #endif
732         
733         od->od_boff = 
734                 lp->d_partitions[dev->d_kind.biosdisk.partition].p_offset -
735                 lp->d_partitions[RAW_PART].p_offset +
736                 sector;
737     }
738     return (0);
739 }
740
741 static void
742 bd_checkextended(struct open_disk *od, int slicenum)
743 {
744         char    buf[BIOSDISK_SECSIZE];
745         struct dos_partition *dp;
746         u_int base;
747         int i, start, end;
748
749         dp = &od->od_slicetab[slicenum];
750         start = od->od_nslices;
751
752         if (dp->dp_size == 0)
753                 goto done;
754         if (dp->dp_typ != DOSPTYP_EXT)
755                 goto done;
756         if (bd_read(od, (daddr_t)dp->dp_start, 1, buf))
757                 goto done;
758         if (((u_char)buf[0x1fe] != 0x55) || ((u_char)buf[0x1ff] != 0xaa)) {
759                 DEBUG("no magic in extended table");
760                 goto done;
761         }
762         base = dp->dp_start;
763         dp = (struct dos_partition *)(&buf[DOSPARTOFF]);
764         for (i = 0; i < NDOSPART; i++, dp++) {
765                 if (dp->dp_size == 0)
766                         continue;
767                 if (od->od_nslices == NEXTDOSPART)
768                         goto done;
769                 dp->dp_start += base;
770                 bcopy(dp, &od->od_slicetab[od->od_nslices], sizeof(*dp));
771                 od->od_nslices++;
772         }
773         end = od->od_nslices;
774
775         /*
776          * now, recursively check the slices we just added
777          */
778         for (i = start; i < end; i++)
779                 bd_checkextended(od, i);
780 done:
781         return;
782 }
783
784 /*
785  * Search for a slice with the following preferences:
786  *
787  * 1: Active FreeBSD slice
788  * 2: Non-active FreeBSD slice
789  * 3: Active Linux slice
790  * 4: non-active Linux slice
791  * 5: Active FAT/FAT32 slice
792  * 6: non-active FAT/FAT32 slice
793  */
794 #define PREF_RAWDISK    0
795 #define PREF_FBSD_ACT   1
796 #define PREF_FBSD       2
797 #define PREF_LINUX_ACT  3
798 #define PREF_LINUX      4
799 #define PREF_DOS_ACT    5
800 #define PREF_DOS        6
801 #define PREF_NONE       7
802
803 /*
804  * slicelimit is in the range 0 .. NDOSPART
805  */
806 static int
807 bd_bestslice(struct open_disk *od)
808 {
809         struct dos_partition *dp;
810         int pref, preflevel;
811         int i, prefslice;
812         
813         prefslice = 0;
814         preflevel = PREF_NONE;
815
816         dp = &od->od_slicetab[0];
817         for (i = 0; i < od->od_nslices; i++, dp++) {
818
819                 switch (dp->dp_typ) {
820                 case DOSPTYP_386BSD:            /* FreeBSD */
821                         pref = dp->dp_flag & 0x80 ? PREF_FBSD_ACT : PREF_FBSD;
822                         break;
823
824                 case DOSPTYP_LINUX:
825                         pref = dp->dp_flag & 0x80 ? PREF_LINUX_ACT : PREF_LINUX;
826                         break;
827     
828                 case 0x01:              /* DOS/Windows */
829                 case 0x04:
830                 case 0x06:
831                 case 0x0b:
832                 case 0x0c:
833                 case 0x0e:
834                         pref = dp->dp_flag & 0x80 ? PREF_DOS_ACT : PREF_DOS;
835                         break;
836
837                 default:
838                         pref = PREF_NONE;
839                 }
840                 if (pref < preflevel) {
841                         preflevel = pref;
842                         prefslice = i + 1;
843                 }
844         }
845         return (prefslice);
846 }
847
848 #ifdef LOADER_GPT_SUPPORT
849 static int
850 bd_open_gpt(struct open_disk *od, struct i386_devdesc *dev)
851 {
852     struct dos_partition *dp;
853     struct gpt_hdr *hdr;
854     struct gpt_ent *ent;
855     struct gpt_part *gp;
856     int entries_per_sec, error, i, part;
857     daddr_t lba, elba;
858     char gpt[BIOSDISK_SECSIZE], tbl[BIOSDISK_SECSIZE];
859
860     /*
861      * Following calculations attempt to determine the correct value
862      * for d->od_boff by looking for the slice and partition specified,
863      * or searching for reasonable defaults.
864      */
865     error = 0;
866
867     /* First, read the MBR and see if we have a PMBR. */
868     if (bd_read(od, 0, 1, tbl)) {
869         DEBUG("error reading MBR");
870         return (EIO);
871     }
872
873     /* Check the slice table magic. */
874     if (((u_char)tbl[0x1fe] != 0x55) || ((u_char)tbl[0x1ff] != 0xaa))
875         return (ENXIO);
876
877     /* Check for GPT slice. */
878     part = 0;
879     dp = (struct dos_partition *)(tbl + DOSPARTOFF);
880     for (i = 0; i < NDOSPART; i++) {
881         if (dp[i].dp_typ == 0xee)
882             part++;
883         else if ((part != 1) && (dp[i].dp_typ != 0x00))
884             return (EINVAL);
885     }
886     if (part != 1)
887         return (EINVAL);
888
889     /* Read primary GPT table header. */
890     if (bd_read(od, 1, 1, gpt)) {
891         DEBUG("error reading GPT header");
892         return (EIO);
893     }
894     hdr = (struct gpt_hdr *)gpt;
895     if (bcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig)) != 0 ||
896         hdr->hdr_lba_self != 1 || hdr->hdr_revision < 0x00010000 ||
897         hdr->hdr_entsz < sizeof(*ent) ||
898         BIOSDISK_SECSIZE % hdr->hdr_entsz != 0) {
899         DEBUG("Invalid GPT header\n");
900         return (EINVAL);
901     }
902
903     /* Now walk the partition table to count the number of valid partitions. */
904     part = 0;
905     entries_per_sec = BIOSDISK_SECSIZE / hdr->hdr_entsz;
906     elba = hdr->hdr_lba_table + hdr->hdr_entries / entries_per_sec;
907     for (lba = hdr->hdr_lba_table; lba < elba; lba++) {
908         if (bd_read(od, lba, 1, tbl)) {
909             DEBUG("error reading GPT table");
910             return (EIO);
911         }
912         for (i = 0; i < entries_per_sec; i++) {
913             ent = (struct gpt_ent *)(tbl + i * hdr->hdr_entsz);
914             if (uuid_is_nil(&ent->ent_type, NULL) || ent->ent_lba_start == 0 ||
915                 ent->ent_lba_end < ent->ent_lba_start)
916                 continue;
917             part++;
918         }
919     }
920
921     /* Save the important information about all the valid partitions. */
922     od->od_nparts = part;
923     if (part != 0) {
924         od->od_partitions = malloc(part * sizeof(struct gpt_part));
925         part = 0;       
926         for (lba = hdr->hdr_lba_table; lba < elba; lba++) {
927             if (bd_read(od, lba, 1, tbl)) {
928                 DEBUG("error reading GPT table");
929                 error = EIO;
930                 goto out;
931             }
932             for (i = 0; i < entries_per_sec; i++) {
933                 ent = (struct gpt_ent *)(tbl + i * hdr->hdr_entsz);
934                 if (uuid_is_nil(&ent->ent_type, NULL) ||
935                     ent->ent_lba_start == 0 ||
936                     ent->ent_lba_end < ent->ent_lba_start)
937                     continue;
938                 od->od_partitions[part].gp_index = (lba - hdr->hdr_lba_table) *
939                     entries_per_sec + i + 1;
940                 od->od_partitions[part].gp_type = ent->ent_type;
941                 od->od_partitions[part].gp_start = ent->ent_lba_start;
942                 od->od_partitions[part].gp_end = ent->ent_lba_end;
943                 part++;
944             }
945         }
946     }
947     od->od_flags |= BD_GPTOK;
948
949     /* Is this a request for the whole disk? */
950     if (dev->d_kind.biosdisk.slice < 0) {
951         od->od_boff = 0;
952         return (0);
953     }
954
955     /*
956      * If a partition number was supplied, then the user is trying to use
957      * an MBR address rather than a GPT address, so fail.
958      */
959     if (dev->d_kind.biosdisk.partition != 0xff) {
960         error = ENOENT;
961         goto out;
962     }
963
964     /* If a slice number was supplied but not found, this is an error. */
965     gp = NULL;
966     if (dev->d_kind.biosdisk.slice > 0) {
967         for (i = 0; i < od->od_nparts; i++) {
968             if (od->od_partitions[i].gp_index == dev->d_kind.biosdisk.slice) {
969                 gp = &od->od_partitions[i];
970                 break;
971             }
972         }
973         if (gp == NULL) {
974             DEBUG("partition %d not found", dev->d_kind.biosdisk.slice);
975             error = ENOENT;
976             goto out;
977         }
978     }
979
980     /* Try to auto-detect the best partition. */
981     if (dev->d_kind.biosdisk.slice == 0) {
982         gp = bd_best_gptpart(od);
983         if (gp == NULL) {
984             error = ENOENT;
985             goto out;
986         }
987         dev->d_kind.biosdisk.slice = gp->gp_index;
988     }
989     od->od_boff = gp->gp_start;
990
991 out:
992     if (error) {
993         if (od->od_nparts > 0)
994             free(od->od_partitions);
995         od->od_flags &= ~BD_GPTOK;
996     }
997     return (error);
998 }
999
1000 static struct gpt_part *
1001 bd_best_gptpart(struct open_disk *od)
1002 {
1003     struct gpt_part *gp, *prefpart;
1004     int i, pref, preflevel;
1005         
1006     prefpart = NULL;
1007     preflevel = PREF_NONE;
1008
1009     gp = od->od_partitions;
1010     for (i = 0; i < od->od_nparts; i++, gp++) {
1011         /* Windows. XXX: Also Linux. */
1012         if (uuid_equal(&gp->gp_type, &ms_basic_data, NULL))
1013             pref = PREF_DOS;
1014         /* FreeBSD */
1015         else if (uuid_equal(&gp->gp_type, &freebsd_ufs, NULL) ||
1016             uuid_equal(&gp->gp_type, &freebsd_zfs, NULL))
1017             pref = PREF_FBSD;
1018         else
1019             pref = PREF_NONE;
1020         if (pref < preflevel) {
1021             preflevel = pref;
1022             prefpart = gp;
1023         }
1024     }
1025     return (prefpart);
1026 }
1027 #endif
1028
1029 static int 
1030 bd_close(struct open_file *f)
1031 {
1032     struct open_disk    *od = (struct open_disk *)(((struct i386_devdesc *)(f->f_devdata))->d_kind.biosdisk.data);
1033
1034     bd_closedisk(od);
1035     return(0);
1036 }
1037
1038 static void
1039 bd_closedisk(struct open_disk *od)
1040 {
1041     DEBUG("open_disk %p", od);
1042 #if 0
1043     /* XXX is this required? (especially if disk already open...) */
1044     if (od->od_flags & BD_FLOPPY)
1045         delay(3000000);
1046 #endif
1047 #ifdef LOADER_GPT_SUPPORT
1048     if (od->od_flags & BD_GPTOK && od->od_nparts > 0)
1049         free(od->od_partitions);
1050 #endif
1051     free(od);
1052 }
1053
1054 static int 
1055 bd_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
1056 {
1057     struct bcache_devdata       bcd;
1058     struct open_disk    *od = (struct open_disk *)(((struct i386_devdesc *)devdata)->d_kind.biosdisk.data);
1059
1060     bcd.dv_strategy = bd_realstrategy;
1061     bcd.dv_devdata = devdata;
1062     return(bcache_strategy(&bcd, od->od_unit, rw, dblk+od->od_boff, size, buf, rsize));
1063 }
1064
1065 static int 
1066 bd_realstrategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
1067 {
1068     struct open_disk    *od = (struct open_disk *)(((struct i386_devdesc *)devdata)->d_kind.biosdisk.data);
1069     int                 blks;
1070 #ifdef BD_SUPPORT_FRAGS
1071     char                fragbuf[BIOSDISK_SECSIZE];
1072     size_t              fragsize;
1073
1074     fragsize = size % BIOSDISK_SECSIZE;
1075 #else
1076     if (size % BIOSDISK_SECSIZE)
1077         panic("bd_strategy: %d bytes I/O not multiple of block size", size);
1078 #endif
1079
1080     DEBUG("open_disk %p", od);
1081     blks = size / BIOSDISK_SECSIZE;
1082     if (rsize)
1083         *rsize = 0;
1084
1085     switch(rw){
1086     case F_READ:
1087         DEBUG("read %d from %lld to %p", blks, dblk, buf);
1088
1089         if (blks && bd_read(od, dblk, blks, buf)) {
1090             DEBUG("read error");
1091             return (EIO);
1092         }
1093 #ifdef BD_SUPPORT_FRAGS
1094         DEBUG("bd_strategy: frag read %d from %d+%d to %p",
1095             fragsize, dblk, blks, buf + (blks * BIOSDISK_SECSIZE));
1096         if (fragsize && bd_read(od, dblk + blks, 1, fragsize)) {
1097             DEBUG("frag read error");
1098             return(EIO);
1099         }
1100         bcopy(fragbuf, buf + (blks * BIOSDISK_SECSIZE), fragsize);
1101 #endif
1102         break;
1103     case F_WRITE :
1104         DEBUG("write %d from %d to %p", blks, dblk, buf);
1105
1106         if (blks && bd_write(od, dblk, blks, buf)) {
1107             DEBUG("write error");
1108             return (EIO);
1109         }
1110 #ifdef BD_SUPPORT_FRAGS
1111         if(fragsize) {
1112             DEBUG("Attempted to write a frag");
1113             return (EIO);
1114         }
1115 #endif
1116         break;
1117     default:
1118         /* DO NOTHING */
1119         return (EROFS);
1120     }
1121
1122     if (rsize)
1123         *rsize = size;
1124     return (0);
1125 }
1126
1127 /* Max number of sectors to bounce-buffer if the request crosses a 64k boundary */
1128 #define FLOPPY_BOUNCEBUF        18
1129
1130 static int
1131 bd_edd_io(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest, int write)
1132 {
1133     static struct edd_packet packet;
1134
1135     packet.len = 0x10;
1136     packet.count = blks;
1137     packet.offset = VTOPOFF(dest);
1138     packet.seg = VTOPSEG(dest);
1139     packet.lba = dblk;
1140     v86.ctl = V86_FLAGS;
1141     v86.addr = 0x13;
1142     if (write)
1143         /* Should we Write with verify ?? 0x4302 ? */
1144         v86.eax = 0x4300;
1145     else
1146         v86.eax = 0x4200;
1147     v86.edx = od->od_unit;
1148     v86.ds = VTOPSEG(&packet);
1149     v86.esi = VTOPOFF(&packet);
1150     v86int();
1151     return (v86.efl & 0x1);
1152 }
1153
1154 static int
1155 bd_chs_io(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest, int write)
1156 {
1157     u_int       x, bpc, cyl, hd, sec;
1158
1159     bpc = (od->od_sec * od->od_hds);    /* blocks per cylinder */
1160     x = dblk;
1161     cyl = x / bpc;                      /* block # / blocks per cylinder */
1162     x %= bpc;                           /* block offset into cylinder */
1163     hd = x / od->od_sec;                /* offset / blocks per track */
1164     sec = x % od->od_sec;               /* offset into track */
1165
1166     /* correct sector number for 1-based BIOS numbering */
1167     sec++;
1168
1169     if (cyl > 1023)
1170         /* CHS doesn't support cylinders > 1023. */
1171         return (1);
1172
1173     v86.ctl = V86_FLAGS;
1174     v86.addr = 0x13;
1175     if (write)
1176         v86.eax = 0x300 | blks;
1177     else
1178         v86.eax = 0x200 | blks;
1179     v86.ecx = ((cyl & 0xff) << 8) | ((cyl & 0x300) >> 2) | sec;
1180     v86.edx = (hd << 8) | od->od_unit;
1181     v86.es = VTOPSEG(dest);
1182     v86.ebx = VTOPOFF(dest);
1183     v86int();
1184     return (v86.efl & 0x1);
1185 }
1186
1187 static int
1188 bd_io(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest, int write)
1189 {
1190     u_int       x, sec, result, resid, retry, maxfer;
1191     caddr_t     p, xp, bbuf, breg;
1192     
1193     /* Just in case some idiot actually tries to read/write -1 blocks... */
1194     if (blks < 0)
1195         return (-1);
1196
1197     resid = blks;
1198     p = dest;
1199
1200     /* Decide whether we have to bounce */
1201     if (VTOP(dest) >> 20 != 0 || ((od->od_unit < 0x80) && 
1202         ((VTOP(dest) >> 16) != (VTOP(dest + blks * BIOSDISK_SECSIZE) >> 16)))) {
1203
1204         /* 
1205          * There is a 64k physical boundary somewhere in the
1206          * destination buffer, or the destination buffer is above
1207          * first 1MB of physical memory so we have to arrange a
1208          * suitable bounce buffer.  Allocate a buffer twice as large
1209          * as we need to.  Use the bottom half unless there is a break
1210          * there, in which case we use the top half.
1211          */
1212         x = min(FLOPPY_BOUNCEBUF, (unsigned)blks);
1213         bbuf = alloca(x * 2 * BIOSDISK_SECSIZE);
1214         if (((u_int32_t)VTOP(bbuf) & 0xffff0000) ==
1215             ((u_int32_t)VTOP(bbuf + x * BIOSDISK_SECSIZE) & 0xffff0000)) {
1216             breg = bbuf;
1217         } else {
1218             breg = bbuf + x * BIOSDISK_SECSIZE;
1219         }
1220         maxfer = x;             /* limit transfers to bounce region size */
1221     } else {
1222         breg = bbuf = NULL;
1223         maxfer = 0;
1224     }
1225     
1226     while (resid > 0) {
1227         /*
1228          * Play it safe and don't cross track boundaries.
1229          * (XXX this is probably unnecessary)
1230          */
1231         sec = dblk % od->od_sec;        /* offset into track */
1232         x = min(od->od_sec - sec, resid);
1233         if (maxfer > 0)
1234             x = min(x, maxfer);         /* fit bounce buffer */
1235
1236         /* where do we transfer to? */
1237         xp = bbuf == NULL ? p : breg;
1238
1239         /*
1240          * Put your Data In, Put your Data out,
1241          * Put your Data In, and shake it all about 
1242          */
1243         if (write && bbuf != NULL)
1244             bcopy(p, breg, x * BIOSDISK_SECSIZE);
1245
1246         /*
1247          * Loop retrying the operation a couple of times.  The BIOS
1248          * may also retry.
1249          */
1250         for (retry = 0; retry < 3; retry++) {
1251             /* if retrying, reset the drive */
1252             if (retry > 0) {
1253                 v86.ctl = V86_FLAGS;
1254                 v86.addr = 0x13;
1255                 v86.eax = 0;
1256                 v86.edx = od->od_unit;
1257                 v86int();
1258             }
1259
1260             if (od->od_flags & BD_MODEEDD1)
1261                 result = bd_edd_io(od, dblk, x, xp, write);
1262             else
1263                 result = bd_chs_io(od, dblk, x, xp, write);
1264             if (result == 0)
1265                 break;
1266         }
1267
1268         if (write)
1269             DEBUG("Write %d sector(s) from %p (0x%x) to %lld %s", x,
1270                 p, VTOP(p), dblk, result ? "failed" : "ok");
1271         else
1272             DEBUG("Read %d sector(s) from %lld to %p (0x%x) %s", x,
1273                 dblk, p, VTOP(p), result ? "failed" : "ok");
1274         if (result) {
1275             return(-1);
1276         }
1277         if (!write && bbuf != NULL)
1278             bcopy(breg, p, x * BIOSDISK_SECSIZE);
1279         p += (x * BIOSDISK_SECSIZE);
1280         dblk += x;
1281         resid -= x;
1282     }
1283
1284 /*    hexdump(dest, (blks * BIOSDISK_SECSIZE)); */
1285     return(0);
1286 }
1287
1288 static int
1289 bd_read(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest)
1290 {
1291
1292     return (bd_io(od, dblk, blks, dest, 0));
1293 }
1294
1295 static int
1296 bd_write(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest)
1297 {
1298
1299     return (bd_io(od, dblk, blks, dest, 1));
1300 }
1301
1302 static int
1303 bd_getgeom(struct open_disk *od)
1304 {
1305
1306     v86.ctl = V86_FLAGS;
1307     v86.addr = 0x13;
1308     v86.eax = 0x800;
1309     v86.edx = od->od_unit;
1310     v86int();
1311
1312     if ((v86.efl & 0x1) ||                              /* carry set */
1313         ((v86.edx & 0xff) <= (unsigned)(od->od_unit & 0x7f)))   /* unit # bad */
1314         return(1);
1315     
1316     /* convert max cyl # -> # of cylinders */
1317     od->od_cyl = ((v86.ecx & 0xc0) << 2) + ((v86.ecx & 0xff00) >> 8) + 1;
1318     /* convert max head # -> # of heads */
1319     od->od_hds = ((v86.edx & 0xff00) >> 8) + 1;
1320     od->od_sec = v86.ecx & 0x3f;
1321
1322     DEBUG("unit 0x%x geometry %d/%d/%d", od->od_unit, od->od_cyl, od->od_hds, od->od_sec);
1323     return(0);
1324 }
1325
1326 /*
1327  * Return the BIOS geometry of a given "fixed drive" in a format
1328  * suitable for the legacy bootinfo structure.  Since the kernel is
1329  * expecting raw int 0x13/0x8 values for N_BIOS_GEOM drives, we
1330  * prefer to get the information directly, rather than rely on being
1331  * able to put it together from information already maintained for
1332  * different purposes and for a probably different number of drives.
1333  *
1334  * For valid drives, the geometry is expected in the format (31..0)
1335  * "000000cc cccccccc hhhhhhhh 00ssssss"; and invalid drives are
1336  * indicated by returning the geometry of a "1.2M" PC-format floppy
1337  * disk.  And, incidentally, what is returned is not the geometry as
1338  * such but the highest valid cylinder, head, and sector numbers.
1339  */
1340 u_int32_t
1341 bd_getbigeom(int bunit)
1342 {
1343
1344     v86.ctl = V86_FLAGS;
1345     v86.addr = 0x13;
1346     v86.eax = 0x800;
1347     v86.edx = 0x80 + bunit;
1348     v86int();
1349     if (v86.efl & 0x1)
1350         return 0x4f010f;
1351     return ((v86.ecx & 0xc0) << 18) | ((v86.ecx & 0xff00) << 8) |
1352            (v86.edx & 0xff00) | (v86.ecx & 0x3f);
1353 }
1354
1355 /*
1356  * Return a suitable dev_t value for (dev).
1357  *
1358  * In the case where it looks like (dev) is a SCSI disk, we allow the number of
1359  * IDE disks to be specified in $num_ide_disks.  There should be a Better Way.
1360  */
1361 int
1362 bd_getdev(struct i386_devdesc *dev)
1363 {
1364     struct open_disk            *od;
1365     int                         biosdev;
1366     int                         major;
1367     int                         rootdev;
1368     char                        *nip, *cp;
1369     int                         unitofs = 0, i, unit;
1370
1371     biosdev = bd_unit2bios(dev->d_unit);
1372     DEBUG("unit %d BIOS device %d", dev->d_unit, biosdev);
1373     if (biosdev == -1)                          /* not a BIOS device */
1374         return(-1);
1375     if (bd_opendisk(&od, dev) != 0)             /* oops, not a viable device */
1376         return(-1);
1377
1378     if (biosdev < 0x80) {
1379         /* floppy (or emulated floppy) or ATAPI device */
1380         if (bdinfo[dev->d_unit].bd_type == DT_ATAPI) {
1381             /* is an ATAPI disk */
1382             major = WFDMAJOR;
1383         } else {
1384             /* is a floppy disk */
1385             major = FDMAJOR;
1386         }
1387     } else {
1388         /* harddisk */
1389         if ((od->od_flags & BD_LABELOK) && (od->od_disklabel.d_type == DTYPE_SCSI)) {
1390             /* label OK, disk labelled as SCSI */
1391             major = DAMAJOR;
1392             /* check for unit number correction hint, now deprecated */
1393             if ((nip = getenv("num_ide_disks")) != NULL) {
1394                 i = strtol(nip, &cp, 0);
1395                 /* check for parse error */
1396                 if ((cp != nip) && (*cp == 0))
1397                     unitofs = i;
1398             }
1399         } else {
1400             /* assume an IDE disk */
1401             major = WDMAJOR;
1402         }
1403     }
1404     /* default root disk unit number */
1405     unit = (biosdev & 0x7f) - unitofs;
1406
1407     /* XXX a better kludge to set the root disk unit number */
1408     if ((nip = getenv("root_disk_unit")) != NULL) {
1409         i = strtol(nip, &cp, 0);
1410         /* check for parse error */
1411         if ((cp != nip) && (*cp == 0))
1412             unit = i;
1413     }
1414
1415     rootdev = MAKEBOOTDEV(major, dev->d_kind.biosdisk.slice + 1, unit,
1416         dev->d_kind.biosdisk.partition);
1417     DEBUG("dev is 0x%x\n", rootdev);
1418     return(rootdev);
1419 }