Annotation of sys/scsi/sd.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 3:
! 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: */
! 39:
! 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: */
! 56:
! 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>
! 75:
! 76: #include <scsi/scsi_all.h>
! 77: #include <scsi/scsi_disk.h>
! 78: #include <scsi/scsiconf.h>
! 79: #include <scsi/sdvar.h>
! 80:
! 81: #include <ufs/ffs/fs.h> /* for BBSIZE and SBSIZE */
! 82:
! 83: #include <sys/vnode.h>
! 84:
! 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);
! 89:
! 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 *);
! 101:
! 102: void viscpy(u_char *, u_char *, int);
! 103:
! 104: int sd_ioctl_inquiry(struct sd_softc *, struct dk_inquiry *);
! 105:
! 106: struct cfattach sd_ca = {
! 107: sizeof(struct sd_softc), sdmatch, sdattach,
! 108: sddetach, sdactivate
! 109: };
! 110:
! 111: struct cfdriver sd_cd = {
! 112: NULL, "sd", DV_DISK
! 113: };
! 114:
! 115: struct dkdriver sddkdriver = { sdstrategy };
! 116:
! 117: struct scsi_device sd_switch = {
! 118: sd_interpret_sense, /* check out error handler first */
! 119: sdstart, /* have a queue, served by this */
! 120: NULL, /* have no async handler */
! 121: sddone, /* deal with stats at interrupt time */
! 122: };
! 123:
! 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: };
! 138:
! 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))
! 142:
! 143: int
! 144: sdmatch(struct device *parent, void *match, void *aux)
! 145: {
! 146: struct scsi_attach_args *sa = aux;
! 147: int priority;
! 148:
! 149: (void)scsi_inqmatch(sa->sa_inqbuf,
! 150: sd_patterns, sizeof(sd_patterns)/sizeof(sd_patterns[0]),
! 151: sizeof(sd_patterns[0]), &priority);
! 152:
! 153: return (priority);
! 154: }
! 155:
! 156: /*
! 157: * The routine called by the low level scsi routine when it discovers
! 158: * a device suitable for this driver.
! 159: */
! 160: void
! 161: 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;
! 168:
! 169: SC_DEBUG(sc_link, SDEV_DB2, ("sdattach:\n"));
! 170:
! 171: /*
! 172: * Store information needed to contact our base driver
! 173: */
! 174: sd->sc_link = sc_link;
! 175: sc_link->device = &sd_switch;
! 176: sc_link->device_softc = sd;
! 177:
! 178: /*
! 179: * Initialize and attach the disk structure.
! 180: */
! 181: sd->sc_dk.dk_driver = &sddkdriver;
! 182: sd->sc_dk.dk_name = sd->sc_dev.dv_xname;
! 183: disk_attach(&sd->sc_dk);
! 184:
! 185: if ((sc_link->flags & SDEV_ATAPI) && (sc_link->flags & SDEV_REMOVABLE))
! 186: sc_link->quirks |= SDEV_NOSYNCCACHE;
! 187:
! 188: if (!(sc_link->inqdata.flags & SID_RelAdr))
! 189: sc_link->quirks |= SDEV_ONLYBIG;
! 190:
! 191: /*
! 192: * Note if this device is ancient. This is used in sdminphys().
! 193: */
! 194: if (!(sc_link->flags & SDEV_ATAPI) &&
! 195: SCSISPC(sa->sa_inqbuf->version) == 0)
! 196: sd->flags |= SDF_ANCIENT;
! 197:
! 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: */
! 203: printf("\n");
! 204:
! 205: timeout_set(&sd->sc_timeout, sdrestart, sd);
! 206:
! 207: /* Spin up non-UMASS devices ready or not. */
! 208: if ((sd->sc_link->flags & SDEV_UMASS) == 0)
! 209: scsi_start(sc_link, SSS_START, scsi_autoconf | SCSI_SILENT |
! 210: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
! 211:
! 212: /* Check that it is still responding and ok. */
! 213: error = scsi_test_unit_ready(sd->sc_link, TEST_READY_RETRIES,
! 214: scsi_autoconf | SCSI_IGNORE_ILLEGAL_REQUEST |
! 215: SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT);
! 216:
! 217: if (error)
! 218: result = SDGP_RESULT_OFFLINE;
! 219: else
! 220: result = sd_get_parms(sd, &sd->params,
! 221: scsi_autoconf | SCSI_SILENT | SCSI_IGNORE_MEDIA_CHANGE);
! 222:
! 223: printf("%s: ", sd->sc_dev.dv_xname);
! 224: switch (result) {
! 225: case SDGP_RESULT_OK:
! 226: printf("%lldMB, %lu cyl, %lu head, %lu sec, %lu bytes/sec, %lld sec total",
! 227: dp->disksize / (1048576 / dp->blksize), dp->cyls,
! 228: dp->heads, dp->sectors, dp->blksize, dp->disksize);
! 229: break;
! 230:
! 231: case SDGP_RESULT_OFFLINE:
! 232: printf("drive offline");
! 233: break;
! 234:
! 235: #ifdef DIAGNOSTIC
! 236: default:
! 237: panic("sdattach: unknown result (%#x) from get_parms", result);
! 238: break;
! 239: #endif
! 240: }
! 241: printf("\n");
! 242:
! 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 =
! 252: shutdownhook_establish(sd_shutdown, sd)) == NULL)
! 253: printf("%s: WARNING: unable to establish shutdown hook\n",
! 254: sd->sc_dev.dv_xname);
! 255: }
! 256:
! 257: int
! 258: sdactivate(struct device *self, enum devact act)
! 259: {
! 260: int rv = 0;
! 261:
! 262: switch (act) {
! 263: case DVACT_ACTIVATE:
! 264: break;
! 265:
! 266: case DVACT_DEACTIVATE:
! 267: /*
! 268: * Nothing to do; we key off the device's DVF_ACTIVATE.
! 269: */
! 270: break;
! 271: }
! 272:
! 273: return (rv);
! 274: }
! 275:
! 276:
! 277: int
! 278: sddetach(struct device *self, int flags)
! 279: {
! 280: struct sd_softc *sd = (struct sd_softc *)self;
! 281: int bmaj, cmaj, mn;
! 282:
! 283: sd_kill_buffers(sd);
! 284:
! 285: /* Locate the lowest minor number to be detached. */
! 286: mn = DISKMINOR(self->dv_unit, 0);
! 287:
! 288: for (bmaj = 0; bmaj < nblkdev; bmaj++)
! 289: if (bdevsw[bmaj].d_open == sdopen)
! 290: vdevgone(bmaj, mn, mn + MAXPARTITIONS - 1, VBLK);
! 291: for (cmaj = 0; cmaj < nchrdev; cmaj++)
! 292: if (cdevsw[cmaj].d_open == sdopen)
! 293: vdevgone(cmaj, mn, mn + MAXPARTITIONS - 1, VCHR);
! 294:
! 295: /* Get rid of the shutdown hook. */
! 296: if (sd->sc_sdhook != NULL)
! 297: shutdownhook_disestablish(sd->sc_sdhook);
! 298:
! 299: /* Detach disk. */
! 300: disk_detach(&sd->sc_dk);
! 301:
! 302: return (0);
! 303: }
! 304:
! 305: /*
! 306: * Open the device. Make sure the partition info is as up-to-date as can be.
! 307: */
! 308: int
! 309: 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;
! 314:
! 315: unit = DISKUNIT(dev);
! 316: part = DISKPART(dev);
! 317:
! 318: rawopen = (part == RAW_PART) && (fmt == S_IFCHR);
! 319:
! 320: sd = sdlookup(unit);
! 321: if (sd == NULL)
! 322: return (ENXIO);
! 323:
! 324: sc_link = sd->sc_link;
! 325: SC_DEBUG(sc_link, SDEV_DB1,
! 326: ("sdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
! 327: sd_cd.cd_ndevs, part));
! 328:
! 329: if ((error = sdlock(sd)) != 0) {
! 330: device_unref(&sd->sc_dev);
! 331: return (error);
! 332: }
! 333:
! 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;
! 342: 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)
! 348: scsi_start(sc_link, SSS_START, (rawopen ? SCSI_SILENT :
! 349: 0) | SCSI_IGNORE_ILLEGAL_REQUEST |
! 350: SCSI_IGNORE_MEDIA_CHANGE);
! 351:
! 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: */
! 358: sc_link->flags |= SDEV_OPEN;
! 359:
! 360: /* Check that it is still responding and ok. */
! 361: error = scsi_test_unit_ready(sc_link,
! 362: TEST_READY_RETRIES, (rawopen ? SCSI_SILENT : 0) |
! 363: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
! 364:
! 365: if (error) {
! 366: if (rawopen) {
! 367: error = 0;
! 368: goto out;
! 369: } else
! 370: goto bad;
! 371: }
! 372:
! 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)
! 379: scsi_prevent(sc_link, PR_PREVENT,
! 380: SCSI_IGNORE_ILLEGAL_REQUEST |
! 381: SCSI_IGNORE_MEDIA_CHANGE);
! 382:
! 383: /* Load the physical device parameters. */
! 384: sc_link->flags |= SDEV_MEDIA_LOADED;
! 385: if (sd_get_parms(sd, &sd->params, (rawopen ? SCSI_SILENT : 0))
! 386: == SDGP_RESULT_OFFLINE) {
! 387: sc_link->flags &= ~SDEV_MEDIA_LOADED;
! 388: error = ENXIO;
! 389: goto bad;
! 390: }
! 391: SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded\n"));
! 392:
! 393: /* Load the partition info if not already loaded. */
! 394: sdgetdisklabel(dev, sd, sd->sc_dk.dk_label, 0);
! 395: SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel loaded\n"));
! 396: }
! 397:
! 398: /* Check that the partition exists. */
! 399: if (part != RAW_PART &&
! 400: (part >= sd->sc_dk.dk_label->d_npartitions ||
! 401: sd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
! 402: error = ENXIO;
! 403: goto bad;
! 404: }
! 405:
! 406: out: /* Insure only one open at a time. */
! 407: switch (fmt) {
! 408: case S_IFCHR:
! 409: sd->sc_dk.dk_copenmask |= (1 << part);
! 410: break;
! 411: case S_IFBLK:
! 412: sd->sc_dk.dk_bopenmask |= (1 << part);
! 413: break;
! 414: }
! 415: sd->sc_dk.dk_openmask = sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
! 416: SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
! 417:
! 418: /* It's OK to fall through because dk_openmask is now non-zero. */
! 419: bad:
! 420: if (sd->sc_dk.dk_openmask == 0) {
! 421: if ((sd->sc_link->flags & SDEV_REMOVABLE) != 0)
! 422: scsi_prevent(sc_link, PR_ALLOW,
! 423: SCSI_IGNORE_ILLEGAL_REQUEST |
! 424: SCSI_IGNORE_MEDIA_CHANGE);
! 425: sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
! 426: }
! 427:
! 428: sdunlock(sd);
! 429: device_unref(&sd->sc_dev);
! 430: return (error);
! 431: }
! 432:
! 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
! 438: 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;
! 443:
! 444: sd = sdlookup(DISKUNIT(dev));
! 445: if (sd == NULL)
! 446: return ENXIO;
! 447:
! 448: if ((error = sdlock(sd)) != 0) {
! 449: device_unref(&sd->sc_dev);
! 450: return (error);
! 451: }
! 452:
! 453: switch (fmt) {
! 454: case S_IFCHR:
! 455: sd->sc_dk.dk_copenmask &= ~(1 << part);
! 456: break;
! 457: case S_IFBLK:
! 458: sd->sc_dk.dk_bopenmask &= ~(1 << part);
! 459: break;
! 460: }
! 461: sd->sc_dk.dk_openmask = sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
! 462:
! 463: if (sd->sc_dk.dk_openmask == 0) {
! 464: if ((sd->flags & SDF_DIRTY) != 0)
! 465: sd_flush(sd, 0);
! 466:
! 467: if ((sd->sc_link->flags & SDEV_REMOVABLE) != 0)
! 468: scsi_prevent(sd->sc_link, PR_ALLOW,
! 469: SCSI_IGNORE_ILLEGAL_REQUEST |
! 470: SCSI_IGNORE_NOT_READY);
! 471: sd->sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
! 472:
! 473: if (sd->sc_link->flags & SDEV_EJECTING) {
! 474: scsi_start(sd->sc_link, SSS_STOP|SSS_LOEJ, 0);
! 475: sd->sc_link->flags &= ~SDEV_EJECTING;
! 476: }
! 477:
! 478: timeout_del(&sd->sc_timeout);
! 479: }
! 480:
! 481: sdunlock(sd);
! 482: device_unref(&sd->sc_dev);
! 483: return 0;
! 484: }
! 485:
! 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
! 492: sdstrategy(struct buf *bp)
! 493: {
! 494: struct sd_softc *sd;
! 495: int s;
! 496:
! 497: sd = sdlookup(DISKUNIT(bp->b_dev));
! 498: if (sd == NULL) {
! 499: bp->b_error = ENXIO;
! 500: goto bad;
! 501: }
! 502:
! 503: SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdstrategy: %ld bytes @ blk %d\n",
! 504: 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)
! 510: bp->b_error = EIO;
! 511: else
! 512: 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;
! 520:
! 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) {
! 525: 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 &&
! 533: bounds_check_with_label(bp, sd->sc_dk.dk_label,
! 534: (sd->flags & (SDF_WLABEL|SDF_LABELLING)) != 0) <= 0)
! 535: goto done;
! 536:
! 537: s = splbio();
! 538:
! 539: /*
! 540: * Place it in the queue of disk activities for this disk
! 541: */
! 542: disksort(&sd->buf_queue, bp);
! 543:
! 544: /*
! 545: * Tell the device to get going on the transfer if it's
! 546: * not doing anything, otherwise just wait for completion
! 547: */
! 548: sdstart(sd);
! 549:
! 550: splx(s);
! 551:
! 552: device_unref(&sd->sc_dev);
! 553: return;
! 554:
! 555: bad:
! 556: bp->b_flags |= B_ERROR;
! 557: done:
! 558: /*
! 559: * Correctly set the buf to indicate a completed xfer
! 560: */
! 561: bp->b_resid = bp->b_bcount;
! 562: s = splbio();
! 563: biodone(bp);
! 564: splx(s);
! 565: if (sd != NULL)
! 566: device_unref(&sd->sc_dev);
! 567: }
! 568:
! 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
! 586: 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;
! 597: daddr64_t blkno;
! 598: int nblks, cmdlen, error;
! 599: struct partition *p;
! 600:
! 601: SC_DEBUG(sc_link, SDEV_DB2, ("sdstart\n"));
! 602:
! 603: splassert(IPL_BIO);
! 604:
! 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) {
! 615: sc_link->flags &= ~SDEV_WAITING;
! 616: wakeup((caddr_t)sc_link);
! 617: return;
! 618: }
! 619:
! 620: /*
! 621: * See if there is a buf with work for us to do..
! 622: */
! 623: dp = &sd->buf_queue;
! 624: if ((bp = dp->b_actf) == NULL) /* yes, an assign */
! 625: return;
! 626: dp->b_actf = bp->b_actf;
! 627:
! 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) {
! 634: bp->b_error = EIO;
! 635: bp->b_flags |= B_ERROR;
! 636: bp->b_resid = bp->b_bcount;
! 637: biodone(bp);
! 638: continue;
! 639: }
! 640:
! 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: */
! 647: blkno =
! 648: bp->b_blkno / (sd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
! 649: p = &sd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
! 650: blkno += DL_GETPOFFSET(p);
! 651: nblks = howmany(bp->b_bcount, sd->sc_dk.dk_label->d_secsize);
! 652:
! 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: */
! 664: bzero(&cmd_small, sizeof(cmd_small));
! 665: cmd_small.opcode = (bp->b_flags & B_READ) ?
! 666: READ_COMMAND : WRITE_COMMAND;
! 667: _lto3b(blkno, cmd_small.addr);
! 668: cmd_small.length = nblks;
! 669: cmdlen = sizeof(cmd_small);
! 670: 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: */
! 676: bzero(&cmd_big, sizeof(cmd_big));
! 677: cmd_big.opcode = (bp->b_flags & B_READ) ?
! 678: READ_BIG : WRITE_BIG;
! 679: _lto4b(blkno, cmd_big.addr);
! 680: _lto2b(nblks, cmd_big.length);
! 681: cmdlen = sizeof(cmd_big);
! 682: 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: */
! 688: bzero(&cmd_12, sizeof(cmd_12));
! 689: cmd_12.opcode = (bp->b_flags & B_READ) ?
! 690: READ_12 : WRITE_12;
! 691: _lto4b(blkno, cmd_12.addr);
! 692: _lto4b(nblks, cmd_12.length);
! 693: cmdlen = sizeof(cmd_12);
! 694: cmdp = (struct scsi_generic *)&cmd_12;
! 695: } else {
! 696: /*
! 697: * Need a 16 byte cdb. There's nothing bigger.
! 698: */
! 699: bzero(&cmd_16, sizeof(cmd_16));
! 700: cmd_16.opcode = (bp->b_flags & B_READ) ?
! 701: READ_16 : WRITE_16;
! 702: _lto8b(blkno, cmd_16.addr);
! 703: _lto4b(nblks, cmd_16.length);
! 704: cmdlen = sizeof(cmd_16);
! 705: cmdp = (struct scsi_generic *)&cmd_16;
! 706: }
! 707:
! 708: /* Instrumentation. */
! 709: disk_busy(&sd->sc_dk);
! 710:
! 711: /*
! 712: * Call the routine that chats with the adapter.
! 713: * Note: we cannot sleep as we may be an interrupt
! 714: */
! 715: error = scsi_scsi_cmd(sc_link, cmdp, cmdlen,
! 716: (u_char *)bp->b_data, bp->b_bcount,
! 717: 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)
! 726: sd->flags |= SDF_DIRTY;
! 727: timeout_del(&sd->sc_timeout);
! 728: break;
! 729: case EAGAIN:
! 730: /*
! 731: * The device can't start another i/o. Try again later.
! 732: */
! 733: dp->b_actf = bp;
! 734: disk_unbusy(&sd->sc_dk, 0, 0);
! 735: timeout_add(&sd->sc_timeout, 1);
! 736: return;
! 737: default:
! 738: disk_unbusy(&sd->sc_dk, 0, 0);
! 739: printf("%s: not queued, error %d\n",
! 740: sd->sc_dev.dv_xname, error);
! 741: break;
! 742: }
! 743: }
! 744: }
! 745:
! 746: void
! 747: sdrestart(void *v)
! 748: {
! 749: int s;
! 750:
! 751: s = splbio();
! 752: sdstart(v);
! 753: splx(s);
! 754: }
! 755:
! 756: void
! 757: sddone(struct scsi_xfer *xs)
! 758: {
! 759: struct sd_softc *sd = xs->sc_link->device_softc;
! 760:
! 761: if (sd->flags & SDF_FLUSHING) {
! 762: /* Flush completed, no longer dirty. */
! 763: sd->flags &= ~(SDF_FLUSHING|SDF_DIRTY);
! 764: }
! 765:
! 766: if (xs->bp != NULL)
! 767: disk_unbusy(&sd->sc_dk, (xs->bp->b_bcount - xs->bp->b_resid),
! 768: (xs->bp->b_flags & B_READ));
! 769: }
! 770:
! 771: void
! 772: sdminphys(struct buf *bp)
! 773: {
! 774: struct sd_softc *sd;
! 775: long max;
! 776:
! 777: sd = sdlookup(DISKUNIT(bp->b_dev));
! 778: if (sd == NULL)
! 779: return; /* XXX - right way to fail this? */
! 780:
! 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) {
! 793: max = sd->sc_dk.dk_label->d_secsize * 0xff;
! 794:
! 795: if (bp->b_bcount > max)
! 796: bp->b_bcount = max;
! 797: }
! 798:
! 799: (*sd->sc_link->adapter->scsi_minphys)(bp);
! 800:
! 801: device_unref(&sd->sc_dev);
! 802: }
! 803:
! 804: int
! 805: sdread(dev_t dev, struct uio *uio, int ioflag)
! 806: {
! 807: return (physio(sdstrategy, NULL, dev, B_READ, sdminphys, uio));
! 808: }
! 809:
! 810: int
! 811: sdwrite(dev_t dev, struct uio *uio, int ioflag)
! 812: {
! 813: return (physio(sdstrategy, NULL, dev, B_WRITE, sdminphys, uio));
! 814: }
! 815:
! 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);
! 827:
! 828: sd = sdlookup(DISKUNIT(dev));
! 829: if (sd == NULL)
! 830: return ENXIO;
! 831:
! 832: SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdioctl 0x%lx\n", cmd));
! 833:
! 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) {
! 850: error = ENODEV;
! 851: goto exit;
! 852: } else {
! 853: error = EIO;
! 854: goto exit;
! 855: }
! 856: }
! 857: }
! 858:
! 859: switch (cmd) {
! 860: case DIOCRLDINFO:
! 861: lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
! 862: sdgetdisklabel(dev, sd, lp, 0);
! 863: bcopy(lp, sd->sc_dk.dk_label, sizeof(*lp));
! 864: free(lp, M_TEMP);
! 865: goto exit;
! 866: case DIOCGPDINFO:
! 867: sdgetdisklabel(dev, sd, (struct disklabel *)addr, 1);
! 868: goto exit;
! 869:
! 870: case DIOCGDINFO:
! 871: *(struct disklabel *)addr = *(sd->sc_dk.dk_label);
! 872: goto exit;
! 873:
! 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;
! 879:
! 880: case DIOCWDINFO:
! 881: case DIOCSDINFO:
! 882: if ((flag & FWRITE) == 0) {
! 883: error = EBADF;
! 884: goto exit;
! 885: }
! 886:
! 887: if ((error = sdlock(sd)) != 0)
! 888: goto exit;
! 889: sd->flags |= SDF_LABELLING;
! 890:
! 891: 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)
! 895: error = writedisklabel(DISKLABELDEV(dev),
! 896: sdstrategy, sd->sc_dk.dk_label);
! 897: }
! 898:
! 899: sd->flags &= ~SDF_LABELLING;
! 900: sdunlock(sd);
! 901: goto exit;
! 902:
! 903: case DIOCWLABEL:
! 904: if ((flag & FWRITE) == 0) {
! 905: error = EBADF;
! 906: goto exit;
! 907: }
! 908: if (*(int *)addr)
! 909: sd->flags |= SDF_WLABEL;
! 910: else
! 911: sd->flags &= ~SDF_WLABEL;
! 912: goto exit;
! 913:
! 914: case DIOCLOCK:
! 915: error = scsi_prevent(sd->sc_link,
! 916: (*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0);
! 917: goto exit;
! 918:
! 919: case MTIOCTOP:
! 920: if (((struct mtop *)addr)->mt_op != MTOFFL) {
! 921: error = EIO;
! 922: goto exit;
! 923: }
! 924: /* FALLTHROUGH */
! 925: case DIOCEJECT:
! 926: if ((sd->sc_link->flags & SDEV_REMOVABLE) == 0) {
! 927: error = ENOTTY;
! 928: goto exit;
! 929: }
! 930: sd->sc_link->flags |= SDEV_EJECTING;
! 931: goto exit;
! 932:
! 933: case DIOCINQ:
! 934: error = scsi_do_ioctl(sd->sc_link, dev, cmd, addr, flag, p);
! 935: if (error == ENOTTY)
! 936: error = sd_ioctl_inquiry(sd,
! 937: (struct dk_inquiry *)addr);
! 938: goto exit;
! 939:
! 940: default:
! 941: if (part != RAW_PART) {
! 942: error = ENOTTY;
! 943: goto exit;
! 944: }
! 945: error = scsi_do_ioctl(sd->sc_link, dev, cmd, addr, flag, p);
! 946: }
! 947:
! 948: exit:
! 949: device_unref(&sd->sc_dev);
! 950: return (error);
! 951: }
! 952:
! 953: int
! 954: sd_ioctl_inquiry(struct sd_softc *sd, struct dk_inquiry *di)
! 955: {
! 956: struct scsi_inquiry_vpd vpd;
! 957:
! 958: bzero(di, sizeof(struct dk_inquiry));
! 959: scsi_strvis(di->vendor, sd->sc_link->inqdata.vendor,
! 960: sizeof(sd->sc_link->inqdata.vendor));
! 961: scsi_strvis(di->product, sd->sc_link->inqdata.product,
! 962: sizeof(sd->sc_link->inqdata.product));
! 963: scsi_strvis(di->revision, sd->sc_link->inqdata.revision,
! 964: sizeof(sd->sc_link->inqdata.revision));
! 965:
! 966: /* the serial vpd page is optional */
! 967: if (scsi_inquire_vpd(sd->sc_link, &vpd, sizeof(vpd),
! 968: SI_PG_SERIAL, 0) == 0)
! 969: scsi_strvis(di->serial, vpd.serial, sizeof(vpd.serial));
! 970:
! 971: return (0);
! 972: }
! 973:
! 974: /*
! 975: * Load the label information on the named device
! 976: */
! 977: void
! 978: sdgetdisklabel(dev_t dev, struct sd_softc *sd, struct disklabel *lp,
! 979: int spoofonly)
! 980: {
! 981: size_t len;
! 982: char *errstring, packname[sizeof(lp->d_packname) + 1];
! 983: char product[17], vendor[9];
! 984:
! 985: bzero(lp, sizeof(struct disklabel));
! 986:
! 987: lp->d_secsize = sd->params.blksize;
! 988: lp->d_ntracks = sd->params.heads;
! 989: lp->d_nsectors = sd->params.sectors;
! 990: lp->d_ncylinders = sd->params.cyls;
! 991: lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
! 992: if (lp->d_secpercyl == 0) {
! 993: lp->d_secpercyl = 100;
! 994: /* as long as it's not 0 - readdisklabel divides by it */
! 995: }
! 996:
! 997: lp->d_type = DTYPE_SCSI;
! 998: if ((sd->sc_link->inqdata.device & SID_TYPE) == T_OPTICAL)
! 999: strncpy(lp->d_typename, "SCSI optical",
! 1000: sizeof(lp->d_typename));
! 1001: else
! 1002: strncpy(lp->d_typename, "SCSI disk",
! 1003: sizeof(lp->d_typename));
! 1004:
! 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: */
! 1010: viscpy(vendor, sd->sc_link->inqdata.vendor, 8);
! 1011: viscpy(product, sd->sc_link->inqdata.product, 16);
! 1012: len = snprintf(packname, sizeof(packname), "%s %s", vendor, product);
! 1013: if (len > sizeof(lp->d_packname)) {
! 1014: strlcpy(packname, product, sizeof(packname));
! 1015: 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: */
! 1023: bcopy(packname, lp->d_packname, len);
! 1024:
! 1025: DL_SETDSIZE(lp, sd->params.disksize);
! 1026: lp->d_rpm = sd->params.rot_rate;
! 1027: lp->d_interleave = 1;
! 1028: lp->d_version = 1;
! 1029: lp->d_flags = 0;
! 1030:
! 1031: /* XXX - these values for BBSIZE and SBSIZE assume ffs */
! 1032: lp->d_bbsize = BBSIZE;
! 1033: lp->d_sbsize = SBSIZE;
! 1034:
! 1035: lp->d_magic = DISKMAGIC;
! 1036: lp->d_magic2 = DISKMAGIC;
! 1037: lp->d_checksum = dkcksum(lp);
! 1038:
! 1039: /*
! 1040: * Call the generic disklabel extraction routine
! 1041: */
! 1042: errstring = readdisklabel(DISKLABELDEV(dev), sdstrategy, lp, spoofonly);
! 1043: if (errstring) {
! 1044: /*printf("%s: %s\n", sd->sc_dev.dv_xname, errstring);*/
! 1045: }
! 1046: }
! 1047:
! 1048:
! 1049: void
! 1050: sd_shutdown(void *arg)
! 1051: {
! 1052: struct sd_softc *sd = (struct sd_softc *)arg;
! 1053:
! 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)
! 1060: sd_flush(sd, SCSI_AUTOCONF);
! 1061:
! 1062: timeout_del(&sd->sc_timeout);
! 1063: }
! 1064:
! 1065: /*
! 1066: * Tell the device to map out a defective block
! 1067: */
! 1068: int
! 1069: 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;
! 1073:
! 1074: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 1075: bzero(&rbdata, sizeof(rbdata));
! 1076: scsi_cmd.opcode = REASSIGN_BLOCKS;
! 1077:
! 1078: _lto2b(sizeof(rbdata.defect_descriptor[0]), rbdata.length);
! 1079: _lto4b(blkno, rbdata.defect_descriptor[0].dlbaddr);
! 1080:
! 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: }
! 1085:
! 1086: /*
! 1087: * Check Errors
! 1088: */
! 1089: int
! 1090: 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;
! 1095: u_int8_t serr = sense->error_code & SSD_ERRCODE;
! 1096: int retval;
! 1097:
! 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);
! 1107:
! 1108: switch (ASC_ASCQ(sense)) {
! 1109: case SENSE_NOT_READY_BECOMING_READY:
! 1110: SC_DEBUG(sc_link, SDEV_DB1, ("becoming ready.\n"));
! 1111: retval = scsi_delay(xs, 5);
! 1112: break;
! 1113:
! 1114: case SENSE_NOT_READY_INIT_REQUIRED:
! 1115: SC_DEBUG(sc_link, SDEV_DB1, ("spinning up\n"));
! 1116: retval = scsi_start(sd->sc_link, SSS_START,
! 1117: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_URGENT | SCSI_NOSLEEP);
! 1118: if (retval == 0)
! 1119: retval = ERESTART;
! 1120: else
! 1121: SC_DEBUG(sc_link, SDEV_DB1, ("spin up failed (%#x)\n",
! 1122: retval));
! 1123: break;
! 1124:
! 1125: default:
! 1126: retval = EJUSTRETURN;
! 1127: break;
! 1128: }
! 1129:
! 1130: return (retval);
! 1131: }
! 1132:
! 1133: daddr64_t
! 1134: sdsize(dev_t dev)
! 1135: {
! 1136: struct sd_softc *sd;
! 1137: int part, omask;
! 1138: int64_t size;
! 1139:
! 1140: sd = sdlookup(DISKUNIT(dev));
! 1141: if (sd == NULL)
! 1142: return -1;
! 1143:
! 1144: part = DISKPART(dev);
! 1145: omask = sd->sc_dk.dk_openmask & (1 << part);
! 1146:
! 1147: if (omask == 0 && sdopen(dev, 0, S_IFBLK, NULL) != 0) {
! 1148: size = -1;
! 1149: goto exit;
! 1150: }
! 1151: if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0)
! 1152: size = -1;
! 1153: else if (sd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
! 1154: size = -1;
! 1155: else
! 1156: 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)
! 1159: size = -1;
! 1160:
! 1161: exit:
! 1162: device_unref(&sd->sc_dev);
! 1163: return size;
! 1164: }
! 1165:
! 1166: /* #define SD_DUMP_NOT_TRUSTED if you just want to watch */
! 1167: static struct scsi_xfer sx;
! 1168: static int sddoingadump;
! 1169:
! 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 */
! 1181: daddr64_t nsects; /* number of sectors in partition */
! 1182: 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;
! 1188:
! 1189: /* Check if recursive dump; if so, punt. */
! 1190: if (sddoingadump)
! 1191: return EFAULT;
! 1192:
! 1193: /* Mark as active early. */
! 1194: sddoingadump = 1;
! 1195:
! 1196: unit = DISKUNIT(dev); /* Decompose unit & partition. */
! 1197: part = DISKPART(dev);
! 1198:
! 1199: /* Check for acceptable drive number. */
! 1200: if (unit >= sd_cd.cd_ndevs || (sd = sd_cd.cd_devs[unit]) == NULL)
! 1201: return ENXIO;
! 1202:
! 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
! 1213:
! 1214: /* Convert to disk sectors. Request must be a multiple of size. */
! 1215: lp = sd->sc_dk.dk_label;
! 1216: sectorsize = lp->d_secsize;
! 1217: if ((size % sectorsize) != 0)
! 1218: return EFAULT;
! 1219: totwrt = size / sectorsize;
! 1220: blkno = dbtob(blkno) / sectorsize; /* blkno in DEV_BSIZE units */
! 1221:
! 1222: nsects = DL_GETPSIZE(&lp->d_partitions[part]);
! 1223: sectoff = DL_GETPOFFSET(&lp->d_partitions[part]);
! 1224:
! 1225: /* Check transfer bounds against partition size. */
! 1226: if ((blkno < 0) || ((blkno + totwrt) > nsects))
! 1227: return EINVAL;
! 1228:
! 1229: /* Offset block number to start of partition. */
! 1230: blkno += sectoff;
! 1231:
! 1232: xs = &sx;
! 1233:
! 1234: while (totwrt > 0) {
! 1235: nwrt = totwrt; /* XXX */
! 1236: #ifndef SD_DUMP_NOT_TRUSTED
! 1237: /*
! 1238: * Fill out the scsi command
! 1239: */
! 1240: bzero(&cmd, sizeof(cmd));
! 1241: cmd.opcode = WRITE_BIG;
! 1242: _lto4b(blkno, cmd.addr);
! 1243: _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: */
! 1250: bzero(xs, sizeof(sx));
! 1251: xs->flags |= SCSI_AUTOCONF | SCSI_DATA_OUT;
! 1252: xs->sc_link = sd->sc_link;
! 1253: xs->retries = SDRETRIES;
! 1254: xs->timeout = 10000; /* 10000 millisecs for a disk ! */
! 1255: xs->cmd = (struct scsi_generic *)&cmd;
! 1256: xs->cmdlen = sizeof(cmd);
! 1257: xs->resid = nwrt * sectorsize;
! 1258: xs->error = XS_NOERROR;
! 1259: xs->bp = NULL;
! 1260: xs->data = va;
! 1261: xs->datalen = nwrt * sectorsize;
! 1262:
! 1263: /*
! 1264: * Pass all this info to the scsi driver.
! 1265: */
! 1266: 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... */
! 1271: printf("sd%d: dump addr 0x%x, blk %d\n", unit, va, blkno);
! 1272: delay(500 * 1000); /* half a second */
! 1273: #endif /* SD_DUMP_NOT_TRUSTED */
! 1274:
! 1275: /* update block count */
! 1276: totwrt -= nwrt;
! 1277: blkno += nwrt;
! 1278: va += sectorsize * nwrt;
! 1279: }
! 1280: sddoingadump = 0;
! 1281: return 0;
! 1282: }
! 1283:
! 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
! 1290: viscpy(u_char *dst, u_char *src, int len)
! 1291: {
! 1292: while (len > 0 && *src != '\0') {
! 1293: if (*src < 0x20 || *src >= 0x80) {
! 1294: src++;
! 1295: continue;
! 1296: }
! 1297: *dst++ = *src++;
! 1298: len--;
! 1299: }
! 1300: *dst = '\0';
! 1301: }
! 1302:
! 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
! 1310: 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;
! 1316: u_int32_t heads = 0, sectors = 0, cyls = 0, blksize, ssblksize;
! 1317: u_int16_t rpm = 0;
! 1318:
! 1319: dp->disksize = scsi_size(sd->sc_link, flags, &ssblksize);
! 1320:
! 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. */
! 1328:
! 1329: buf = malloc(sizeof(*buf), M_TEMP, M_NOWAIT);
! 1330: if (buf == NULL)
! 1331: goto validate;
! 1332:
! 1333: switch (sd->sc_link->inqdata.device & SID_TYPE) {
! 1334: case T_OPTICAL:
! 1335: /* No more information needed or available. */
! 1336: break;
! 1337:
! 1338: case T_RDIRECT:
! 1339: /* T_RDIRECT supports only PAGE_REDUCED_GEOMETRY (6). */
! 1340: scsi_do_mode_sense(sd->sc_link, PAGE_REDUCED_GEOMETRY, buf,
! 1341: (void **)&reduced, NULL, NULL, &blksize, sizeof(*reduced),
! 1342: flags | SCSI_SILENT, NULL);
! 1343: if (DISK_PGCODE(reduced, PAGE_REDUCED_GEOMETRY)) {
! 1344: if (dp->disksize == 0)
! 1345: dp->disksize = _5btol(reduced->sectors);
! 1346: if (blksize == 0)
! 1347: blksize = _2btol(reduced->bytes_s);
! 1348: }
! 1349: break;
! 1350:
! 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: */
! 1359: rigid = NULL;
! 1360: if (((sd->sc_link->flags & SDEV_ATAPI) == 0) ||
! 1361: ((sd->sc_link->flags & SDEV_REMOVABLE) == 0))
! 1362: scsi_do_mode_sense(sd->sc_link, PAGE_RIGID_GEOMETRY,
! 1363: buf, (void **)&rigid, NULL, NULL, &blksize,
! 1364: sizeof(*rigid) - 4, flags | SCSI_SILENT, NULL);
! 1365: if (DISK_PGCODE(rigid, PAGE_RIGID_GEOMETRY)) {
! 1366: heads = rigid->nheads;
! 1367: cyls = _3btol(rigid->ncyl);
! 1368: rpm = _2btol(rigid->rpm);
! 1369: if (heads * cyls > 0)
! 1370: sectors = dp->disksize / (heads * cyls);
! 1371: } else {
! 1372: scsi_do_mode_sense(sd->sc_link, PAGE_FLEX_GEOMETRY,
! 1373: buf, (void **)&flex, NULL, NULL, &blksize,
! 1374: sizeof(*flex) - 4, flags | SCSI_SILENT, NULL);
! 1375: if (DISK_PGCODE(flex, PAGE_FLEX_GEOMETRY)) {
! 1376: sectors = flex->ph_sec_tr;
! 1377: heads = flex->nheads;
! 1378: cyls = _2btol(flex->ncyl);
! 1379: rpm = _2btol(flex->rpm);
! 1380: if (blksize == 0)
! 1381: blksize = _2btol(flex->bytes_s);
! 1382: if (dp->disksize == 0)
! 1383: dp->disksize = heads * cyls * sectors;
! 1384: }
! 1385: }
! 1386: break;
! 1387: }
! 1388:
! 1389: validate:
! 1390: if (buf)
! 1391: free(buf, M_TEMP);
! 1392:
! 1393: if (dp->disksize == 0)
! 1394: return (SDGP_RESULT_OFFLINE);
! 1395:
! 1396: if (ssblksize > 0)
! 1397: dp->blksize = ssblksize;
! 1398: else
! 1399: dp->blksize = (blksize == 0) ? 512 : blksize;
! 1400:
! 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:
! 1415: SC_DEBUG(sd->sc_link, SDEV_DB1,
! 1416: ("sd_get_parms: bad blksize: %#x\n", dp->blksize));
! 1417: return (SDGP_RESULT_OFFLINE);
! 1418: }
! 1419:
! 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) {
! 1427: dp->heads = 511;
! 1428: dp->sectors = 255;
! 1429: cyls = 0;
! 1430: } else {
! 1431: /*
! 1432: * Use standard geometry values for anything we still don't
! 1433: * know.
! 1434: */
! 1435: dp->heads = (heads == 0) ? 255 : heads;
! 1436: dp->sectors = (sectors == 0) ? 63 : sectors;
! 1437: dp->rot_rate = (rpm == 0) ? 3600 : rpm;
! 1438: }
! 1439:
! 1440: dp->cyls = (cyls == 0) ? dp->disksize / (dp->heads * dp->sectors) :
! 1441: cyls;
! 1442:
! 1443: return (SDGP_RESULT_OK);
! 1444: }
! 1445:
! 1446: void
! 1447: 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;
! 1451:
! 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) {
! 1468: bzero(&sync_cmd, sizeof(sync_cmd));
! 1469: sync_cmd.opcode = SYNCHRONIZE_CACHE;
! 1470:
! 1471: if (scsi_scsi_cmd(sc_link,
! 1472: (struct scsi_generic *)&sync_cmd, sizeof(sync_cmd),
! 1473: NULL, 0, SDRETRIES, 100000, NULL,
! 1474: flags|SCSI_IGNORE_ILLEGAL_REQUEST))
! 1475: printf("%s: WARNING: cache synchronization failed\n",
! 1476: sd->sc_dev.dv_xname);
! 1477: else
! 1478: sd->flags |= SDF_FLUSHING;
! 1479: }
! 1480: }
! 1481:
! 1482: /*
! 1483: * Remove unprocessed buffers from queue.
! 1484: */
! 1485: void
! 1486: sd_kill_buffers(struct sd_softc *sd)
! 1487: {
! 1488: struct buf *dp, *bp;
! 1489: int s;
! 1490:
! 1491: s = splbio();
! 1492: for (dp = &sd->buf_queue; (bp = dp->b_actf) != NULL; ) {
! 1493: dp->b_actf = bp->b_actf;
! 1494:
! 1495: bp->b_error = ENXIO;
! 1496: bp->b_flags |= B_ERROR;
! 1497: biodone(bp);
! 1498: }
! 1499: splx(s);
! 1500: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi