![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / sundev|
Return to sd.c CVS log | Up to [Research Unix] / researchv9 / sys / sundev |
1.1 root 1: /* @(#)sd.c 1.1 86/02/03 SMI */
2:
3: /*
4: * Copyright (c) 1984 by Sun Microsystems, Inc.
5: */
6:
7: /*
8: * SCSI driver for SCSI disks.
9: */
10:
11: #include "sd.h"
12: #include "../h/param.h"
13: #include "../h/systm.h"
14: #include "../h/dk.h"
15: #include "../h/buf.h"
16: #include "../h/conf.h"
17: #include "../h/dir.h"
18: #include "../h/user.h"
19: #include "../h/map.h"
20: #include "../h/vmmac.h"
21: /*
22: *#include "../h/ioctl.h"
23: *#include "../h/uio.h"
24: *#include "../h/kernel.h"
25: */
26: #include "../h/dkbad.h"
27:
28: #include "../machine/pte.h"
29: #include "../machine/psl.h"
30: #include "../machine/mmu.h"
31: #include "../machine/cpu.h"
32:
33: #include "../sun/dklabel.h"
34: #include "../sun/dkio.h"
35:
36: #include "../sundev/mbvar.h"
37: #include "../sundev/screg.h"
38: #include "../sundev/sireg.h"
39: #include "../sundev/scsi.h"
40:
41: #define MAX_RETRIES 3
42: #define MAX_RESTORES 1
43:
44: #define LPART(dev) (dev % NLPART)
45: #define SDUNIT(dev) ((dev >> 3) % NUNIT)
46: #define SDNUM(un) (un - sdunits)
47:
48: #define b_cylin b_resid
49: #define SECSIZE 512
50:
51: #define BUSY_RETRY 1000
52:
53: /*
54: * Error message control.
55: */
56: #define EL_RETRY 3
57: #define EL_REST 2
58: #define EL_FAIL 1
59: int sderrlvl = EL_RETRY;
60:
61: extern struct scsi_unit sdunits[];
62: extern struct scsi_unit_subr scsi_unit_subr[];
63: extern struct scsi_disk sdisk[];
64: extern int nsdisk;
65:
66: /*
67: * Return a pointer to this unit's unit structure.
68: */
69: sdunitptr(md)
70: register struct mb_device *md;
71: {
72: return ((int)&sdunits[md->md_unit]);
73: }
74:
75: /*
76: * Attach device (boot time).
77: */
78: sdattach(md)
79: register struct mb_device *md;
80: {
81: register struct scsi_unit *un;
82: register struct dk_label *l;
83: register int nbusy;
84:
85: un = &sdunits[md->md_unit];
86: un->un_md = md;
87: un->un_mc = md->md_mc;
88: un->un_unit = md->md_unit;
89: un->un_target = TARGET(md->md_slave);
90: un->un_lun = LUN(md->md_slave);
91: un->un_ss = &scsi_unit_subr[TYPE(md->md_flags)];
92:
93: nbusy = 0;
94: for (;;) {
95: if (simple(un, SC_TEST_UNIT_READY, 0, 0, 0)) {
96: break;
97: } else if (un->un_c->c_scb.busy && nbusy++ < BUSY_RETRY) {
98: DELAY(5000);
99: continue;
100: } else {
101: if (nbusy >= BUSY_RETRY) {
102: printf("sd%d: scsi continuously busy\n",
103: SDNUM(un));
104: }
105: return;
106: }
107: }
108: /* Allocate space for label in Multibus memory */
109: l = (struct dk_label *)rmalloc(iopbmap, (long)SECSIZE);
110: if (l == NULL) {
111: printf("sd%d: sdattach: no space for disk label\n",
112: SDNUM(un));
113: return;
114: }
115: l->dkl_magic = 0;
116: if (getlabel(un, l) && islabel(un, l)) {
117: uselabel(un, l);
118: }
119: rmfree(iopbmap, (long)SECSIZE, (long)l);
120: }
121:
122: static
123: getlabel(un, l)
124: register struct scsi_unit *un;
125: register struct dk_label *l;
126: {
127: register int retries, restores;
128:
129: for (restores = 0; restores < MAX_RESTORES; restores++) {
130: for (retries = 0; retries < MAX_RETRIES; retries++) {
131: if (simple(un, SC_READ, (char *) l - DVMA, 0, 1)) {
132: return (1);
133: }
134: }
135: (void) simple(un, SC_REZERO_UNIT, 0, 0, 0);
136: }
137: return (0);
138: }
139:
140: static
141: islabel(un, l)
142: register struct scsi_unit *un;
143: register struct dk_label *l;
144: {
145: if (l->dkl_magic != DKL_MAGIC) {
146: return (0);
147: }
148: if (!ck_cksum(l)) {
149: printf("sd%d: corrupt label\n", SDNUM(un));
150: return (0);
151: }
152: return (1);
153: }
154:
155: /*
156: * Check the checksum of the label
157: */
158: static
159: ck_cksum(l)
160: register struct dk_label *l;
161: {
162: short *sp, sum = 0;
163: short count = sizeof(struct dk_label)/sizeof(short);
164:
165: sp = (short *)l;
166: while (count--) {
167: sum ^= *sp++;
168: }
169: return (sum ? 0 : 1);
170: }
171:
172: static
173: uselabel(un, l)
174: register struct scsi_unit *un;
175: register struct dk_label *l;
176: {
177: register int i, intrlv;
178: register struct scsi_disk *dsi;
179:
180: printf("sd%d: <%s>\n", SDNUM(un), l->dkl_asciilabel);
181: un->un_present = 1;
182: dsi = &sdisk[un->un_unit];
183: dsi->un_g.dkg_ncyl = l->dkl_ncyl;
184: dsi->un_g.dkg_bcyl = 0;
185: dsi->un_g.dkg_nhead = l->dkl_nhead;
186: dsi->un_g.dkg_bhead = l->dkl_bhead;
187: dsi->un_g.dkg_nsect = l->dkl_nsect;
188: dsi->un_g.dkg_gap1 = l->dkl_gap1;
189: dsi->un_g.dkg_gap2 = l->dkl_gap2;
190: dsi->un_g.dkg_intrlv = l->dkl_intrlv;
191: for (i = 0; i < NLPART; i++)
192: dsi->un_map[i] = l->dkl_map[i];
193: if (un->un_md->md_dk >= 0) {
194: intrlv = dsi->un_g.dkg_intrlv;
195: if (intrlv <= 0 || intrlv >= dsi->un_g.dkg_nsect) {
196: intrlv = 1;
197: }
198: /*
199: dk_bps[un->un_md->md_dk] = SECSIZE*60*dsi->un_g.dkg_nsect/intrlv;
200: */
201: }
202: }
203:
204: static
205: simple(un, cmd, dma_addr, secno, nsect)
206: register struct scsi_unit *un;
207: register int cmd, dma_addr, secno, nsect;
208: {
209: register struct scsi_cdb *cdb;
210: register struct scsi_ctlr *c;
211: register int count;
212:
213: c = un->un_c;
214: cdb = &c->c_cdb;
215: bzero((caddr_t)cdb, sizeof(struct scsi_cdb));
216: cdb->cmd = cmd;
217: c->c_un = un;
218: cdb->lun = un->un_lun;
219: cdbaddr(cdb, secno);
220: cdb->count = nsect;
221: un->un_dma_addr = dma_addr;
222: un->un_dma_count = nsect * SECSIZE;
223: if ((*c->c_ss->scs_cmd)(c, un, 0)) {
224: if ((*c->c_ss->scs_cmd_wait)(c)) {
225: count = (*c->c_ss->scs_dmacount)(c);
226: * (char *) &c->c_scb = 0;
227: if ((*c->c_ss->scs_getstat)(un, 0)) {
228: if (count == 0) {
229: if (c->c_scb.chk == 0 &&
230: c->c_scb.busy == 0) {
231: return (1);
232: }
233: }
234: }
235: }
236: }
237: return (0);
238: }
239:
240: /*ARGSUSED*/
241: sdopen(dev, flag)
242: dev_t dev;
243: int flag;
244: {
245: register struct scsi_unit *un;
246: register struct dk_label *l;
247: register int unit;
248: register struct scsi_disk *dsi;
249: int memall();
250:
251: unit = SDUNIT(dev);
252: if (unit >= nsdisk) {
253: u.u_error = ENXIO;
254: return;
255: }
256: un = &sdunits[unit];
257: dsi = &sdisk[unit];
258: if (un->un_mc == 0) { /* never attached */
259: u.u_error = ENXIO;
260: return;
261: }
262: if (!un->un_present) {
263: dsi->un_g.dkg_nsect = dsi->un_g.dkg_nhead = 1; /* for strat */
264: if (sdcmd(dev, SC_TEST_UNIT_READY, 0, 0, (caddr_t)0)) {
265: u.u_error = EIO;
266: return;
267: }
268: /* Allocate space for label */
269: l = (struct dk_label *)wmemall(memall, SECSIZE);
270: if (l == NULL) {
271: printf("sd%d: no space for disk label\n",
272: SDNUM(un));
273: u.u_error = EIO;
274: return;
275: }
276: if (sdcmd(dev, SC_READ, 0, SECSIZE, (caddr_t)l)) {
277: uprintf("sd%d: error reading label\n", SDNUM(un));
278: wmemfree((caddr_t)l, SECSIZE);
279: u.u_error = EIO;
280: return;
281: }
282: if (islabel(un, l)) {
283: uselabel(un, l);
284: } else {
285: wmemfree((caddr_t)l, SECSIZE);
286: u.u_error = EIO;
287: return;
288: }
289: wmemfree((caddr_t)l, SECSIZE);
290: }
291: return (0);
292: }
293:
294: sdsize(dev)
295: register dev_t dev;
296: {
297: register struct scsi_unit *un;
298: register struct dk_map *lp;
299: register struct scsi_disk *dsi;
300:
301: un = &sdunits[SDUNIT(dev)];
302: if (!un->un_present) {
303: return (-1);
304: }
305: dsi = &sdisk[SDUNIT(dev)];
306: lp = &dsi->un_map[LPART(dev)];
307: return (lp->dkl_nblk);
308: }
309:
310: sdstrategy(bp)
311: register struct buf *bp;
312: {
313: register struct scsi_unit *un;
314: register struct dk_map *lp;
315: register daddr_t bn;
316: register int unit;
317: register struct buf *dp;
318: register struct scsi_disk *dsi;
319: long sz;
320: int s;
321:
322: sz = bp->b_bcount;
323: sz = (sz+511) >> 9;
324: unit = dkunit(bp);
325: if (unit >= nsdisk)
326: goto bad;
327: un = &sdunits[unit];
328: if (!un->un_present && bp != &un->un_sbuf)
329: goto bad;
330: dsi = &sdisk[unit];
331: lp = &dsi->un_map[LPART(bp->b_dev)];
332: if (bp->b_blkno < 0 || (bn = dkblock(bp))+sz > lp->dkl_nblk)
333: goto bad;
334: bp->b_cylin = bn / (dsi->un_g.dkg_nsect * dsi->un_g.dkg_nhead);
335: bp->b_cylin += lp->dkl_cylno + dsi->un_g.dkg_bcyl;
336: dp = &un->un_utab;
337: s = splx(pritospl(un->un_mc->mc_intpri));
338: disksort(dp, bp);
339: if (dp->b_active == 0) {
340: (*un->un_c->c_ss->scs_ustart)(un);
341: bp = &un->un_mc->mc_tab;
342: if (bp->b_actf && bp->b_active == 0) {
343: (*un->un_c->c_ss->scs_start)(un);
344: }
345: }
346: (void) splx(s);
347: return;
348:
349: bad:
350: bp->b_flags |= B_ERROR;
351: iodone(bp);
352: return;
353: }
354:
355: /*
356: * Do a special command.
357: */
358: sdcmd(dev, cmd, sector, len, addr)
359: register dev_t dev;
360: register int cmd, sector, len;
361: register caddr_t addr;
362: {
363: register struct scsi_unit *un;
364: register struct buf *bp;
365: register int s;
366:
367: un = &sdunits[SDUNIT(dev)];
368: bp = &un->un_sbuf;
369: s = splx(pritospl(un->un_mc->mc_intpri));
370: while (bp->b_flags&B_BUSY) {
371: bp->b_flags |= B_WANTED;
372: sleep((caddr_t)bp, PRIBIO);
373: }
374: bp->b_flags = B_BUSY|B_READ;
375: (void) splx(s);
376: un->un_scmd = cmd;
377: bp->b_dev = dev;
378: bp->b_blkno = sector;
379: bp->b_un.b_addr = addr;
380: bp->b_bcount = len;
381: sdstrategy(bp);
382: iowait(bp);
383: bp->b_flags &= ~B_BUSY;
384: if (bp->b_flags&B_WANTED)
385: wakeup((caddr_t)bp);
386: return (bp->b_flags & B_ERROR);
387: }
388:
389: /*
390: * Set up a transfer for the controller
391: */
392: sdstart(bp, un)
393: register struct buf *bp;
394: register struct scsi_unit *un;
395: {
396: register struct dk_map *lp;
397: register int nblk;
398: register struct scsi_disk *dsi;
399:
400: dsi = &sdisk[dkunit(bp)];
401: lp = &dsi->un_map[LPART(bp->b_dev)];
402: un->un_blkno = dkblock(bp) +
403: lp->dkl_cylno * dsi->un_g.dkg_nhead * dsi->un_g.dkg_nsect;
404: if (bp == &un->un_sbuf) {
405: un->un_cmd = un->un_scmd;
406: } else if (bp->b_flags & B_READ) {
407: un->un_cmd = SC_READ;
408: } else {
409: un->un_cmd = SC_WRITE;
410: }
411: if (un->un_cmd == SC_READ || un->un_cmd == SC_WRITE) {
412: nblk = howmany(bp->b_bcount, SECSIZE);
413: un->un_count = MIN(nblk, lp->dkl_nblk - bp->b_blkno);
414: bp->b_resid = bp->b_bcount - un->un_count * SECSIZE;
415: un->un_flags |= SC_UNF_DVMA;
416: } else {
417: un->un_count = 0;
418: }
419: return (1);
420: }
421:
422: /*
423: * Make a cdb for disk i/o.
424: */
425: sdmkcdb(c, un)
426: register struct scsi_ctlr *c;
427: struct scsi_unit *un;
428: {
429: register struct scsi_cdb *cdb;
430:
431: cdb = &c->c_cdb;
432: bzero((caddr_t)cdb, sizeof (*cdb));
433: cdb->cmd = un->un_cmd;
434: cdb->lun = un->un_lun;
435: cdbaddr(cdb, un->un_blkno);
436: cdb->count = un->un_count;
437: un->un_dma_addr = un->un_baddr;
438: un->un_dma_count = un->un_count * SECSIZE;
439: }
440:
441: /*
442: * Interrupt processing.
443: */
444: sdintr(c, resid, error)
445: register struct scsi_ctlr *c;
446: register int resid, error;
447: {
448: register struct scsi_unit *un;
449: register struct buf *bp;
450: register struct mb_device *md;
451:
452: un = c->c_un;
453: bp = un->un_mc->mc_tab.b_actf->b_actf;
454: md = un->un_md;
455: if (md->md_dk >= 0) {
456: dk_busy &= ~(1 << md->md_dk);
457: }
458: if (error == SE_FATAL) {
459: if (bp == &un->un_sbuf &&
460: ((un->un_flags & SC_UNF_DVMA) == 0)) {
461: (*c->c_ss->scs_done)(un->un_mc);
462: } else {
463: mbdone(un->un_mc);
464: un->un_flags &= ~SC_UNF_DVMA;
465: }
466: bp->b_flags |= B_ERROR;
467: printf("sd%d: SCSI FAILURE\n", SDNUM(un));
468: (*c->c_ss->scs_off)(un);
469: return;
470: }
471: if (error == SE_RETRYABLE || c->c_scb.chk || resid > 0) {
472: sderror(c, un, bp);
473: return;
474: }
475: if (c->c_cdb.cmd == SC_REZERO_UNIT &&
476: !(bp == &un->un_sbuf &&
477: un->un_scmd == SC_REZERO_UNIT)) {
478: /* error recovery */
479: sdmkcdb(c, un);
480: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) {
481: printf("sd%d sdintr: scsi cmd failed 1\n", SDNUM(un));
482: (*c->c_ss->scs_off)(un);
483: }
484: return;
485: }
486: /* transfer worked */
487: un->un_retries = un->un_restores = 0;
488: if (un->un_sec_left) { /* single sector stuff */
489: un->un_sec_left--;
490: un->un_baddr += SECSIZE;
491: un->un_blkno++;
492: sdmkcdb(c, un);
493: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) {
494: printf("sd%d: sdintr: scsi cmd failed 2\n", SDNUM(un));
495: (*c->c_ss->scs_off)(un);
496: }
497: } else if (bp == &un->un_sbuf &&
498: ((un->un_flags & SC_UNF_DVMA) == 0)) {
499: (*c->c_ss->scs_done)(un->un_mc);
500: } else {
501: mbdone(un->un_mc);
502: un->un_flags &= ~SC_UNF_DVMA;
503: }
504: }
505:
506: /*
507: * Error handling.
508: */
509: sderror(c, un, bp)
510: register struct scsi_ctlr *c;
511: register struct scsi_unit *un;
512: register struct buf *bp;
513: {
514: if (un->un_present == 0) { /* error trying to open */
515: bp->b_flags |= B_ERROR;
516: if (bp == &un->un_sbuf &&
517: ((un->un_flags & SC_UNF_DVMA) == 0)) {
518: (*c->c_ss->scs_done)(un->un_mc);
519: } else {
520: mbdone(un->un_mc);
521: un->un_flags &= ~SC_UNF_DVMA;
522: }
523: } else if (c->c_scb.chk && c->c_sense->class == 1 &&
524: c->c_sense->code == 5 && un->un_count > 1) {
525: /* Seek errors - try single sectors (Adaptec bug) */
526: un->un_sec_left = un->un_count - 1;
527: un->un_count = 1;
528: sdmkcdb(c, un);
529: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) {
530: printf("sd%d: sderror: scsi cmd failed 1\n", SDNUM(un));
531: (*c->c_ss->scs_off)(un);
532: }
533: } else if (un->un_retries++ < MAX_RETRIES) {
534: /* retry */
535: if (sderrlvl >= EL_RETRY) {
536: sderrmsg(c, un, bp, "retry");
537: }
538: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) {
539: printf("sd%d: sderror: scsi cmd failed 2\n", SDNUM(un));
540: (*c->c_ss->scs_off)(un);
541: }
542: } else if (un->un_restores++ < MAX_RESTORES) {
543: /* retries exhausted, try restore */
544: un->un_retries = 0;
545: if (sderrlvl >= EL_REST) {
546: sderrmsg(c, un, bp, "restore");
547: }
548: c->c_cdb.cmd = SC_REZERO_UNIT;
549: cdbaddr(&c->c_cdb, 0);
550: c->c_cdb.count = 0;
551: un->un_dma_addr = un->un_dma_count = 0;
552: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) {
553: printf("sd%d: sderror: scsi cmd failed 3\n", SDNUM(un));
554: (*c->c_ss->scs_off)(un);
555: }
556: } else {
557: /* complete failure */
558: if (sderrlvl >= EL_FAIL) {
559: sderrmsg(c, un, bp, "failed");
560: }
561: (*c->c_ss->scs_off)(un);
562: bp->b_flags |= B_ERROR;
563: if (bp == &un->un_sbuf &&
564: ((un->un_flags & SC_UNF_DVMA) == 0)) {
565: (*c->c_ss->scs_done)(un->un_mc);
566: } else {
567: mbdone(un->un_mc);
568: un->un_flags &= ~SC_UNF_DVMA;
569: }
570: }
571: }
572:
573: sdread(dev)
574: dev_t dev;
575: {
576: sdrw(dev, B_READ);
577: }
578:
579: sdrw(dev, direction)
580: dev_t dev;
581: int direction;
582: {
583: register struct scsi_unit *un;
584: register int unit;
585:
586: unit = SDUNIT(dev);
587: if (unit >= nsdisk) {
588: u.u_error = ENXIO;
589: }
590: un = &sdunits[unit];
591: physio(sdstrategy, &un->un_rbuf, dev, direction, minphys);
592: }
593:
594: sdwrite(dev)
595: dev_t dev;
596: {
597: sdrw(dev, B_WRITE);
598: }
599:
600: /*ARGSUSED*/
601: sdioctl(dev, cmd, data, flag)
602: register dev_t dev;
603: register caddr_t data;
604: {
605: register struct scsi_unit *un;
606: register struct dk_map *lp;
607: register struct dk_info *inf;
608: register int unit;
609: register struct scsi_disk *dsi;
610:
611: unit = SDUNIT(dev);
612: if (unit >= nsdisk) {
613: return (ENXIO);
614: }
615: un = &sdunits[unit];
616: dsi = &sdisk[unit];
617: lp = &dsi->un_map[LPART(dev)];
618: switch (cmd) {
619:
620: case DKIOCINFO:
621: inf = (struct dk_info *)data;
622: inf->dki_ctlr = getdevaddr(un->un_mc->mc_addr);
623: inf->dki_unit = un->un_md->md_slave;
624: inf->dki_ctype = DKC_SCSI;
625: inf->dki_flags = DKI_FMTVOL;
626: break;
627:
628: case DKIOCGGEOM:
629: *(struct dk_geom *)data = dsi->un_g;
630: break;
631:
632: case DKIOCSGEOM:
633: if (!suser())
634: return (u.u_error);
635: dsi->un_g = *(struct dk_geom *)data;
636: break;
637:
638: case DKIOCGPART:
639: *(struct dk_map *)data = *lp;
640: break;
641:
642: case DKIOCSPART:
643: if (!suser())
644: return (u.u_error);
645: *lp = *(struct dk_map *)data;
646: break;
647:
648: default:
649: return (ENOTTY);
650: }
651: return (0);
652: }
653:
654: sddump(dev, addr, blkno, nblk)
655: register dev_t dev;
656: register caddr_t addr;
657: register daddr_t blkno, nblk;
658: {
659: register struct scsi_unit *un;
660: register struct dk_map *lp;
661: static int first_time = 1;
662: register struct scsi_disk *dsi;
663:
664: un = &sdunits[SDUNIT(dev)];
665: if (un->un_present == 0) {
666: return (ENXIO);
667: }
668: dsi = &sdisk[SDUNIT(dev)];
669: lp = &dsi->un_map[LPART(dev)];
670: if (blkno >= lp->dkl_nblk || (blkno + nblk) > lp->dkl_nblk) {
671: return (EINVAL);
672: }
673: blkno += lp->dkl_cylno * dsi->un_g.dkg_nhead * dsi->un_g.dkg_nsect;
674: if (first_time) {
675: (*un->un_c->c_ss->scs_reset)(un->un_c); /* clr state - prevent err msg */
676: first_time = 0;
677: }
678: if (simple(un, SC_WRITE, (int)(addr-DVMA), (int) blkno, (int) nblk)) {
679: return (0);
680: } else {
681: return (EIO);
682: }
683: }
684:
685: char *class_00_errors[] = {
686: "no sense",
687: "no index signal",
688: "no seek complete",
689: "write fault",
690: "drive not ready",
691: "drive not selected",
692: "no track 00",
693: "multiple drives selected",
694: "no address acknowledged",
695: "media not loaded",
696: "insufficient capacity",
697: };
698:
699: char *class_01_errors[] = {
700: "I.D. CRC error",
701: "unrecoverable data error",
702: "I.D. address mark not found",
703: "data address mark not found",
704: "record not found",
705: "seek error",
706: "DMA timeout error",
707: "write protected",
708: "correctable data check",
709: "bad block found",
710: "interleave error",
711: "data transfer incomplete",
712: "unformatted or bad format on drive",
713: "self test failed",
714: "defective track (media errors)",
715: };
716:
717: char *class_02_errors[] = {
718: "invalid command",
719: "illegal block address",
720: "aborted",
721: "volume overflow",
722: };
723:
724: char **sc_errors[] = {
725: class_00_errors,
726: class_01_errors,
727: class_02_errors,
728: 0, 0, 0, 0,
729: };
730:
731: int sc_errct[] = {
732: sizeof class_00_errors / sizeof (char *),
733: sizeof class_01_errors / sizeof (char *),
734: sizeof class_02_errors / sizeof (char *),
735: 0, 0, 0, 0,
736: };
737:
738: char *sc_ext_sense_keys [] = {
739: "no sense",
740: "recoverable error",
741: "not ready",
742: "media error",
743: "hardware error",
744: "illegal request",
745: "media change",
746: "write protect",
747: "diagnostic unique",
748: "vendor unique",
749: "power up failed",
750: "aborted command",
751: "equal",
752: "volume overflow",
753: };
754:
755: #define N_EXT_SENSE_KEYS \
756: (sizeof(sc_ext_sense_keys)/sizeof(sc_ext_sense_keys[0]))
757:
758: char *sd_cmds[] = {
759: "test unit ready",
760: "rezero unit",
761: "<bad cmd>",
762: "request sense",
763: "<bad cmd>",
764: "<bad cmd>",
765: "<bad cmd>",
766: "<bad cmd>",
767: "read",
768: "<bad cmd>",
769: "write",
770: "seek",
771: };
772:
773: sderrmsg(c, un, bp, action)
774: register struct scsi_ctlr *c;
775: struct scsi_unit *un;
776: struct buf *bp;
777: char *action;
778: {
779: char *sensemsg, *cmdname;
780: register struct scsi_sense *sense;
781: #define ext_sense ((struct scsi_ext_sense* ) sense)
782: register struct dk_map *lp;
783: register int blkno;
784: register struct scsi_disk *dsi;
785:
786: dsi = &sdisk[dkunit(bp)];
787: sense = c->c_sense;
788: if (c->c_scb.chk == 0) {
789: sensemsg = "no sense";
790: } else if (sense->class <= 6) {
791: if (sense->code < sc_errct[sense->class]) {
792: sensemsg = sc_errors[sense->class][sense->code];
793: } else {
794: sensemsg = "invalid sense code";
795: }
796: } else if (sense->class == 7) {
797: if (ext_sense->key < N_EXT_SENSE_KEYS) {
798: sensemsg = sc_ext_sense_keys[ext_sense->key];
799: } else {
800: sensemsg = "invalid sense code";
801: }
802: } else {
803: sensemsg = "invalid sense class";
804: }
805: if (un->un_cmd < sizeof(sd_cmds)) {
806: cmdname = sd_cmds[un->un_cmd];
807: } else {
808: cmdname = "unknown cmd";
809: }
810: blkno = (sense->high_addr << 16) | (sense->mid_addr << 8) |
811: sense->low_addr;
812: lp = &dsi->un_map[LPART(bp->b_dev)];
813: blkno -= lp->dkl_cylno * dsi->un_g.dkg_nhead * dsi->un_g.dkg_nsect;
814: printf("sd%d%c: %s %s (%s) blk %d\n", SDNUM(un),
815: LPART(bp->b_dev) + 'a', cmdname, action, sensemsg, blkno);
816: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.