![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mscp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vax|
Return to mscp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vax |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Chris Torek.
7: *
8: * Redistribution is only permitted until one year after the first shipment
9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
10: * binary forms are permitted provided that: (1) source distributions retain
11: * this entire copyright notice and comment, and (2) distributions including
12: * binaries display the following acknowledgement: This product includes
13: * software developed by the University of California, Berkeley and its
14: * contributors'' in the documentation or other materials provided with the
15: * distribution and in all advertising materials mentioning features or use
16: * of this software. Neither the name of the University nor the names of
17: * its contributors may be used to endorse or promote products derived from
18: * this software without specific prior written permission.
19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22: *
23: * @(#)mscp.c 7.4 (Berkeley) 6/28/90
24: */
25:
26: /*
27: * MSCP generic driver routines
28: */
29:
30: #include "param.h"
31: #include "buf.h"
32: #include "errno.h"
33: #include "dkstat.h"
34: #include "ioctl.h"
35: #include "disklabel.h"
36: #include "syslog.h"
37:
38: #include "../vaxuba/ubavar.h"
39:
40: #include "mscp.h"
41: #include "mscpvar.h"
42:
43: #define PCMD PSWP /* priority for command packet waits */
44:
45: /*
46: * During transfers, mapping info is saved in the buffer's b_resid.
47: */
48: #define b_info b_resid
49:
50: /*
51: * Get a command packet. Second argument is true iff we are
52: * to wait if necessary. Return NULL if none are available and
53: * we cannot wait.
54: */
55: struct mscp *
56: mscp_getcp(mi, canwait)
57: register struct mscp_info *mi;
58: int canwait;
59: {
60: #define mri (&mi->mi_cmd)
61: register struct mscp *mp;
62: register int i;
63: int s = spl5();
64:
65: again:
66: /*
67: * Ensure that we have some command credits, and
68: * that the next command packet is free.
69: */
70: if (mi->mi_credits <= MSCP_MINCREDITS) {
71: if (!canwait) {
72: splx(s);
73: return (NULL);
74: }
75: mi->mi_wantcredits = 1;
76: sleep((caddr_t) &mi->mi_wantcredits, PCMD);
77: goto again;
78: }
79: i = mri->mri_next;
80: if (mri->mri_desc[i] & MSCP_OWN) {
81: if (!canwait) {
82: splx(s);
83: return (NULL);
84: }
85: mi->mi_wantcmd = 1;
86: sleep((caddr_t) &mi->mi_wantcmd, PCMD);
87: goto again;
88: }
89: mi->mi_credits--;
90: mri->mri_desc[i] &= ~MSCP_INT;
91: mri->mri_next = (mri->mri_next + 1) % mri->mri_size;
92: splx(s);
93: mp = &mri->mri_ring[i];
94:
95: /*
96: * Initialise some often-zero fields.
97: * ARE THE LAST TWO NECESSARY IN GENERAL? IT SURE WOULD BE
98: * NICE IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
99: */
100: mp->mscp_msglen = MSCP_MSGLEN;
101: mp->mscp_flags = 0;
102: mp->mscp_modifier = 0;
103: mp->mscp_seq.seq_bytecount = 0;
104: mp->mscp_seq.seq_buffer = 0;
105: mp->mscp_seq.seq_mapbase = 0;
106: /*???*/ mp->mscp_sccc.sccc_errlgfl = 0;
107: /*???*/ mp->mscp_sccc.sccc_copyspd = 0;
108: return (mp);
109: #undef mri
110: }
111:
112: #ifdef AVOID_EMULEX_BUG
113: int mscp_aeb_xor = 0x8000bb80;
114: #endif
115:
116: /*
117: * Do a device go. The driver calls this once it has allocated
118: * resources for the transfer. Save the resource information in
119: * bp->b_ubinfo, and finish the MSCP packet.
120: *
121: * N.B.: If we were blocked for some time, the drive could have gone
122: * off line and might still be that way. We should probably handle
123: * such a case by changing this command into an on line request and
124: * not dequeuing the transfer after all.
125: */
126: mscp_go(mi, mp, info)
127: register struct mscp_info *mi;
128: register struct mscp *mp;
129: int info;
130: {
131: register struct buf *bp, *dp;
132:
133: /*
134: * Now is also the time to move the transfer off the
135: * controller and drive queues, and shuffle the drive
136: * queue on the controller queue. The idea is to try
137: * to keep as many drives busy as possible---to deal
138: * the controller's credits out to the drives in a `fair
139: * share' arrangement. (To do this fully would be more
140: * trouble than it is worth, though.)
141: */
142: dp = mi->mi_tab->b_actf;
143: bp = dp->b_actf;
144: dp->b_actf = bp->av_forw; /* transfer off drive queue */
145: mi->mi_tab->b_actf = dp->b_forw;/* drive off ctlr queue */
146: APPEND(dp, mi->mi_tab, b_forw); /* then back again */
147:
148: /*
149: * Move the buffer to the I/O wait queue.
150: */
151: bp->av_back = mi->mi_wtab.av_back;
152: bp->av_forw = &mi->mi_wtab;
153: mi->mi_wtab.av_back->av_forw = bp;
154: mi->mi_wtab.av_back = bp;
155:
156: /*
157: * Save the mapping info, finish the command packet, and give
158: * it to the device. The device's dgo routine should then
159: * initiate polling.
160: */
161: bp->b_info = info;
162: #ifdef AVOID_EMULEX_BUG
163: /*
164: * The Emulex SC41/MS will occasionally zero the lower half word
165: * of the command reference number. The upper half word remains
166: * intact. To keep running, we convert the buffer address into
167: * a small but nonzero integer that is unique over all pending
168: * transfers, and store that value in the upper half word. To
169: * catch occurrances of the bug (so that we can gripe to Emulex),
170: * we also put a nonzero value in the lower word.
171: */
172: {
173: register u_int i = mi->mi_nextbp;
174:
175: do { /* find a free value */
176: if (mi->mi_bp[i] == 0)
177: goto found;
178: i = (i + 1) % AEB_MAX_BP;
179: } while (i != mi->mi_nextbp);
180: panic("mscp_go: AEB_MAX_BP too small");
181: found:
182: mi->mi_bp[i++] = bp;
183: mi->mi_nextbp = i % AEB_MAX_BP;
184: mp->mscp_cmdref = (i << 16) ^ mscp_aeb_xor;
185: }
186: #else
187: mp->mscp_cmdref = (long) bp;
188: #endif
189: *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
190: }
191:
192: /*
193: * Handle a response ring transition.
194: */
195: mscp_dorsp(mi)
196: register struct mscp_info *mi;
197: {
198: register struct uba_device *ui;
199: register struct buf *bp;
200: register struct mscp *mp;
201: register int nextrsp;
202: struct mscp_driver *md = mi->mi_md;
203: char *ctlrname, *drivename;
204: int st, error, info;
205:
206: ctlrname = md->md_mname;
207: drivename = md->md_dname;
208: nextrsp = mi->mi_rsp.mri_next;
209: loop:
210: if (mi->mi_rsp.mri_desc[nextrsp] & MSCP_OWN) {
211: /*
212: * No more responses. Remember the next expected
213: * response index. Check to see if we have some
214: * credits back, and wake up sleepers if so.
215: */
216: mi->mi_rsp.mri_next = nextrsp;
217: if (mi->mi_wantcredits && mi->mi_credits > MSCP_MINCREDITS) {
218: mi->mi_wantcredits = 0;
219: wakeup((caddr_t) &mi->mi_wantcredits);
220: }
221: return;
222: }
223:
224: /*
225: * Found a response. Update credit information. If there is
226: * nothing else to do, jump to `done' to get the next response.
227: */
228: mp = &mi->mi_rsp.mri_ring[nextrsp];
229: mi->mi_credits += MSCP_CREDITS(mp->mscp_msgtc);
230: switch (MSCP_MSGTYPE(mp->mscp_msgtc)) {
231:
232: case MSCPT_SEQ:
233: break;
234:
235: case MSCPT_DATAGRAM:
236: (*md->md_dgram)(mi, mp);
237: goto done;
238:
239: case MSCPT_CREDITS:
240: goto done;
241:
242: case MSCPT_MAINTENANCE:
243: default:
244: printf("%s%d: unit %d: unknown message type 0x%x ignored\n",
245: ctlrname, mi->mi_ctlr, mp->mscp_unit,
246: MSCP_MSGTYPE(mp->mscp_msgtc));
247: goto done;
248: }
249:
250: /*
251: * Controllers are allowed to interrupt as any drive, so we
252: * must check the command before checking for a drive.
253: */
254: if (mp->mscp_opcode == (M_OP_SETCTLRC | M_OP_END)) {
255: (*md->md_ctlrdone)(mi, mp);
256: goto done;
257: }
258:
259: /*
260: * Find the drive info. If there is none, and this is an
261: * available attention response, try configuring a new drive.
262: */
263: if (mp->mscp_unit > md->md_ndpc) {
264: printf("%s%d: unit %d out of range\n",
265: ctlrname, mi->mi_ctlr, mp->mscp_unit);
266: goto done;
267: }
268: if ((ui = mi->mi_ip[mp->mscp_unit]) == NULL) {
269: if ((*md->md_unconf)(mi, mp) != MSCP_DONE) {
270: printf("%s%d: unit %d not configured, ",
271: ctlrname, mi->mi_ctlr, mp->mscp_unit);
272: if (mp->mscp_opcode == M_OP_AVAILATTN)
273: printf("available attn");
274: else
275: printf("stray response op 0x%x status 0x%x",
276: mp->mscp_opcode, mp->mscp_status);
277: printf(" ignored\n");
278: }
279: goto done;
280: }
281:
282: /*
283: * Handle individual responses.
284: */
285: st = mp->mscp_status & M_ST_MASK;
286: error = 0;
287: switch (mp->mscp_opcode) {
288:
289: case M_OP_END:
290: /*
291: * The controller presents a bogus END packet when
292: * a read/write command is given with an illegal
293: * block number. This is contrary to the MSCP
294: * specification (ENDs are to be given only for
295: * invalid commands), but that is the way of it.
296: */
297: if (st == M_ST_INVALCMD && mp->mscp_cmdref != 0) {
298: printf("%s%d: bad lbn (%d)?\n", drivename,
299: ui->ui_unit, mp->mscp_seq.seq_lbn);
300: error = EIO;
301: goto rwend;
302: }
303: goto unknown;
304:
305: case M_OP_ONLINE | M_OP_END:
306: /*
307: * Finished an ON LINE request. Call the driver to
308: * find out whether it succeeded. If so, mark it on
309: * line.
310: */
311: if (ui->ui_flags & UNIT_ONLINE) {
312: printf("%s%d: duplicate ONLINE ignored\n",
313: drivename, ui->ui_unit);
314: break;
315: }
316: if ((*md->md_online)(ui, mp) == MSCP_DONE)
317: ui->ui_flags |= UNIT_ONLINE;
318: break;
319:
320: case M_OP_GETUNITST | M_OP_END:
321: /*
322: * Got unit status. Call the driver to find out
323: * whether it succeeded, and if so, mark it.
324: */
325: if ((*md->md_gotstatus)(ui, mp) == MSCP_DONE)
326: ui->ui_flags |= UNIT_HAVESTATUS;
327: break;
328:
329: case M_OP_AVAILATTN:
330: /*
331: * The drive went offline and we did not notice.
332: * Mark it off line now, to force an on line request
333: * next, so we can make sure it is still the same
334: * drive.
335: *
336: * IF THE UDA DRIVER HAS A COMMAND AWAITING UNIBUS
337: * RESOURCES, THAT COMMAND MAY GO OUT BEFORE THE ON
338: * LINE. IS IT WORTH FIXING??
339: */
340: ui->ui_flags &= ~(UNIT_ONLINE | UNIT_HAVESTATUS);
341: #ifdef notyet
342: (*md->md_offline)(ui, mp);
343: #endif
344: break;
345:
346: case M_OP_READ | M_OP_END:
347: case M_OP_WRITE | M_OP_END:
348: /*
349: * A transfer finished. Get the buffer, and release its
350: * map registers via ubadone(). If the command finished
351: * with an off line or available status, the drive went
352: * off line (the idiot controller does not tell us until
353: * it comes back *on* line, or until we try to use it).
354: */
355: if (mp->mscp_cmdref == 0) {
356: /*
357: * No buffer means there is a bug somewhere!
358: */
359: printf("%s%d: io done, but no buffer?\n",
360: drivename, ui->ui_unit);
361: mscp_hexdump(mp);
362: break;
363: }
364:
365: rwend:
366: #ifdef AVOID_EMULEX_BUG
367: {
368: register u_short *p = (u_short *) &mp->mscp_cmdref;
369:
370: /*
371: * Note any errors on the part of the controller.
372: * The lower word should be zero after exclusive
373: * or'ing with mscp_aeb_xor, and the upper should
374: * then be in the range [1..AEB_MAX_BP].
375: */
376: mp->mscp_cmdref ^= mscp_aeb_xor;
377: p[1]--;
378: if (p[1] >= AEB_MAX_BP)
379: panic("unrecoverable Emulex screwup");
380: if (p[0] == 0)
381: mi->mi_ok++;
382: else {
383: /*
384: * Calculate the expected response,
385: * assuming p[1] is correct. The
386: * actual response is then the expected
387: * response xor p[0].
388: */
389: int sb = ((p[1] + 1) << 16) ^ mscp_aeb_xor;
390:
391: log(LOG_WARNING, "\
392: Emulex SC41/MS screwup: %s%d, got %d correct, then changed 0x%x to 0x%x\n",
393: ctlrname, mi->mi_ctlr,
394: mi->mi_ok, sb, sb ^ p[0]);
395: mi->mi_ok = 0;
396: }
397: /* convert index back to buffer, and mark free */
398: bp = mi->mi_bp[p[1]];
399: mi->mi_bp[p[1]] = 0;
400: }
401: #else
402: bp = (struct buf *) mp->mscp_cmdref;
403: #ifdef MSCP_PARANOIA
404: {
405: register struct buf *q = mi->mi_wtab.av_forw;
406:
407: /*
408: * Ensure that this response corresponds to
409: * some outstanding request. If not, ignore
410: * it entirely. This will likely cause a
411: * Unibus reset soon, after which the controller
412: * just might behave.
413: */
414: while (q != bp && q != &mi->mi_wtab)
415: q = q->av_forw;
416: if (q != bp) {
417: printf("%s%d: bad response packet ignored\n",
418: ctlrname, mi->mi_ctlr);
419: mscp_hexdump(mp);
420: goto out;
421: }
422: }
423: #endif MSCP_PARANOIA
424: #endif AVOID_EMULEX_BUG
425:
426: /*
427: * Mark any error-due-to-bad-LBN (via `goto rwend').
428: * WHAT STATUS WILL THESE HAVE? IT SURE WOULD BE NICE
429: * IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
430: */
431: if (error) {
432: bp->b_flags |= B_ERROR;
433: bp->b_error = error;
434: }
435: if (st == M_ST_OFFLINE || st == M_ST_AVAILABLE) {
436: ui->ui_flags &= ~(UNIT_ONLINE | UNIT_HAVESTATUS);
437: #ifdef notyet
438: (*md->md_offline)(ui, mp);
439: #endif
440: }
441:
442: /*
443: * Unlink the transfer from the wait queue mi_wtab.
444: * If there are no more transfers on the drive queue
445: * for this drive, and it is a profiled disk, turn
446: * off its busy bit.
447: */
448: bp->av_back->av_forw = bp->av_forw;
449: bp->av_forw->av_back = bp->av_back;
450: if (ui->ui_dk >= 0 && md->md_utab[ui->ui_unit].b_forw == NULL)
451: dk_busy &= ~(1 << ui->ui_dk);
452:
453: /*
454: * If the transfer has something to do with bad
455: * block forwarding, let the driver handle the
456: * rest.
457: */
458: if ((bp->b_flags & B_BAD) != 0 && md->md_bb != NULL) {
459: (*md->md_bb)(ui, mp, bp);
460: goto out;
461: }
462:
463: /*
464: * If the transfer failed, give the driver a crack
465: * at fixing things up.
466: */
467: if (st != M_ST_SUCCESS) {
468: switch ((*md->md_ioerr)(ui, mp, bp)) {
469:
470: case MSCP_DONE: /* fixed */
471: break;
472:
473: case MSCP_RESTARTED: /* still working on it */
474: goto out;
475:
476: case MSCP_FAILED: /* no luck */
477: diskerr(bp, drivename, "hard error",
478: LOG_PRINTF, -1, md->md_lab ?
479: &md->md_lab[ui->ui_unit] : md->md_lab);
480: mscp_printevent(mp);
481: bp->b_flags |= B_ERROR;
482: bp->b_error = EIO;
483: break;
484: }
485: }
486:
487: /*
488: * Set the residual count and mark the transfer as
489: * done. If the I/O wait queue is now empty, release
490: * the shared BDP, if any.
491: */
492: info = bp->b_info; /* we are about to clobber it */
493: bp->b_resid = bp->b_bcount - mp->mscp_seq.seq_bytecount;
494: (*md->md_iodone)(mi, bp, info);
495: out:
496: break;
497:
498: case M_OP_REPLACE | M_OP_END:
499: /*
500: * A replace operation finished. Just let the driver
501: * handle it (if it does replaces).
502: */
503: if (md->md_replace == NULL)
504: printf("%s%d: bogus REPLACE end\n",
505: drivename, ui->ui_unit);
506: else
507: (*md->md_replace)(ui, mp);
508: break;
509:
510: default:
511: /*
512: * If it is not one of the above, we cannot handle it.
513: * (And we should not have received it, for that matter.)
514: */
515: unknown:
516: printf("%s%d: unknown opcode 0x%x status 0x%x ignored\n",
517: mi->mi_md->md_dname, ui->ui_unit,
518: mp->mscp_opcode, mp->mscp_status);
519: mscp_hexdump(mp);
520: break;
521: }
522:
523: /*
524: * If the drive needs to be put back in the controller queue,
525: * do that now. (`bp' below ought to be `dp', but they are all
526: * struct buf *.) Note that b_active was cleared in the driver;
527: * we presume that there is something to be done, hence reassert it.
528: */
529: if (ui->ui_flags & UNIT_REQUEUE) {
530: bp = &md->md_utab[ui->ui_unit];
531: if (bp->b_active) panic("mscp_dorsp requeue");
532: APPEND(bp, mi->mi_tab, b_forw);
533: bp->b_active = 1;
534: ui->ui_flags &= ~UNIT_REQUEUE;
535: }
536:
537: done:
538: /*
539: * Give back the response packet, and take a look at the next.
540: */
541: mp->mscp_msglen = MSCP_MSGLEN;
542: mi->mi_rsp.mri_desc[nextrsp] |= MSCP_OWN;
543: nextrsp = (nextrsp + 1) % mi->mi_rsp.mri_size;
544: goto loop;
545: }
546:
547: /*
548: * Dump the entire contents of an MSCP packet in hex. Mainly useful
549: * for debugging....
550: */
551: mscp_hexdump(mp)
552: register struct mscp *mp;
553: {
554: register long *p = (long *) mp;
555: register int i = mp->mscp_msglen;
556:
557: if (i > 256) /* sanity */
558: i = 256;
559: i /= sizeof (*p); /* ASSUMES MULTIPLE OF sizeof(long) */
560: while (--i >= 0)
561: printf("0x%x ", *p++);
562: printf("\n");
563: }
564:
565: /*
566: * Requeue outstanding transfers, e.g., after bus reset.
567: * Also requeue any drives that have on line or unit status
568: * info pending.
569: */
570: mscp_requeue(mi)
571: struct mscp_info *mi;
572: {
573: register struct uba_device *ui;
574: register struct mscp_driver *md = mi->mi_md;
575: register struct buf *bp, *dp;
576: register int unit;
577: struct buf *nextbp;
578:
579: /*
580: * Clear the controller chain. Mark everything un-busy; we
581: * will soon fix any that are in fact busy.
582: */
583: mi->mi_tab->b_actf = NULL;
584: mi->mi_tab->b_active = 0;
585: for (unit = 0, dp = md->md_utab; unit < md->md_nunits; unit++, dp++) {
586: ui = md->md_dinfo[unit];
587: if (ui == NULL || !ui->ui_alive || ui->ui_ctlr != mi->mi_ctlr)
588: continue; /* not ours */
589: dp->b_forw = NULL;
590: dp->b_active = 0;
591: }
592:
593: /*
594: * Scan the wait queue, linking buffers onto drive queues.
595: * Note that these must be put at the front of the drive queue,
596: * lest we reorder I/O operations.
597: */
598: for (bp = mi->mi_wtab.av_back; bp != &mi->mi_wtab; bp = nextbp) {
599: nextbp = bp->av_back;
600: dp = &md->md_utab[minor(bp->b_dev) >> md->md_unitshift];
601: bp->av_forw = dp->b_actf;
602: if (dp->b_actf == NULL)
603: dp->b_actl = bp;
604: dp->b_actf = bp;
605: }
606: mi->mi_wtab.av_forw = mi->mi_wtab.av_back = &mi->mi_wtab;
607:
608: /*
609: * Scan for drives waiting for on line or status responses,
610: * and for drives with pending transfers. Put these on the
611: * controller queue, and mark the controller busy.
612: */
613: for (unit = 0, dp = md->md_utab; unit < md->md_nunits; unit++, dp++) {
614: ui = md->md_dinfo[unit];
615: if (ui == NULL || !ui->ui_alive || ui->ui_ctlr != mi->mi_ctlr)
616: continue;
617: ui->ui_flags &= ~(UNIT_HAVESTATUS | UNIT_ONLINE);
618: if ((ui->ui_flags & UNIT_REQUEUE) == 0 && dp->b_actf == NULL)
619: continue;
620: ui->ui_flags &= ~UNIT_REQUEUE;
621: APPEND(dp, mi->mi_tab, b_forw);
622: dp->b_active = 1;
623: mi->mi_tab->b_active = 1;
624: }
625:
626: #ifdef AVOID_EMULEX_BUG
627: /*
628: * ... and clear the index-to-buffer table.
629: */
630: for (unit = 0; unit < AEB_MAX_BP; unit++)
631: mi->mi_bp[unit] = 0;
632: #endif
633: }
634:
635:
636: /*
637: * MSCP error reporting
638: */
639:
640: /*
641: * Messages for the various subcodes.
642: */
643: static char unknown_msg[] = "unknown subcode";
644:
645: /*
646: * Subcodes for Success (0)
647: */
648: static char *succ_msgs[] = {
649: "normal", /* 0 */
650: "spin down ignored", /* 1 = Spin-Down Ignored */
651: "still connected", /* 2 = Still Connected */
652: unknown_msg,
653: "dup. unit #", /* 4 = Duplicate Unit Number */
654: unknown_msg,
655: unknown_msg,
656: unknown_msg,
657: "already online", /* 8 = Already Online */
658: unknown_msg,
659: unknown_msg,
660: unknown_msg,
661: unknown_msg,
662: unknown_msg,
663: unknown_msg,
664: unknown_msg,
665: "still online", /* 16 = Still Online */
666: };
667:
668: /*
669: * Subcodes for Invalid Command (1)
670: */
671: static char *icmd_msgs[] = {
672: "invalid msg length", /* 0 = Invalid Message Length */
673: };
674:
675: /*
676: * Subcodes for Command Aborted (2)
677: */
678: /* none known */
679:
680: /*
681: * Subcodes for Unit Offline (3)
682: */
683: static char *offl_msgs[] = {
684: "unknown drive", /* 0 = Unknown, or online to other ctlr */
685: "not mounted", /* 1 = Unmounted, or RUN/STOP at STOP */
686: "inoperative", /* 2 = Unit Inoperative */
687: unknown_msg,
688: "duplicate", /* 4 = Duplicate Unit Number */
689: unknown_msg,
690: unknown_msg,
691: unknown_msg,
692: "in diagnosis", /* 8 = Disabled by FS or diagnostic */
693: };
694:
695: /*
696: * Subcodes for Unit Available (4)
697: */
698: /* none known */
699:
700: /*
701: * Subcodes for Media Format Error (5)
702: */
703: static char *media_fmt_msgs[] = {
704: "fct unread - edc", /* 0 = FCT unreadable */
705: "invalid sector header",/* 1 = Invalid Sector Header */
706: "not 512 sectors", /* 2 = Not 512 Byte Sectors */
707: "not formatted", /* 3 = Not Formatted */
708: "fct ecc", /* 4 = FCT ECC */
709: };
710:
711: /*
712: * Subcodes for Write Protected (6)
713: * N.B.: Code 6 subcodes are 7 bits higher than other subcodes
714: * (i.e., bits 12-15).
715: */
716: static char *wrprot_msgs[] = {
717: unknown_msg,
718: "software", /* 1 = Software Write Protect */
719: "hardware", /* 2 = Hardware Write Protect */
720: };
721:
722: /*
723: * Subcodes for Compare Error (7)
724: */
725: /* none known */
726:
727: /*
728: * Subcodes for Data Error (8)
729: */
730: static char *data_msgs[] = {
731: "forced error", /* 0 = Forced Error (software) */
732: unknown_msg,
733: "header compare", /* 2 = Header Compare Error */
734: "sync timeout", /* 3 = Sync Timeout Error */
735: unknown_msg,
736: unknown_msg,
737: unknown_msg,
738: "uncorrectable ecc", /* 7 = Uncorrectable ECC */
739: "1 symbol ecc", /* 8 = 1 bit ECC */
740: "2 symbol ecc", /* 9 = 2 bit ECC */
741: "3 symbol ecc", /* 10 = 3 bit ECC */
742: "4 symbol ecc", /* 11 = 4 bit ECC */
743: "5 symbol ecc", /* 12 = 5 bit ECC */
744: "6 symbol ecc", /* 13 = 6 bit ECC */
745: "7 symbol ecc", /* 14 = 7 bit ECC */
746: "8 symbol ecc", /* 15 = 8 bit ECC */
747: };
748:
749: /*
750: * Subcodes for Host Buffer Access Error (9)
751: */
752: static char *host_buffer_msgs[] = {
753: unknown_msg,
754: "odd xfer addr", /* 1 = Odd Transfer Address */
755: "odd xfer count", /* 2 = Odd Transfer Count */
756: "non-exist. memory", /* 3 = Non-Existent Memory */
757: "memory parity", /* 4 = Memory Parity Error */
758: };
759:
760: /*
761: * Subcodes for Controller Error (10)
762: */
763: static char *cntlr_msgs[] = {
764: unknown_msg,
765: "serdes overrun", /* 1 = Serialiser/Deserialiser Overrun */
766: "edc", /* 2 = Error Detection Code? */
767: "inconsistant internal data struct",/* 3 = Internal Error */
768: };
769:
770: /*
771: * Subcodes for Drive Error (11)
772: */
773: static char *drive_msgs[] = {
774: unknown_msg,
775: "sdi command timeout", /* 1 = SDI Command Timeout */
776: "ctlr detected protocol",/* 2 = Controller Detected Protocol Error */
777: "positioner", /* 3 = Positioner Error */
778: "lost rd/wr ready", /* 4 = Lost R/W Ready Error */
779: "drive clock dropout", /* 5 = Lost Drive Clock */
780: "lost recvr ready", /* 6 = Lost Receiver Ready */
781: "drive detected error", /* 7 = Drive Error */
782: "ctlr detected pulse or parity",/* 8 = Pulse or Parity Error */
783: };
784:
785: /*
786: * The following table correlates message codes with the
787: * decoding strings.
788: */
789: struct code_decode {
790: char *cdc_msg;
791: int cdc_nsubcodes;
792: char **cdc_submsgs;
793: } code_decode[] = {
794: #define SC(m) sizeof (m) / sizeof (m[0]), m
795: "success", SC(succ_msgs),
796: "invalid command", SC(icmd_msgs),
797: "command aborted", 0, 0,
798: "unit offline", SC(offl_msgs),
799: "unit available", 0, 0,
800: "media format error", SC(media_fmt_msgs),
801: "write protected", SC(wrprot_msgs),
802: "compare error", 0, 0,
803: "data error", SC(data_msgs),
804: "host buffer access error", SC(host_buffer_msgs),
805: "controller error", SC(cntlr_msgs),
806: "drive error", SC(drive_msgs),
807: #undef SC
808: };
809:
810: /*
811: * Print the decoded error event from an MSCP error datagram.
812: */
813: mscp_printevent(mp)
814: struct mscp *mp;
815: {
816: register int event = mp->mscp_event;
817: register struct code_decode *cdc;
818: int c, sc;
819: char *cm, *scm;
820:
821: /*
822: * The code is the lower six bits of the event number (aka
823: * status). If that is 6 (write protect), the subcode is in
824: * bits 12-15; otherwise, it is in bits 5-11.
825: * I WONDER WHAT THE OTHER BITS ARE FOR. IT SURE WOULD BE
826: * NICE IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
827: */
828: c = event & M_ST_MASK;
829: sc = (c != 6 ? event >> 5 : event >> 12) & 0x7ff;
830: if (c >= sizeof code_decode / sizeof code_decode[0])
831: cm = "- unknown code", scm = "??";
832: else {
833: cdc = &code_decode[c];
834: cm = cdc->cdc_msg;
835: if (sc >= cdc->cdc_nsubcodes)
836: scm = unknown_msg;
837: else
838: scm = cdc->cdc_submsgs[sc];
839: }
840: printf(" %s (%s) (code %d, subcode %d)\n", cm, scm, c, sc);
841: }
842:
843: /*
844: * Print the code and logical block number for an error packet.
845: * THIS IS PROBABLY PECULIAR TO DISK DRIVES. IT SURE WOULD BE
846: * NICE IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
847: */
848: mscp_decodeerror(name, ctlr, mp)
849: char *name;
850: int ctlr;
851: register struct mscp *mp;
852: {
853: /*
854: * For bad blocks, mp->mscp_erd.erd_hdr identifies a code and
855: * the logical block number. Code 0 is a regular block; code 6
856: * is a replacement block. The remaining codes are currently
857: * undefined. The code is in the upper four bits of the header
858: * (bits 0-27 are the lbn).
859: */
860: int issoft = mp->mscp_flags & (M_LF_SUCC | M_LF_CONT);
861: static char *codemsg[16] = {
862: "lbn", "code 1", "code 2", "code 3",
863: "code 4", "code 5", "rbn", "code 7",
864: "code 8", "code 9", "code 10", "code 11",
865: "code 12", "code 13", "code 14", "code 15"
866: };
867: #define BADCODE(h) (codemsg[(unsigned)(h) >> 28])
868: #define BADLBN(h) ((h) & 0xfffffff)
869:
870: printf("%s%d: %s error datagram%s:", name, ctlr,
871: issoft ? "soft" : "hard",
872: mp->mscp_flags & M_LF_CONT ? " (continuing)" : "");
873: switch (mp->mscp_format & 0377) {
874:
875: case M_FM_CTLRERR: /* controller error */
876: break;
877:
878: case M_FM_BUSADDR: /* host memory access error */
879: printf(" memory addr 0x%x:", mp->mscp_erd.erd_busaddr);
880: break;
881:
882: case M_FM_DISKTRN:
883: printf(" unit %d: level %d retry %d, %s %d:",
884: mp->mscp_unit,
885: mp->mscp_erd.erd_level, mp->mscp_erd.erd_retry,
886: BADCODE(mp->mscp_erd.erd_hdr),
887: BADLBN(mp->mscp_erd.erd_hdr));
888: break;
889:
890: case M_FM_SDI:
891: printf(" unit %d: %s %d:", mp->mscp_unit,
892: BADCODE(mp->mscp_erd.erd_hdr),
893: BADLBN(mp->mscp_erd.erd_hdr));
894: break;
895:
896: case M_FM_SMLDSK:
897: printf(" unit %d: small disk error, cyl %d:",
898: mp->mscp_unit, mp->mscp_erd.erd_sdecyl);
899: break;
900:
901: default:
902: printf(" unit %d: unknown error, format 0x%x:",
903: mp->mscp_unit, mp->mscp_format);
904: }
905: mscp_printevent(mp);
906: #undef BADCODE
907: #undef BADLBN
908: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.