root/scsi/sd.c

DEFINITIONS

1. sdmatch
2. sdattach
3. sdactivate
4. sddetach
5. sdopen
6. sdclose
7. sdstrategy
8. sdstart
9. sdrestart
10. sddone
11. sdminphys
12. sdread
13. sdwrite
14. sdioctl
15. sd_ioctl_inquiry
16. sdgetdisklabel
17. sd_shutdown
18. sd_reassign_blocks
19. sd_interpret_sense
20. sdsize
21. sddump
22. viscpy
23. sd_get_parms
24. sd_flush
25. sd_kill_buffers

    1 /*      $OpenBSD: sd.c,v 1.136 2007/06/23 19:19:49 krw Exp $    */
    2 /*      $NetBSD: sd.c,v 1.111 1997/04/02 02:29:41 mycroft Exp $ */
    4 /*-
    5  * Copyright (c) 1998 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Charles M. Hannum.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 /*
   41  * Originally written by Julian Elischer (julian@dialix.oz.au)
   42  * for TRW Financial Systems for use under the MACH(2.5) operating system.
   43  *
   44  * TRW Financial Systems, in accordance with their agreement with Carnegie
   45  * Mellon University, makes this software available to CMU to distribute
   46  * or use in any manner that they see fit as long as this message is kept with
   47  * the software. For this reason TFS also grants any other persons or
   48  * organisations permission to use or modify this software.
   49  *
   50  * TFS supplies this software to be publicly redistributed
   51  * on the understanding that TFS is not responsible for the correct
   52  * functioning of this software in any circumstances.
   53  *
   54  * Ported to run under 386BSD by Julian Elischer (julian@dialix.oz.au) Sept 1992
   55  */
   57 #include <sys/types.h>
   58 #include <sys/param.h>
   59 #include <sys/systm.h>
   60 #include <sys/timeout.h>
   61 #include <sys/file.h>
   62 #include <sys/stat.h>
   63 #include <sys/ioctl.h>
   64 #include <sys/mtio.h>
   65 #include <sys/buf.h>
   66 #include <sys/uio.h>
   67 #include <sys/malloc.h>
   68 #include <sys/errno.h>
   69 #include <sys/device.h>
   70 #include <sys/disklabel.h>
   71 #include <sys/disk.h>
   72 #include <sys/proc.h>
   73 #include <sys/conf.h>
   74 #include <sys/scsiio.h>
   76 #include <scsi/scsi_all.h>
   77 #include <scsi/scsi_disk.h>
   78 #include <scsi/scsiconf.h>
   79 #include <scsi/sdvar.h>
   81 #include <ufs/ffs/fs.h>                 /* for BBSIZE and SBSIZE */
   83 #include <sys/vnode.h>
   85 int     sdmatch(struct device *, void *, void *);
   86 void    sdattach(struct device *, struct device *, void *);
   87 int     sdactivate(struct device *, enum devact);
   88 int     sddetach(struct device *, int);
   90 void    sdminphys(struct buf *);
   91 void    sdgetdisklabel(dev_t, struct sd_softc *, struct disklabel *, int);
   92 void    sdstart(void *);
   93 void    sdrestart(void *);
   94 void    sddone(struct scsi_xfer *);
   95 void    sd_shutdown(void *);
   96 int     sd_reassign_blocks(struct sd_softc *, u_long);
   97 int     sd_interpret_sense(struct scsi_xfer *);
   98 int     sd_get_parms(struct sd_softc *, struct disk_parms *, int);
   99 void    sd_flush(struct sd_softc *, int);
  100 void    sd_kill_buffers(struct sd_softc *);
  102 void    viscpy(u_char *, u_char *, int);
  104 int     sd_ioctl_inquiry(struct sd_softc *, struct dk_inquiry *);
  106 struct cfattach sd_ca = {
  107         sizeof(struct sd_softc), sdmatch, sdattach,
sddetach, sdactivate
  109 };
  111 struct cfdriver sd_cd = {
NULL, "sd", DV_DISK
  113 };
  115 struct dkdriver sddkdriver = { sdstrategy };
  117 struct scsi_device sd_switch = {
sd_interpret_sense,     /* check out error handler first */
sdstart,                /* have a queue, served by this */
NULL,                   /* have no async handler */
sddone,                 /* deal with stats at interrupt time */
  122 };
  124 const struct scsi_inquiry_pattern sd_patterns[] = {
  125         {T_DIRECT, T_FIXED,
  126          "",         "",                 ""},
  127         {T_DIRECT, T_REMOV,
  128          "",         "",                 ""},
  129         {T_RDIRECT, T_FIXED,
  130          "",         "",                 ""},
  131         {T_RDIRECT, T_REMOV,
  132          "",         "",                 ""},
  133         {T_OPTICAL, T_FIXED,
  134          "",         "",                 ""},
  135         {T_OPTICAL, T_REMOV,
  136          "",         "",                 ""},
  137 };
  139 #define sdlock(softc)   disk_lock(&(softc)->sc_dk)
  140 #define sdunlock(softc) disk_unlock(&(softc)->sc_dk)
  141 #define sdlookup(unit) (struct sd_softc *)device_lookup(&sd_cd, (unit))
  143 int
sdmatch(struct device *parent, void *match, void *aux)
  145 {
  146         struct scsi_attach_args *sa = aux;
  147         int priority;
  149         (void)scsi_inqmatch(sa->sa_inqbuf,
sd_patterns, sizeof(sd_patterns)/sizeof(sd_patterns[0]),
  151             sizeof(sd_patterns[0]), &priority);
  153         return (priority);
  154 }
  156 /*
  157  * The routine called by the low level scsi routine when it discovers
  158  * a device suitable for this driver.
  159  */
  160 void
sdattach(struct device *parent, struct device *self, void *aux)
  162 {
  163         int error, result;
  164         struct sd_softc *sd = (struct sd_softc *)self;
  165         struct disk_parms *dp = &sd->params;
  166         struct scsi_attach_args *sa = aux;
  167         struct scsi_link *sc_link = sa->sa_sc_link;
SC_DEBUG(sc_link, SDEV_DB2, ("sdattach:\n"));
  171         /*
  172          * Store information needed to contact our base driver
  173          */
sd->sc_link = sc_link;
sc_link->device = &sd_switch;
sc_link->device_softc = sd;
  178         /*
  179          * Initialize and attach the disk structure.
  180          */
sd->sc_dk.dk_driver = &sddkdriver;
sd->sc_dk.dk_name = sd->sc_dev.dv_xname;
disk_attach(&sd->sc_dk);
  185         if ((sc_link->flags & SDEV_ATAPI) && (sc_link->flags & SDEV_REMOVABLE))
sc_link->quirks |= SDEV_NOSYNCCACHE;
  188         if (!(sc_link->inqdata.flags & SID_RelAdr))
sc_link->quirks |= SDEV_ONLYBIG;
  191         /*
  192          * Note if this device is ancient.  This is used in sdminphys().
  193          */
  194         if (!(sc_link->flags & SDEV_ATAPI) &&
SCSISPC(sa->sa_inqbuf->version) == 0)
sd->flags |= SDF_ANCIENT;
  198         /*
  199          * Use the subdriver to request information regarding
  200          * the drive. We cannot use interrupts yet, so the
  201          * request must specify this.
  202          */
printf("\n");
timeout_set(&sd->sc_timeout, sdrestart, sd);
  207         /* Spin up non-UMASS devices ready or not. */
  208         if ((sd->sc_link->flags & SDEV_UMASS) == 0)
scsi_start(sc_link, SSS_START, scsi_autoconf | SCSI_SILENT |
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
  212         /* Check that it is still responding and ok. */
error = scsi_test_unit_ready(sd->sc_link, TEST_READY_RETRIES,
scsi_autoconf | SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT);
  217         if (error)
result = SDGP_RESULT_OFFLINE;
  219         else
result = sd_get_parms(sd, &sd->params,
scsi_autoconf | SCSI_SILENT | SCSI_IGNORE_MEDIA_CHANGE);
printf("%s: ", sd->sc_dev.dv_xname);
  224         switch (result) {
  225         case SDGP_RESULT_OK:
printf("%lldMB, %lu cyl, %lu head, %lu sec, %lu bytes/sec, %lld sec total",
dp->disksize / (1048576 / dp->blksize), dp->cyls,
dp->heads, dp->sectors, dp->blksize, dp->disksize);
  229                 break;
  231         case SDGP_RESULT_OFFLINE:
printf("drive offline");
  233                 break;
  235 #ifdef DIAGNOSTIC
  236         default:
panic("sdattach: unknown result (%#x) from get_parms", result);
  238                 break;
  239 #endif
  240         }
printf("\n");
  243         /*
  244          * Establish a shutdown hook so that we can ensure that
  245          * our data has actually made it onto the platter at
  246          * shutdown time.  Note that this relies on the fact
  247          * that the shutdown hook code puts us at the head of
  248          * the list (thus guaranteeing that our hook runs before
  249          * our ancestors').
  250          */
  251         if ((sd->sc_sdhook =
shutdownhook_establish(sd_shutdown, sd)) == NULL)
printf("%s: WARNING: unable to establish shutdown hook\n",
sd->sc_dev.dv_xname);
  255 }
  257 int
sdactivate(struct device *self, enum devact act)
  259 {
  260         int rv = 0;
  262         switch (act) {
  263         case DVACT_ACTIVATE:
  264                 break;
  266         case DVACT_DEACTIVATE:
  267                 /*
  268                  * Nothing to do; we key off the device's DVF_ACTIVATE.
  269                  */
  270                 break;
  271         }
  273         return (rv);
  274 }
  277 int
sddetach(struct device *self, int flags)
  279 {
  280         struct sd_softc *sd = (struct sd_softc *)self;
  281         int bmaj, cmaj, mn;
sd_kill_buffers(sd);
  285         /* Locate the lowest minor number to be detached. */
mn = DISKMINOR(self->dv_unit, 0);
  288         for (bmaj = 0; bmaj < nblkdev; bmaj++)
  289                 if (bdevsw[bmaj].d_open == sdopen)
vdevgone(bmaj, mn, mn + MAXPARTITIONS - 1, VBLK);
  291         for (cmaj = 0; cmaj < nchrdev; cmaj++)
  292                 if (cdevsw[cmaj].d_open == sdopen)
vdevgone(cmaj, mn, mn + MAXPARTITIONS - 1, VCHR);
  295         /* Get rid of the shutdown hook. */
  296         if (sd->sc_sdhook != NULL)
shutdownhook_disestablish(sd->sc_sdhook);
  299         /* Detach disk. */
disk_detach(&sd->sc_dk);
  302         return (0);
  303 }
  305 /*
  306  * Open the device. Make sure the partition info is as up-to-date as can be.
  307  */
  308 int
sdopen(dev_t dev, int flag, int fmt, struct proc *p)
  310 {
  311         struct scsi_link *sc_link;
  312         struct sd_softc *sd;
  313         int error = 0, part, rawopen, unit;
unit = DISKUNIT(dev);
part = DISKPART(dev);
rawopen = (part == RAW_PART) && (fmt == S_IFCHR);
sd = sdlookup(unit);
  321         if (sd == NULL)
  322                 return (ENXIO);
sc_link = sd->sc_link;
SC_DEBUG(sc_link, SDEV_DB1,
  326             ("sdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
sd_cd.cd_ndevs, part));
  329         if ((error = sdlock(sd)) != 0) {
device_unref(&sd->sc_dev);
  331                 return (error);
  332         }
  334         if (sd->sc_dk.dk_openmask != 0) {
  335                 /*
  336                  * If any partition is open, but the disk has been invalidated,
  337                  * disallow further opens of non-raw partition.
  338                  */
  339                 if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
  340                         if (rawopen)
  341                                 goto out;
error = EIO;
  343                         goto bad;
  344                 }
  345         } else {
  346                 /* Spin up non-UMASS devices ready or not. */
  347                 if ((sd->sc_link->flags & SDEV_UMASS) == 0)
scsi_start(sc_link, SSS_START, (rawopen ? SCSI_SILENT :
  349                             0) | SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE);
  352                 /* Use sd_interpret_sense() for sense errors.
  353                  *
  354                  * But only after spinning the disk up! Just in case a broken
  355                  * device returns "Initialization command required." and causes
  356                  * a loop of scsi_start() calls.
  357                  */
sc_link->flags |= SDEV_OPEN;
  360                 /* Check that it is still responding and ok. */
error = scsi_test_unit_ready(sc_link,
TEST_READY_RETRIES, (rawopen ? SCSI_SILENT : 0) |
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
  365                 if (error) {
  366                         if (rawopen) {
error = 0;
  368                                 goto out;
  369                         } else
  370                                 goto bad;
  371                 }
  373                 /*
  374                  * Try to prevent the unloading of a removable device while
  375                  * it's open. But allow the open to proceed if the device can't
  376                  * be locked in.
  377                  */
  378                 if ((sc_link->flags & SDEV_REMOVABLE) != 0)
scsi_prevent(sc_link, PR_PREVENT,
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE);
  383                 /* Load the physical device parameters. */
sc_link->flags |= SDEV_MEDIA_LOADED;
  385                 if (sd_get_parms(sd, &sd->params, (rawopen ? SCSI_SILENT : 0))
  386                     == SDGP_RESULT_OFFLINE) {
sc_link->flags &= ~SDEV_MEDIA_LOADED;
error = ENXIO;
  389                         goto bad;
  390                 }
SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded\n"));
  393                 /* Load the partition info if not already loaded. */
sdgetdisklabel(dev, sd, sd->sc_dk.dk_label, 0);
SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel loaded\n"));
  396         }
  398         /* Check that the partition exists. */
  399         if (part != RAW_PART &&
  400             (part >= sd->sc_dk.dk_label->d_npartitions ||
sd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
error = ENXIO;
  403                 goto bad;
  404         }
out:    /* Insure only one open at a time. */
  407         switch (fmt) {
  408         case S_IFCHR:
sd->sc_dk.dk_copenmask |= (1 << part);
  410                 break;
  411         case S_IFBLK:
sd->sc_dk.dk_bopenmask |= (1 << part);
  413                 break;
  414         }
sd->sc_dk.dk_openmask = sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
  418         /* It's OK to fall through because dk_openmask is now non-zero. */
bad:
  420         if (sd->sc_dk.dk_openmask == 0) {
  421                 if ((sd->sc_link->flags & SDEV_REMOVABLE) != 0)
scsi_prevent(sc_link, PR_ALLOW,
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE);
sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
  426         }
sdunlock(sd);
device_unref(&sd->sc_dev);
  430         return (error);
  431 }
  433 /*
  434  * Close the device. Only called if we are the last occurrence of an open
  435  * device.  Convenient now but usually a pain.
  436  */
  437 int
sdclose(dev_t dev, int flag, int fmt, struct proc *p)
  439 {
  440         struct sd_softc *sd;
  441         int part = DISKPART(dev);
  442         int error;
sd = sdlookup(DISKUNIT(dev));
  445         if (sd == NULL)
  446                 return ENXIO;
  448         if ((error = sdlock(sd)) != 0) {
device_unref(&sd->sc_dev);
  450                 return (error);
  451         }
  453         switch (fmt) {
  454         case S_IFCHR:
sd->sc_dk.dk_copenmask &= ~(1 << part);
  456                 break;
  457         case S_IFBLK:
sd->sc_dk.dk_bopenmask &= ~(1 << part);
  459                 break;
  460         }
sd->sc_dk.dk_openmask = sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
  463         if (sd->sc_dk.dk_openmask == 0) {
  464                 if ((sd->flags & SDF_DIRTY) != 0)
sd_flush(sd, 0);
  467                 if ((sd->sc_link->flags & SDEV_REMOVABLE) != 0)
scsi_prevent(sd->sc_link, PR_ALLOW,
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_NOT_READY);
sd->sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
  473                 if (sd->sc_link->flags & SDEV_EJECTING) {
scsi_start(sd->sc_link, SSS_STOP|SSS_LOEJ, 0);
sd->sc_link->flags &= ~SDEV_EJECTING;
  476                 }
timeout_del(&sd->sc_timeout);
  479         }
sdunlock(sd);
device_unref(&sd->sc_dev);
  483         return 0;
  484 }
  486 /*
  487  * Actually translate the requested transfer into one the physical driver
  488  * can understand.  The transfer is described by a buf and will include
  489  * only one physical transfer.
  490  */
  491 void
sdstrategy(struct buf *bp)
  493 {
  494         struct sd_softc *sd;
  495         int s;
sd = sdlookup(DISKUNIT(bp->b_dev));
  498         if (sd == NULL) {
bp->b_error = ENXIO;
  500                 goto bad;
  501         }
SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdstrategy: %ld bytes @ blk %d\n",
bp->b_bcount, bp->b_blkno));
  505         /*
  506          * If the device has been made invalid, error out
  507          */
  508         if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
  509                 if (sd->sc_link->flags & SDEV_OPEN)
bp->b_error = EIO;
  511                 else
bp->b_error = ENODEV;
  513                 goto bad;
  514         }
  515         /*
  516          * If it's a null transfer, return immediately
  517          */
  518         if (bp->b_bcount == 0)
  519                 goto done;
  521         /*
  522          * The transfer must be a whole number of sectors.
  523          */
  524         if ((bp->b_bcount % sd->sc_dk.dk_label->d_secsize) != 0) {
bp->b_error = EINVAL;
  526                 goto bad;
  527         }
  528         /*
  529          * Do bounds checking, adjust transfer. if error, process.
  530          * If end of partition, just return.
  531          */
  532         if (DISKPART(bp->b_dev) != RAW_PART &&
bounds_check_with_label(bp, sd->sc_dk.dk_label,
  534             (sd->flags & (SDF_WLABEL|SDF_LABELLING)) != 0) <= 0)
  535                 goto done;
s = splbio();
  539         /*
  540          * Place it in the queue of disk activities for this disk
  541          */
disksort(&sd->buf_queue, bp);
  544         /*
  545          * Tell the device to get going on the transfer if it's
  546          * not doing anything, otherwise just wait for completion
  547          */
sdstart(sd);
splx(s);
device_unref(&sd->sc_dev);
  553         return;
bad:
bp->b_flags |= B_ERROR;
done:
  558         /*
  559          * Correctly set the buf to indicate a completed xfer
  560          */
bp->b_resid = bp->b_bcount;
s = splbio();
biodone(bp);
splx(s);
  565         if (sd != NULL)
device_unref(&sd->sc_dev);
  567 }
  569 /*
  570  * sdstart looks to see if there is a buf waiting for the device
  571  * and that the device is not already busy. If both are true,
  572  * It dequeues the buf and creates a scsi command to perform the
  573  * transfer in the buf. The transfer request will call scsi_done
  574  * on completion, which will in turn call this routine again
  575  * so that the next queued transfer is performed.
  576  * The bufs are queued by the strategy routine (sdstrategy)
  577  *
  578  * This routine is also called after other non-queued requests
  579  * have been made of the scsi driver, to ensure that the queue
  580  * continues to be drained.
  581  *
  582  * must be called at the correct (highish) spl level
  583  * sdstart() is called at splbio from sdstrategy, sdrestart and scsi_done
  584  */
  585 void
sdstart(void *v)
  587 {
  588         struct sd_softc *sd = (struct sd_softc *)v;
  589         struct scsi_link *sc_link = sd->sc_link;
  590         struct buf *bp = 0;
  591         struct buf *dp;
  592         struct scsi_rw_big cmd_big;
  593         struct scsi_rw_12 cmd_12;
  594         struct scsi_rw_16 cmd_16;
  595         struct scsi_rw cmd_small;
  596         struct scsi_generic *cmdp;
daddr64_t blkno;
  598         int nblks, cmdlen, error;
  599         struct partition *p;
SC_DEBUG(sc_link, SDEV_DB2, ("sdstart\n"));
splassert(IPL_BIO);
  605         /*
  606          * Check if the device has room for another command
  607          */
  608         while (sc_link->openings > 0) {
  609                 /*
  610                  * there is excess capacity, but a special waits
  611                  * It'll need the adapter as soon as we clear out of the
  612                  * way and let it run (user level wait).
  613                  */
  614                 if (sc_link->flags & SDEV_WAITING) {
sc_link->flags &= ~SDEV_WAITING;
wakeup((caddr_t)sc_link);
  617                         return;
  618                 }
  620                 /*
  621                  * See if there is a buf with work for us to do..
  622                  */
dp = &sd->buf_queue;
  624                 if ((bp = dp->b_actf) == NULL)  /* yes, an assign */
  625                         return;
dp->b_actf = bp->b_actf;
  628                 /*
  629                  * If the device has become invalid, abort all the
  630                  * reads and writes until all files have been closed and
  631                  * re-opened
  632                  */
  633                 if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
bp->b_error = EIO;
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
biodone(bp);
  638                         continue;
  639                 }
  641                 /*
  642                  * We have a buf, now we should make a command
  643                  *
  644                  * First, translate the block to absolute and put it in terms
  645                  * of the logical blocksize of the device.
  646                  */
blkno =
bp->b_blkno / (sd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
p = &sd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
blkno += DL_GETPOFFSET(p);
nblks = howmany(bp->b_bcount, sd->sc_dk.dk_label->d_secsize);
  653                 /*
  654                  *  Fill out the scsi command.  If the transfer will
  655                  *  fit in a "small" cdb, use it.
  656                  */
  657                 if (!(sc_link->flags & SDEV_ATAPI) &&
  658                     !(sc_link->quirks & SDEV_ONLYBIG) &&
  659                     ((blkno & 0x1fffff) == blkno) &&
  660                     ((nblks & 0xff) == nblks)) {
  661                         /*
  662                          * We can fit in a 6 byte cdb.
  663                          */
bzero(&cmd_small, sizeof(cmd_small));
cmd_small.opcode = (bp->b_flags & B_READ) ?
READ_COMMAND : WRITE_COMMAND;
_lto3b(blkno, cmd_small.addr);
cmd_small.length = nblks;
cmdlen = sizeof(cmd_small);
cmdp = (struct scsi_generic *)&cmd_small;
  671                 } else if (((blkno & 0xffffffff) == blkno) &&
  672                     ((nblks & 0xffff) == nblks)) {
  673                         /*
  674                          * We can fit in a 10 byte cdb.
  675                          */
bzero(&cmd_big, sizeof(cmd_big));
cmd_big.opcode = (bp->b_flags & B_READ) ?
READ_BIG : WRITE_BIG;
_lto4b(blkno, cmd_big.addr);
_lto2b(nblks, cmd_big.length);
cmdlen = sizeof(cmd_big);
cmdp = (struct scsi_generic *)&cmd_big;
  683                 } else if (((blkno & 0xffffffff) == blkno) &&
  684                     ((nblks & 0xffffffff) == nblks)) {
  685                         /*
  686                          * We can fit in a 12 byte cdb.
  687                          */
bzero(&cmd_12, sizeof(cmd_12));
cmd_12.opcode = (bp->b_flags & B_READ) ?
READ_12 : WRITE_12;
_lto4b(blkno, cmd_12.addr);
_lto4b(nblks, cmd_12.length);
cmdlen = sizeof(cmd_12);
cmdp = (struct scsi_generic *)&cmd_12;
  695                 } else {
  696                         /*
  697                          * Need a 16 byte cdb. There's nothing bigger.
  698                          */
bzero(&cmd_16, sizeof(cmd_16));
cmd_16.opcode = (bp->b_flags & B_READ) ?
READ_16 : WRITE_16;
_lto8b(blkno, cmd_16.addr);
_lto4b(nblks, cmd_16.length);
cmdlen = sizeof(cmd_16);
cmdp = (struct scsi_generic *)&cmd_16;
  706                 }
  708                 /* Instrumentation. */
disk_busy(&sd->sc_dk);
  711                 /*
  712                  * Call the routine that chats with the adapter.
  713                  * Note: we cannot sleep as we may be an interrupt
  714                  */
error = scsi_scsi_cmd(sc_link, cmdp, cmdlen,
  716                     (u_char *)bp->b_data, bp->b_bcount,
SDRETRIES, 60000, bp, SCSI_NOSLEEP |
  718                     ((bp->b_flags & B_READ) ? SCSI_DATA_IN : SCSI_DATA_OUT));
  719                 switch (error) {
  720                 case 0:
  721                         /*
  722                          * Mark the disk dirty so that the cache will be
  723                          * flushed on close.
  724                          */
  725                         if ((bp->b_flags & B_READ) == 0)
sd->flags |= SDF_DIRTY;
timeout_del(&sd->sc_timeout);
  728                         break;
  729                 case EAGAIN:
  730                         /*
  731                          * The device can't start another i/o. Try again later.
  732                          */
dp->b_actf = bp;
disk_unbusy(&sd->sc_dk, 0, 0);
timeout_add(&sd->sc_timeout, 1);
  736                         return;
  737                 default:
disk_unbusy(&sd->sc_dk, 0, 0);
printf("%s: not queued, error %d\n",
sd->sc_dev.dv_xname, error);
  741                         break;
  742                 }
  743         }
  744 }
  746 void
sdrestart(void *v)
  748 {
  749         int s;
s = splbio();
sdstart(v);
splx(s);
  754 }
  756 void
sddone(struct scsi_xfer *xs)
  758 {
  759         struct sd_softc *sd = xs->sc_link->device_softc;
  761         if (sd->flags & SDF_FLUSHING) {
  762                 /* Flush completed, no longer dirty. */
sd->flags &= ~(SDF_FLUSHING|SDF_DIRTY);
  764         }
  766         if (xs->bp != NULL)
disk_unbusy(&sd->sc_dk, (xs->bp->b_bcount - xs->bp->b_resid),
  768                     (xs->bp->b_flags & B_READ));
  769 }
  771 void
sdminphys(struct buf *bp)
  773 {
  774         struct sd_softc *sd;
  775         long max;
sd = sdlookup(DISKUNIT(bp->b_dev));
  778         if (sd == NULL)
  779                 return;  /* XXX - right way to fail this? */
  781         /*
  782          * If the device is ancient, we want to make sure that
  783          * the transfer fits into a 6-byte cdb.
  784          *
  785          * XXX Note that the SCSI-I spec says that 256-block transfers
  786          * are allowed in a 6-byte read/write, and are specified
  787          * by setting the "length" to 0.  However, we're conservative
  788          * here, allowing only 255-block transfers in case an
  789          * ancient device gets confused by length == 0.  A length of 0
  790          * in a 10-byte read/write actually means 0 blocks.
  791          */
  792         if (sd->flags & SDF_ANCIENT) {
max = sd->sc_dk.dk_label->d_secsize * 0xff;
  795                 if (bp->b_bcount > max)
bp->b_bcount = max;
  797         }
  799         (*sd->sc_link->adapter->scsi_minphys)(bp);
device_unref(&sd->sc_dev);
  802 }
  804 int
  805 sdread(dev_t dev, struct uio *uio, int ioflag)
  806 {
  807         return (physio(sdstrategy, NULL, dev, B_READ, sdminphys, uio));
  808 }
  810 int
  811 sdwrite(dev_t dev, struct uio *uio, int ioflag)
  812 {
  813         return (physio(sdstrategy, NULL, dev, B_WRITE, sdminphys, uio));
  814 }
  816 /*
  817  * Perform special action on behalf of the user
  818  * Knows about the internals of this device
  819  */
  820 int
  821 sdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
  822 {
  823         struct sd_softc *sd;
  824         struct disklabel *lp;
  825         int error = 0;
  826         int part = DISKPART(dev);
sd = sdlookup(DISKUNIT(dev));
  829         if (sd == NULL)
  830                 return ENXIO;
SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdioctl 0x%lx\n", cmd));
  834         /*
  835          * If the device is not valid.. abandon ship
  836          */
  837         if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
  838                 switch (cmd) {
  839                 case DIOCWLABEL:
  840                 case DIOCLOCK:
  841                 case DIOCEJECT:
  842                 case SCIOCIDENTIFY:
  843                 case SCIOCCOMMAND:
  844                 case SCIOCDEBUG:
  845                         if (part == RAW_PART)
  846                                 break;
  847                 /* FALLTHROUGH */
  848                 default:
  849                         if ((sd->sc_link->flags & SDEV_OPEN) == 0) {
error = ENODEV;
  851                                 goto exit;
  852                         } else {
error = EIO;
  854                                 goto exit;
  855                         }
  856                 }
  857         }
  859         switch (cmd) {
  860         case DIOCRLDINFO:
lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
sdgetdisklabel(dev, sd, lp, 0);
bcopy(lp, sd->sc_dk.dk_label, sizeof(*lp));
free(lp, M_TEMP);
  865                 goto exit;
  866         case DIOCGPDINFO:
sdgetdisklabel(dev, sd, (struct disklabel *)addr, 1);
  868                 goto exit;
  870         case DIOCGDINFO:
  871                 *(struct disklabel *)addr = *(sd->sc_dk.dk_label);
  872                 goto exit;
  874         case DIOCGPART:
  875                 ((struct partinfo *)addr)->disklab = sd->sc_dk.dk_label;
  876                 ((struct partinfo *)addr)->part =
  877                     &sd->sc_dk.dk_label->d_partitions[DISKPART(dev)];
  878                 goto exit;
  880         case DIOCWDINFO:
  881         case DIOCSDINFO:
  882                 if ((flag & FWRITE) == 0) {
error = EBADF;
  884                         goto exit;
  885                 }
  887                 if ((error = sdlock(sd)) != 0)
  888                         goto exit;
sd->flags |= SDF_LABELLING;
error = setdisklabel(sd->sc_dk.dk_label,
  892                     (struct disklabel *)addr, /*sd->sc_dk.dk_openmask : */0);
  893                 if (error == 0) {
  894                         if (cmd == DIOCWDINFO)
error = writedisklabel(DISKLABELDEV(dev),
sdstrategy, sd->sc_dk.dk_label);
  897                 }
sd->flags &= ~SDF_LABELLING;
sdunlock(sd);
  901                 goto exit;
  903         case DIOCWLABEL:
  904                 if ((flag & FWRITE) == 0) {
error = EBADF;
  906                         goto exit;
  907                 }
  908                 if (*(int *)addr)
sd->flags |= SDF_WLABEL;
  910                 else
sd->flags &= ~SDF_WLABEL;
  912                 goto exit;
  914         case DIOCLOCK:
error = scsi_prevent(sd->sc_link,
  916                     (*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0);
  917                 goto exit;
  919         case MTIOCTOP:
  920                 if (((struct mtop *)addr)->mt_op != MTOFFL) {
error = EIO;
  922                         goto exit;
  923                 }
  924                 /* FALLTHROUGH */
  925         case DIOCEJECT:
  926                 if ((sd->sc_link->flags & SDEV_REMOVABLE) == 0) {
error = ENOTTY;
  928                         goto exit;
  929                 }
sd->sc_link->flags |= SDEV_EJECTING;
  931                 goto exit;
  933         case DIOCINQ:
error = scsi_do_ioctl(sd->sc_link, dev, cmd, addr, flag, p);
  935                 if (error == ENOTTY)
error = sd_ioctl_inquiry(sd,
  937                             (struct dk_inquiry *)addr);
  938                 goto exit;
  940         default:
  941                 if (part != RAW_PART) {
error = ENOTTY;
  943                         goto exit;
  944                 }
error = scsi_do_ioctl(sd->sc_link, dev, cmd, addr, flag, p);
  946         }
exit:
device_unref(&sd->sc_dev);
  950         return (error);
  951 }
  953 int
sd_ioctl_inquiry(struct sd_softc *sd, struct dk_inquiry *di)
  955 {
  956         struct scsi_inquiry_vpd vpd;
bzero(di, sizeof(struct dk_inquiry));
scsi_strvis(di->vendor, sd->sc_link->inqdata.vendor,
  960             sizeof(sd->sc_link->inqdata.vendor));
scsi_strvis(di->product, sd->sc_link->inqdata.product,
  962             sizeof(sd->sc_link->inqdata.product));
scsi_strvis(di->revision, sd->sc_link->inqdata.revision,
  964             sizeof(sd->sc_link->inqdata.revision));
  966         /* the serial vpd page is optional */
  967         if (scsi_inquire_vpd(sd->sc_link, &vpd, sizeof(vpd),
SI_PG_SERIAL, 0) == 0)
scsi_strvis(di->serial, vpd.serial, sizeof(vpd.serial));
  971         return (0);
  972 }
  974 /*
  975  * Load the label information on the named device
  976  */
  977 void
sdgetdisklabel(dev_t dev, struct sd_softc *sd, struct disklabel *lp,
  979     int spoofonly)
  980 {
size_t len;
  982         char *errstring, packname[sizeof(lp->d_packname) + 1];
  983         char product[17], vendor[9];
bzero(lp, sizeof(struct disklabel));
lp->d_secsize = sd->params.blksize;
lp->d_ntracks = sd->params.heads;
lp->d_nsectors = sd->params.sectors;
lp->d_ncylinders = sd->params.cyls;
lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
  992         if (lp->d_secpercyl == 0) {
lp->d_secpercyl = 100;
  994                 /* as long as it's not 0 - readdisklabel divides by it */
  995         }
lp->d_type = DTYPE_SCSI;
  998         if ((sd->sc_link->inqdata.device & SID_TYPE) == T_OPTICAL)
strncpy(lp->d_typename, "SCSI optical",
 1000                     sizeof(lp->d_typename));
 1001         else
strncpy(lp->d_typename, "SCSI disk",
 1003                     sizeof(lp->d_typename));
 1005         /*
 1006          * Try to fit '<vendor> <product>' into d_packname. If that doesn't fit
 1007          * then leave out '<vendor> ' and use only as much of '<product>' as
 1008          * does fit.
 1009          */
viscpy(vendor, sd->sc_link->inqdata.vendor, 8);
viscpy(product, sd->sc_link->inqdata.product, 16);
len = snprintf(packname, sizeof(packname), "%s %s", vendor, product);
 1013         if (len > sizeof(lp->d_packname)) {
strlcpy(packname, product, sizeof(packname));
len = strlen(packname);
 1016         }
 1017         /*
 1018          * It is safe to use len as the count of characters to copy because
 1019          * packname is sizeof(lp->d_packname)+1, the string in packname is
 1020          * always null terminated and len does not count the terminating null.
 1021          * d_packname is not a null terminated string.
 1022          */
bcopy(packname, lp->d_packname, len);
DL_SETDSIZE(lp, sd->params.disksize);
lp->d_rpm = sd->params.rot_rate;
lp->d_interleave = 1;
lp->d_version = 1;
lp->d_flags = 0;
 1031         /* XXX - these values for BBSIZE and SBSIZE assume ffs */
lp->d_bbsize = BBSIZE;
lp->d_sbsize = SBSIZE;
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(lp);
 1039         /*
 1040          * Call the generic disklabel extraction routine
 1041          */
errstring = readdisklabel(DISKLABELDEV(dev), sdstrategy, lp, spoofonly);
 1043         if (errstring) {
 1044                 /*printf("%s: %s\n", sd->sc_dev.dv_xname, errstring);*/
 1045         }
 1046 }
 1049 void
sd_shutdown(void *arg)
 1051 {
 1052         struct sd_softc *sd = (struct sd_softc *)arg;
 1054         /*
 1055          * If the disk cache needs to be flushed, and the disk supports
 1056          * it, flush it.  We're cold at this point, so we poll for
 1057          * completion.
 1058          */
 1059         if ((sd->flags & SDF_DIRTY) != 0)
sd_flush(sd, SCSI_AUTOCONF);
timeout_del(&sd->sc_timeout);
 1063 }
 1065 /*
 1066  * Tell the device to map out a defective block
 1067  */
 1068 int
sd_reassign_blocks(struct sd_softc *sd, u_long blkno)
 1070 {
 1071         struct scsi_reassign_blocks scsi_cmd;
 1072         struct scsi_reassign_blocks_data rbdata;
bzero(&scsi_cmd, sizeof(scsi_cmd));
bzero(&rbdata, sizeof(rbdata));
scsi_cmd.opcode = REASSIGN_BLOCKS;
_lto2b(sizeof(rbdata.defect_descriptor[0]), rbdata.length);
_lto4b(blkno, rbdata.defect_descriptor[0].dlbaddr);
 1081         return scsi_scsi_cmd(sd->sc_link, (struct scsi_generic *)&scsi_cmd,
 1082             sizeof(scsi_cmd), (u_char *)&rbdata, sizeof(rbdata), SDRETRIES,
 1083             5000, NULL, SCSI_DATA_OUT);
 1084 }
 1086 /*
 1087  * Check Errors
 1088  */
 1089 int
sd_interpret_sense(struct scsi_xfer *xs)
 1091 {
 1092         struct scsi_sense_data *sense = &xs->sense;
 1093         struct scsi_link *sc_link = xs->sc_link;
 1094         struct sd_softc *sd = sc_link->device_softc;
u_int8_t serr = sense->error_code & SSD_ERRCODE;
 1096         int retval;
 1098         /*
 1099          * Let the generic code handle everything except a few categories of
 1100          * LUN not ready errors on open devices.
 1101          */
 1102         if (((sc_link->flags & SDEV_OPEN) == 0) ||
 1103             (serr != SSD_ERRCODE_CURRENT && serr != SSD_ERRCODE_DEFERRED) ||
 1104             ((sense->flags & SSD_KEY) != SKEY_NOT_READY) ||
 1105             (sense->extra_len < 6))
 1106                 return (EJUSTRETURN);
 1108         switch (ASC_ASCQ(sense)) {
 1109         case SENSE_NOT_READY_BECOMING_READY:
SC_DEBUG(sc_link, SDEV_DB1, ("becoming ready.\n"));
retval = scsi_delay(xs, 5);
 1112                 break;
 1114         case SENSE_NOT_READY_INIT_REQUIRED:
SC_DEBUG(sc_link, SDEV_DB1, ("spinning up\n"));
retval = scsi_start(sd->sc_link, SSS_START,
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_URGENT | SCSI_NOSLEEP);
 1118                 if (retval == 0)
retval = ERESTART;
 1120                 else
SC_DEBUG(sc_link, SDEV_DB1, ("spin up failed (%#x)\n",
retval));
 1123                 break;
 1125         default:
retval = EJUSTRETURN;
 1127                 break;
 1128         }
 1130         return (retval);
 1131 }
daddr64_t
 1134 sdsize(dev_t dev)
 1135 {
 1136         struct sd_softc *sd;
 1137         int part, omask;
int64_t size;
sd = sdlookup(DISKUNIT(dev));
 1141         if (sd == NULL)
 1142                 return -1;
part = DISKPART(dev);
omask = sd->sc_dk.dk_openmask & (1 << part);
 1147         if (omask == 0 && sdopen(dev, 0, S_IFBLK, NULL) != 0) {
size = -1;
 1149                 goto exit;
 1150         }
 1151         if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0)
size = -1;
 1153         else if (sd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
size = -1;
 1155         else
size = DL_GETPSIZE(&sd->sc_dk.dk_label->d_partitions[part]) *
 1157                         (sd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
 1158         if (omask == 0 && sdclose(dev, 0, S_IFBLK, NULL) != 0)
size = -1;
exit:
device_unref(&sd->sc_dev);
 1163         return size;
 1164 }
 1166 /* #define SD_DUMP_NOT_TRUSTED if you just want to watch */
 1167 static struct scsi_xfer sx;
 1168 static int sddoingadump;
 1170 /*
 1171  * dump all of physical memory into the partition specified, starting
 1172  * at offset 'dumplo' into the partition.
 1173  */
 1174 int
 1175 sddump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
 1176 {
 1177         struct sd_softc *sd;    /* disk unit to do the I/O */
 1178         struct disklabel *lp;   /* disk's disklabel */
 1179         int     unit, part;
 1180         int     sectorsize;     /* size of a disk sector */
daddr64_t       nsects;         /* number of sectors in partition */
daddr64_t       sectoff;        /* sector offset of partition */
 1183         int     totwrt;         /* total number of sectors left to write */
 1184         int     nwrt;           /* current number of sectors to write */
 1185         struct scsi_rw_big cmd; /* write command */
 1186         struct scsi_xfer *xs;   /* ... convenience */
 1187         int     retval;
 1189         /* Check if recursive dump; if so, punt. */
 1190         if (sddoingadump)
 1191                 return EFAULT;
 1193         /* Mark as active early. */
sddoingadump = 1;
unit = DISKUNIT(dev);   /* Decompose unit & partition. */
part = DISKPART(dev);
 1199         /* Check for acceptable drive number. */
 1200         if (unit >= sd_cd.cd_ndevs || (sd = sd_cd.cd_devs[unit]) == NULL)
 1201                 return ENXIO;
 1203         /*
 1204          * XXX Can't do this check, since the media might have been
 1205          * XXX marked `invalid' by successful unmounting of all
 1206          * XXX filesystems.
 1207          */
 1208 #if 0
 1209         /* Make sure it was initialized. */
 1210         if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) != SDEV_MEDIA_LOADED)
 1211                 return ENXIO;
 1212 #endif
 1214         /* Convert to disk sectors.  Request must be a multiple of size. */
lp = sd->sc_dk.dk_label;
sectorsize = lp->d_secsize;
 1217         if ((size % sectorsize) != 0)
 1218                 return EFAULT;
totwrt = size / sectorsize;
blkno = dbtob(blkno) / sectorsize;      /* blkno in DEV_BSIZE units */
nsects = DL_GETPSIZE(&lp->d_partitions[part]);
sectoff = DL_GETPOFFSET(&lp->d_partitions[part]);
 1225         /* Check transfer bounds against partition size. */
 1226         if ((blkno < 0) || ((blkno + totwrt) > nsects))
 1227                 return EINVAL;
 1229         /* Offset block number to start of partition. */
blkno += sectoff;
xs = &sx;
 1234         while (totwrt > 0) {
nwrt = totwrt;          /* XXX */
 1236 #ifndef SD_DUMP_NOT_TRUSTED
 1237                 /*
 1238                  *  Fill out the scsi command
 1239                  */
bzero(&cmd, sizeof(cmd));
cmd.opcode = WRITE_BIG;
_lto4b(blkno, cmd.addr);
_lto2b(nwrt, cmd.length);
 1244                 /*
 1245                  * Fill out the scsi_xfer structure
 1246                  *    Note: we cannot sleep as we may be an interrupt
 1247                  * don't use scsi_scsi_cmd() as it may want
 1248                  * to wait for an xs.
 1249                  */
bzero(xs, sizeof(sx));
xs->flags |= SCSI_AUTOCONF | SCSI_DATA_OUT;
xs->sc_link = sd->sc_link;
xs->retries = SDRETRIES;
xs->timeout = 10000;    /* 10000 millisecs for a disk ! */
xs->cmd = (struct scsi_generic *)&cmd;
xs->cmdlen = sizeof(cmd);
xs->resid = nwrt * sectorsize;
xs->error = XS_NOERROR;
xs->bp = NULL;
xs->data = va;
xs->datalen = nwrt * sectorsize;
 1263                 /*
 1264                  * Pass all this info to the scsi driver.
 1265                  */
retval = (*(sd->sc_link->adapter->scsi_cmd)) (xs);
 1267                 if (retval != COMPLETE)
 1268                         return ENXIO;
 1269 #else   /* SD_DUMP_NOT_TRUSTED */
 1270                 /* Let's just talk about this first... */
printf("sd%d: dump addr 0x%x, blk %d\n", unit, va, blkno);
delay(500 * 1000);      /* half a second */
 1273 #endif  /* SD_DUMP_NOT_TRUSTED */
 1275                 /* update block count */
totwrt -= nwrt;
blkno += nwrt;
va += sectorsize * nwrt;
 1279         }
sddoingadump = 0;
 1281         return 0;
 1282 }
 1284 /*
 1285  * Copy up to len chars from src to dst, ignoring non-printables.
 1286  * Must be room for len+1 chars in dst so we can write the NUL.
 1287  * Does not assume src is NUL-terminated.
 1288  */
 1289 void
viscpy(u_char *dst, u_char *src, int len)
 1291 {
 1292         while (len > 0 && *src != '\0') {
 1293                 if (*src < 0x20 || *src >= 0x80) {
src++;
 1295                         continue;
 1296                 }
 1297                 *dst++ = *src++;
len--;
 1299         }
 1300         *dst = '\0';
 1301 }
 1303 /*
 1304  * Fill out the disk parameter structure. Return SDGP_RESULT_OK if the
 1305  * structure is correctly filled in, SDGP_RESULT_OFFLINE otherwise. The caller
 1306  * is responsible for clearing the SDEV_MEDIA_LOADED flag if the structure
 1307  * cannot be completed.
 1308  */
 1309 int
sd_get_parms(struct sd_softc *sd, struct disk_parms *dp, int flags)
 1311 {
 1312         union scsi_mode_sense_buf *buf = NULL;
 1313         struct page_rigid_geometry *rigid;
 1314         struct page_flex_geometry *flex;
 1315         struct page_reduced_geometry *reduced;
u_int32_t heads = 0, sectors = 0, cyls = 0, blksize, ssblksize;
u_int16_t rpm = 0;
dp->disksize = scsi_size(sd->sc_link, flags, &ssblksize);
 1321         /*
 1322          * Many UMASS devices choke when asked about their geometry. Most
 1323          * don't have a meaningful geometry anyway, so just fake it if
 1324          * scsi_size() worked.
 1325          */
 1326         if ((sd->sc_link->flags & SDEV_UMASS) && (dp->disksize > 0))
 1327                 goto validate;   /* N.B. buf will be NULL at validate. */
buf = malloc(sizeof(*buf), M_TEMP, M_NOWAIT);
 1330         if (buf == NULL)
 1331                 goto validate;
 1333         switch (sd->sc_link->inqdata.device & SID_TYPE) {
 1334         case T_OPTICAL:
 1335                 /* No more information needed or available. */
 1336                 break;
 1338         case T_RDIRECT:
 1339                 /* T_RDIRECT supports only PAGE_REDUCED_GEOMETRY (6). */
scsi_do_mode_sense(sd->sc_link, PAGE_REDUCED_GEOMETRY, buf,
 1341                     (void **)&reduced, NULL, NULL, &blksize, sizeof(*reduced),
flags | SCSI_SILENT, NULL);
 1343                 if (DISK_PGCODE(reduced, PAGE_REDUCED_GEOMETRY)) {
 1344                         if (dp->disksize == 0)
dp->disksize = _5btol(reduced->sectors);
 1346                         if (blksize == 0)
blksize = _2btol(reduced->bytes_s);
 1348                 }
 1349                 break;
 1351         default:
 1352                 /*
 1353                  * NOTE: Some devices leave off the last four bytes of 
 1354                  * PAGE_RIGID_GEOMETRY and PAGE_FLEX_GEOMETRY mode sense pages.
 1355                  * The only information in those four bytes is RPM information
 1356                  * so accept the page. The extra bytes will be zero and RPM will
 1357                  * end up with the default value of 3600.
 1358                  */
rigid = NULL;
 1360                 if (((sd->sc_link->flags & SDEV_ATAPI) == 0) ||
 1361                     ((sd->sc_link->flags & SDEV_REMOVABLE) == 0))
scsi_do_mode_sense(sd->sc_link, PAGE_RIGID_GEOMETRY,
buf, (void **)&rigid, NULL, NULL, &blksize,
 1364                             sizeof(*rigid) - 4, flags | SCSI_SILENT, NULL);
 1365                 if (DISK_PGCODE(rigid, PAGE_RIGID_GEOMETRY)) {
heads = rigid->nheads;
cyls = _3btol(rigid->ncyl);
rpm = _2btol(rigid->rpm);
 1369                         if (heads * cyls > 0)
sectors = dp->disksize / (heads * cyls);
 1371                 } else {
scsi_do_mode_sense(sd->sc_link, PAGE_FLEX_GEOMETRY,
buf, (void **)&flex, NULL, NULL, &blksize,
 1374                             sizeof(*flex) - 4, flags | SCSI_SILENT, NULL);
 1375                         if (DISK_PGCODE(flex, PAGE_FLEX_GEOMETRY)) {
sectors = flex->ph_sec_tr;
heads = flex->nheads;
cyls = _2btol(flex->ncyl);
rpm = _2btol(flex->rpm);
 1380                                 if (blksize == 0)
blksize = _2btol(flex->bytes_s);
 1382                                 if (dp->disksize == 0)
dp->disksize = heads * cyls * sectors;
 1384                         }
 1385                 }
 1386                 break;
 1387         }
validate:
 1390         if (buf)
free(buf, M_TEMP);
 1393         if (dp->disksize == 0)
 1394                 return (SDGP_RESULT_OFFLINE);
 1396         if (ssblksize > 0)
dp->blksize = ssblksize;
 1398         else
dp->blksize = (blksize == 0) ? 512 : blksize;
 1401         /*
 1402          * Restrict blksize values to powers of two between 512 and 64k.
 1403          */
 1404         switch (dp->blksize) {
 1405         case 0x200:     /* == 512, == DEV_BSIZE on all architectures. */
 1406         case 0x400:
 1407         case 0x800:
 1408         case 0x1000:
 1409         case 0x2000:
 1410         case 0x4000:
 1411         case 0x8000:
 1412         case 0x10000:
 1413                 break;
 1414         default:
SC_DEBUG(sd->sc_link, SDEV_DB1,
 1416                     ("sd_get_parms: bad blksize: %#x\n", dp->blksize));
 1417                 return (SDGP_RESULT_OFFLINE);
 1418         }
 1420         /*
 1421          * XXX THINK ABOUT THIS!!  Using values such that sectors * heads *
 1422          * cyls is <= disk_size can lead to wasted space. We need a more
 1423          * careful calculation/validation to make everything work out
 1424          * optimally.
 1425          */
 1426         if (dp->disksize > 0xffffffff && (dp->heads * dp->sectors) < 0xffff) {
dp->heads = 511;
dp->sectors = 255;
cyls = 0;
 1430         } else {
 1431                 /*
 1432                  * Use standard geometry values for anything we still don't
 1433                  * know.
 1434                  */
dp->heads = (heads == 0) ? 255 : heads;
dp->sectors = (sectors == 0) ? 63 : sectors;
dp->rot_rate = (rpm == 0) ? 3600 : rpm;
 1438         }
dp->cyls = (cyls == 0) ? dp->disksize / (dp->heads * dp->sectors) :
cyls;
 1443         return (SDGP_RESULT_OK);
 1444 }
 1446 void
sd_flush(struct sd_softc *sd, int flags)
 1448 {
 1449         struct scsi_link *sc_link = sd->sc_link;
 1450         struct scsi_synchronize_cache sync_cmd;
 1452         /*
 1453          * If the device is SCSI-2, issue a SYNCHRONIZE CACHE.
 1454          * We issue with address 0 length 0, which should be
 1455          * interpreted by the device as "all remaining blocks
 1456          * starting at address 0".  We ignore ILLEGAL REQUEST
 1457          * in the event that the command is not supported by
 1458          * the device, and poll for completion so that we know
 1459          * that the cache has actually been flushed.
 1460          *
 1461          * Unless, that is, the device can't handle the SYNCHRONIZE CACHE
 1462          * command, as indicated by our quirks flags.
 1463          *
 1464          * XXX What about older devices?
 1465          */
 1466         if (SCSISPC(sc_link->inqdata.version) >= 2 &&
 1467             (sc_link->quirks & SDEV_NOSYNCCACHE) == 0) {
bzero(&sync_cmd, sizeof(sync_cmd));
sync_cmd.opcode = SYNCHRONIZE_CACHE;
 1471                 if (scsi_scsi_cmd(sc_link,
 1472                     (struct scsi_generic *)&sync_cmd, sizeof(sync_cmd),
NULL, 0, SDRETRIES, 100000, NULL,
flags|SCSI_IGNORE_ILLEGAL_REQUEST))
printf("%s: WARNING: cache synchronization failed\n",
sd->sc_dev.dv_xname);
 1477                 else
sd->flags |= SDF_FLUSHING;
 1479         }
 1480 }
 1482 /*
 1483  * Remove unprocessed buffers from queue.
 1484  */
 1485 void
sd_kill_buffers(struct sd_softc *sd)
 1487 {
 1488         struct buf *dp, *bp;
 1489         int s;
s = splbio();
 1492         for (dp = &sd->buf_queue; (bp = dp->b_actf) != NULL; ) {
dp->b_actf = bp->b_actf;
bp->b_error = ENXIO;
bp->b_flags |= B_ERROR;
biodone(bp);
 1498         }
splx(s);
 1500 }