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