root/arch/i386/stand/libsa/diskprobe.c

DEFINITIONS

1. floppyprobe
2. hardprobe
3. diskprobe
4. cdprobe
5. dklookup
6. dump_diskinfo
7. bios_dklookup
8. disksum

    1 /*      $OpenBSD: diskprobe.c,v 1.29 2007/06/18 22:11:20 krw Exp $      */
    3 /*
    4  * Copyright (c) 1997 Tobias Weingartner
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  *
   28  */
   30 /* We want the disk type names from disklabel.h */
   31 #undef DKTYPENAMES
   33 #include <sys/param.h>
   34 #include <sys/queue.h>
   35 #include <sys/reboot.h>
   36 #include <sys/disklabel.h>
   37 #include <stand/boot/bootarg.h>
   38 #include <machine/biosvar.h>
   39 #include <lib/libz/zlib.h>
   40 #include "disk.h"
   41 #include "biosdev.h"
   42 #include "libsa.h"
   44 #define MAX_CKSUMLEN MAXBSIZE / DEV_BSIZE       /* Max # of blks to cksum */
   46 /* Local Prototypes */
   47 static int disksum(int);
   49 /* List of disk devices we found/probed */
   50 struct disklist_lh disklist;
   52 /* Pointer to boot device */
   53 struct diskinfo *bootdev_dip;
   55 extern int debug;
   56 extern int bios_bootdev;
   57 extern int bios_cddev;
   59 /* Probe for all BIOS floppies */
   60 static void
floppyprobe(void)
   62 {
   63         struct diskinfo *dip;
   64         int i;
   66         /* Floppies */
   67         for (i = 0; i < 4; i++) {
dip = alloc(sizeof(struct diskinfo));
bzero(dip, sizeof(*dip));
   71                 if (bios_getdiskinfo(i, &dip->bios_info)) {
   72 #ifdef BIOS_DEBUG
   73                         if (debug)
printf(" <!fd%u>", i);
   75 #endif
free(dip, 0);
   77                         break;
   78                 }
printf(" fd%u", i);
   82                 /* Fill out best we can - (fd?) */
dip->bios_info.bsd_dev = MAKEBOOTDEV(2, 0, 0, i, RAW_PART);
   85                 /*
   86                  * Delay reading the disklabel until we're sure we want
   87                  * to boot from the floppy. Doing this avoids a delay
   88                  * (sometimes very long) when trying to read the label
   89                  * and the drive is unplugged.
   90                  */
dip->bios_info.flags |= BDI_BADLABEL;
   93                 /* Add to queue of disks */
TAILQ_INSERT_TAIL(&disklist, dip, list);
   95         }
   96 }
   99 /* Probe for all BIOS hard disks */
  100 static void
hardprobe(void)
  102 {
  103         struct diskinfo *dip;
  104         int i;
u_int bsdunit, type;
u_int scsi = 0, ide = 0;
  107         const char *dc = (const char *)((0x40 << 4) + 0x75);
  109         /* Hard disks */
  110         for (i = 0x80; i < (0x80 + *dc); i++) {
dip = alloc(sizeof(struct diskinfo));
bzero(dip, sizeof(*dip));
  114                 if (bios_getdiskinfo(i, &dip->bios_info)) {
  115 #ifdef BIOS_DEBUG
  116                         if (debug)
printf(" <!hd%u>", i&0x7f);
  118 #endif
free(dip, 0);
  120                         break;
  121                 }
printf(" hd%u%s", i&0x7f, (dip->bios_info.bios_edd > 0?"+":""));
  125                 /* Try to find the label, to figure out device type */
  126                 if ((bios_getdisklabel(&dip->bios_info, &dip->disklabel)) ) {
printf("*");
bsdunit = ide++;
type = 0;       /* XXX let it be IDE */
  130                 } else {
  131                         /* Best guess */
  132                         switch (dip->disklabel.d_type) {
  133                         case DTYPE_SCSI:
type = 4;
bsdunit = scsi++;
dip->bios_info.flags |= BDI_GOODLABEL;
  137                                 break;
  139                         case DTYPE_ESDI:
  140                         case DTYPE_ST506:
type = 0;
bsdunit = ide++;
dip->bios_info.flags |= BDI_GOODLABEL;
  144                                 break;
  146                         default:
dip->bios_info.flags |= BDI_BADLABEL;
type = 0;       /* XXX Suggest IDE */
bsdunit = ide++;
  150                         }
  151                 }
dip->bios_info.checksum = 0; /* just in case */
  154                 /* Fill out best we can */
dip->bios_info.bsd_dev =
MAKEBOOTDEV(type, 0, 0, bsdunit, RAW_PART);
  158                 /* Add to queue of disks */
TAILQ_INSERT_TAIL(&disklist, dip, list);
  160         }
  161 }
  164 /* Probe for all BIOS supported disks */
u_int32_t bios_cksumlen;
  166 void
diskprobe(void)
  168 {
  169         struct diskinfo *dip;
  170         int i;
  172         /* These get passed to kernel */
bios_diskinfo_t *bios_diskinfo;
  175         /* Init stuff */
TAILQ_INIT(&disklist);
  178         /* Do probes */
floppyprobe();
  180 #ifdef BIOS_DEBUG
  181         if (debug)
printf(";");
  183 #endif
hardprobe();
  186         /* Checksumming of hard disks */
  187         for (i = 0; disksum(i++) && i < MAX_CKSUMLEN; )
  188                 ;
bios_cksumlen = i;
  191         /* Get space for passing bios_diskinfo stuff to kernel */
  192         for (i = 0, dip = TAILQ_FIRST(&disklist); dip;
dip = TAILQ_NEXT(dip, list))
i++;
bios_diskinfo = alloc(++i * sizeof(bios_diskinfo_t));
  197         /* Copy out the bios_diskinfo stuff */
  198         for (i = 0, dip = TAILQ_FIRST(&disklist); dip;
dip = TAILQ_NEXT(dip, list))
bios_diskinfo[i++] = dip->bios_info;
bios_diskinfo[i++].bios_number = -1;
  203         /* Register for kernel use */
addbootarg(BOOTARG_CKSUMLEN, sizeof(u_int32_t), &bios_cksumlen);
addbootarg(BOOTARG_DISKINFO, i * sizeof(bios_diskinfo_t),
bios_diskinfo);
  207 }
  210 void
cdprobe(void)
  212 {
  213         struct diskinfo *dip;
  214         int cddev = bios_cddev & 0xff;
  216         /* Another BIOS boot device... */
  218         if (bios_cddev == -1)                   /* Not been set, so don't use */
  219                 return;
dip = alloc(sizeof(struct diskinfo));
bzero(dip, sizeof(*dip));
  224 #if 0
  225         if (bios_getdiskinfo(cddev, &dip->bios_info)) {
printf(" <!cd0>");      /* XXX */
free(dip, 0);
  228                 return;
  229         }
  230 #endif
printf(" cd0");
dip->bios_info.bios_number = cddev;
dip->bios_info.bios_edd = 1;            /* Use the LBA calls */
dip->bios_info.flags |= BDI_GOODLABEL | BDI_EL_TORITO;
dip->bios_info.checksum = 0;             /* just in case */
dip->bios_info.bsd_dev =
MAKEBOOTDEV(0, 0, 0, 0xff, RAW_PART);
  241         /* Create an imaginary disk label */
dip->disklabel.d_secsize = 2048;
dip->disklabel.d_ntracks = 1;
dip->disklabel.d_nsectors = 100;
dip->disklabel.d_ncylinders = 1;
dip->disklabel.d_secpercyl = dip->disklabel.d_ntracks *
dip->disklabel.d_nsectors;
  248         if (dip->disklabel.d_secpercyl == 0) {
dip->disklabel.d_secpercyl = 100;
  250                 /* as long as it's not 0, since readdisklabel divides by it */
  251         }
strncpy(dip->disklabel.d_typename, "ATAPI CD-ROM",
  254             sizeof(dip->disklabel.d_typename));
dip->disklabel.d_type = DTYPE_ATAPI;
strncpy(dip->disklabel.d_packname, "fictitious",
  258             sizeof(dip->disklabel.d_packname));
dip->disklabel.d_secperunit = 100;
dip->disklabel.d_rpm = 300;
dip->disklabel.d_interleave = 1;
dip->disklabel.d_bbsize = 2048;
dip->disklabel.d_sbsize = 2048;
  266         /* 'a' partition covering the "whole" disk */
dip->disklabel.d_partitions[0].p_offset = 0;
dip->disklabel.d_partitions[0].p_size = 100;
dip->disklabel.d_partitions[0].p_fstype = FS_UNUSED;
  271         /* The raw partition is special */
dip->disklabel.d_partitions[RAW_PART].p_offset = 0;
dip->disklabel.d_partitions[RAW_PART].p_size = 100;
dip->disklabel.d_partitions[RAW_PART].p_fstype = FS_UNUSED;
dip->disklabel.d_npartitions = RAW_PART + 1;
dip->disklabel.d_magic = DISKMAGIC;
dip->disklabel.d_magic2 = DISKMAGIC;
dip->disklabel.d_checksum = dkcksum(&dip->disklabel);
  282         /* Add to queue of disks */
TAILQ_INSERT_TAIL(&disklist, dip, list);
  284 }
  287 /* Find info on given BIOS disk */
  288 struct diskinfo *
dklookup(int dev)
  290 {
  291         struct diskinfo *dip;
  293         for (dip = TAILQ_FIRST(&disklist); dip; dip = TAILQ_NEXT(dip, list))
  294                 if (dip->bios_info.bios_number == dev)
  295                         return dip;
  297         return NULL;
  298 }
  300 void
dump_diskinfo(void)
  302 {
  303         struct diskinfo *dip;
printf("Disk\tBIOS#\tType\tCyls\tHeads\tSecs\tFlags\tChecksum\n");
  306         for (dip = TAILQ_FIRST(&disklist); dip; dip = TAILQ_NEXT(dip, list)) {
bios_diskinfo_t *bdi = &dip->bios_info;
  308                 int d = bdi->bios_number;
  309                 int u = d & 0x7f;
  310                 char c;
  312                 if (bdi->flags & BDI_EL_TORITO) {
c = 'c';
u = 0;
  315                 } else {
c = (d & 0x80) ? 'h' : 'f';
  317                 }
printf("%cd%d\t0x%x\t%s\t%d\t%d\t%d\t0x%x\t0x%x\n",
c, u, d,
  321                     (bdi->flags & BDI_BADLABEL)?"*none*":"label",
bdi->bios_cylinders, bdi->bios_heads, bdi->bios_sectors,
bdi->flags, bdi->checksum);
  324         }
  325 }
  327 /* Find BIOS portion on given BIOS disk
  328  * XXX - Use dklookup() instead.
  329  */
bios_diskinfo_t *
bios_dklookup(int dev)
  332 {
  333         struct diskinfo *dip;
dip = dklookup(dev);
  336         if (dip)
  337                 return &dip->bios_info;
  339         return NULL;
  340 }
  342 /*
  343  * Checksum one more block on all harddrives
  344  *
  345  * Use the adler32() function from libz,
  346  * as it is quick, small, and available.
  347  */
  348 int
disksum(int blk)
  350 {
  351         struct diskinfo *dip, *dip2;
  352         int st, reprobe = 0;
  353         char *buf;
buf = alloca(DEV_BSIZE);
  356         for (dip = TAILQ_FIRST(&disklist); dip; dip = TAILQ_NEXT(dip, list)) {
bios_diskinfo_t *bdi = &dip->bios_info;
  359                 /* Skip this disk if it is not a HD or has had an I/O error */
  360                 if (!(bdi->bios_number & 0x80) || bdi->flags & BDI_INVALID)
  361                         continue;
  363                 /* Adler32 checksum */
st = biosd_io(F_READ, bdi, blk, 1, buf);
  365                 if (st) {
bdi->flags |= BDI_INVALID;
  367                         continue;
  368                 }
bdi->checksum = adler32(bdi->checksum, buf, DEV_BSIZE);
  371                 for (dip2 = TAILQ_FIRST(&disklist); dip2 != dip;
dip2 = TAILQ_NEXT(dip2, list)) {
bios_diskinfo_t *bd = &dip2->bios_info;
  374                         if ((bd->bios_number & 0x80) &&
  375                             !(bd->flags & BDI_INVALID) &&
bdi->checksum == bd->checksum)
reprobe = 1;
  378                 }
  379         }
  381         return reprobe;
  382 }