![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba|
Return to ts.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)ts.c 7.13 (Berkeley) 7/1/90 ! 7: */ ! 8: ! 9: #include "ts.h" ! 10: #if NTS > 0 ! 11: /* ! 12: * TS11 tape driver ! 13: * ! 14: * NB: This driver takes advantage of the fact that there is only one ! 15: * drive per controller. ! 16: * ! 17: * TODO: ! 18: * test dump code ! 19: */ ! 20: #include "param.h" ! 21: #include "systm.h" ! 22: #include "buf.h" ! 23: #include "conf.h" ! 24: #include "errno.h" ! 25: #include "file.h" ! 26: #include "map.h" ! 27: #include "vm.h" ! 28: #include "ioctl.h" ! 29: #include "mtio.h" ! 30: #include "cmap.h" ! 31: #include "uio.h" ! 32: #include "syslog.h" ! 33: #include "tprintf.h" ! 34: ! 35: #include "machine/pte.h" ! 36: #include "../vax/cpu.h" ! 37: #include "ubareg.h" ! 38: #include "ubavar.h" ! 39: #include "tsreg.h" ! 40: ! 41: /* ! 42: * There is a ctsbuf per tape controller. ! 43: * It is used as the token to pass to the internal routines ! 44: * to execute tape ioctls. ! 45: * In particular, when the tape is rewinding on close we release ! 46: * the user process but any further attempts to use the tape drive ! 47: * before the rewind completes will hang waiting for ctsbuf. ! 48: */ ! 49: struct buf ctsbuf[NTS]; ! 50: ! 51: /* ! 52: * Driver unibus interface routines and variables. ! 53: */ ! 54: int tsprobe(), tsslave(), tsattach(), tsdgo(), tsintr(); ! 55: struct uba_ctlr *tsminfo[NTS]; ! 56: struct uba_device *tsdinfo[NTS]; ! 57: struct buf tsutab[NTS]; ! 58: u_short tsstd[] = { 0772520, 0 }; ! 59: /* need all these even though controller == drive */ ! 60: struct uba_driver zsdriver = ! 61: { tsprobe, tsslave, tsattach, tsdgo, tsstd, "ts", tsdinfo, "zs", tsminfo }; ! 62: ! 63: /* bits in minor device */ ! 64: #define TSUNIT(dev) (minor(dev)&03) ! 65: #define T_NOREWIND 04 ! 66: #define T_1600BPI 010 ! 67: ! 68: #define INF (daddr_t)1000000L ! 69: ! 70: /* ! 71: * Software state per tape transport. ! 72: * Also contains hardware state in message packets. ! 73: * ! 74: * 1. A tape drive is a unique-open device; we refuse opens when it is already. ! 75: * 2. We keep track of the current position on a block tape and seek ! 76: * before operations by forward/back spacing if necessary. ! 77: * 3. We remember if the last operation was a write on a tape, so if a tape ! 78: * is open read write and the last thing done is a write we can ! 79: * write a standard end of tape mark (two eofs). ! 80: * 4. We remember the status registers after the last command, using ! 81: * then internally and returning them to the SENSE ioctl. ! 82: */ ! 83: struct ts_tsdata { /* data shared with ts11 controller */ ! 84: struct ts_cmd t_cmd; /* the command packet (must be first) */ ! 85: struct ts_sts t_sts; /* status packet, for returned status */ ! 86: struct ts_char t_char; /* characteristics packet */ ! 87: }; ! 88: struct ts_softc { ! 89: char sc_openf; /* lock against multiple opens */ ! 90: char sc_lastiow; /* last op was a write */ ! 91: short sc_resid; /* copy of last bc */ ! 92: daddr_t sc_blkno; /* block number, for block device tape */ ! 93: daddr_t sc_nxrec; /* position of end of tape, if known */ ! 94: struct ts_tsdata sc_ts;/* command and status packets */ ! 95: struct ts_tsdata *sc_ubaddr; /* Unibus address of tsdata structure */ ! 96: u_short sc_uba; /* Unibus addr of cmd pkt for tsdb */ ! 97: short sc_density; /* value |'ed into char_mode for TC13 density */ ! 98: tpr_t sc_tpr; /* tprintf handle */ ! 99: int sc_blks; /* number of I/O operations since open */ ! 100: int sc_softerrs; /* number of soft I/O errors since open */ ! 101: } ts_softc[NTS]; ! 102: ! 103: /* ! 104: * States for um->um_tab.b_active, the per controller state flag. ! 105: * This is used to sequence control in the driver. ! 106: */ ! 107: #define SSEEK 1 /* seeking */ ! 108: #define SIO 2 /* doing seq i/o */ ! 109: #define SCOM 3 /* sending control command */ ! 110: #define SREW 4 /* sending a drive rewind */ ! 111: ! 112: /* ! 113: * Determine if there is a controller for ! 114: * a ts at address reg. Our goal is to make the ! 115: * device interrupt. ! 116: */ ! 117: /*ARGSUSED*/ ! 118: tsprobe(reg, ctlr, um) ! 119: caddr_t reg; ! 120: int ctlr; ! 121: struct uba_ctlr *um; ! 122: { ! 123: register int br, cvec; /* must be r11,r10; value-result */ ! 124: register struct tsdevice *addr = (struct tsdevice *)reg; ! 125: register struct ts_softc *sc; ! 126: register int i; ! 127: int a; ! 128: ! 129: #ifdef lint ! 130: br = 0; cvec = br; br = cvec; ! 131: tsintr(0); ! 132: #endif ! 133: addr->tssr = 0; /* initialize subsystem */ ! 134: DELAY(100); ! 135: if ((addr->tssr & TS_NBA) == 0) ! 136: return (0); ! 137: ! 138: /* ! 139: * Make it interrupt. ! 140: * TS_SETCHR|TS_IE alone refuses to interrupt for me. ! 141: */ ! 142: sc = &ts_softc[ctlr]; ! 143: tsmap(sc, numuba, &a); ! 144: i = (int)&sc->sc_ubaddr->t_char; ! 145: sc->sc_ts.t_cmd.c_loba = i; ! 146: sc->sc_ts.t_cmd.c_hiba = (i >> 16) & 3; ! 147: sc->sc_ts.t_cmd.c_size = sizeof(struct ts_char); ! 148: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_SETCHR; ! 149: sc->sc_ts.t_char.char_addr = (int)&sc->sc_ubaddr->t_sts; ! 150: sc->sc_ts.t_char.char_size = sizeof(struct ts_sts); ! 151: sc->sc_ts.t_char.char_mode = 0; /* mode is unimportant */ ! 152: addr->tsdb = sc->sc_uba; ! 153: DELAY(20000); ! 154: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_CVC | TS_IE | TS_SENSE; ! 155: sc->sc_ts.t_cmd.c_repcnt = 1; ! 156: addr->tsdb = sc->sc_uba; ! 157: DELAY(20000); ! 158: /* should have interrupted by now */ ! 159: ! 160: if (cvec == 0 || cvec == 0x200) /* no interrupt */ ! 161: ubarelse(numuba, &a); ! 162: ! 163: return (sizeof (struct tsdevice)); ! 164: } ! 165: ! 166: /* ! 167: * Map in the command, status, and characteristics packet. We ! 168: * make them contiguous to keep overhead down. This also sets ! 169: * sc_uba (which then never changes). ! 170: */ ! 171: tsmap(sc, uban, a) ! 172: register struct ts_softc *sc; ! 173: int uban, *a; ! 174: { ! 175: register int i; ! 176: ! 177: i = uballoc(uban, (caddr_t)&sc->sc_ts, sizeof(sc->sc_ts), 0); ! 178: if (a != NULL) ! 179: *a = i; ! 180: i = UBAI_ADDR(i); ! 181: sc->sc_ubaddr = (struct ts_tsdata *)i; ! 182: /* ! 183: * Note that i == the Unibus address of the command packet, ! 184: * and that it is a multiple of 4 (guaranteed by the compiler). ! 185: */ ! 186: sc->sc_uba = i + ((i >> 16) & 3); ! 187: } ! 188: ! 189: /* ! 190: * TS11 only supports one drive per controller; ! 191: * check for ui_slave == 0. ! 192: */ ! 193: /*ARGSUSED*/ ! 194: tsslave(ui, reg) ! 195: struct uba_device *ui; ! 196: caddr_t reg; ! 197: { ! 198: ! 199: return (ui->ui_slave == 0); /* non-zero slave not allowed */ ! 200: } ! 201: ! 202: /* ! 203: * Record attachment of the unit to the controller. ! 204: */ ! 205: /*ARGSUSED*/ ! 206: tsattach(ui) ! 207: struct uba_device *ui; ! 208: { ! 209: ! 210: /* void */ ! 211: } ! 212: ! 213: /* ! 214: * Open the device. Tapes are unique open ! 215: * devices, so we refuse if it is already open. ! 216: */ ! 217: tsopen(dev, flag) ! 218: dev_t dev; ! 219: int flag; ! 220: { ! 221: register int tsunit = TSUNIT(dev); ! 222: register struct uba_device *ui; ! 223: register struct ts_softc *sc; ! 224: ! 225: if (tsunit >= NTS || (ui = tsdinfo[tsunit]) == 0 || ui->ui_alive == 0) ! 226: return (ENXIO); ! 227: if ((sc = &ts_softc[ui->ui_ctlr])->sc_openf) ! 228: return (EBUSY); ! 229: sc->sc_openf = 1; ! 230: sc->sc_density = (minor(dev) & T_1600BPI) ? TS_NRZI : 0; ! 231: tscommand(dev, TS_SENSE, 1); ! 232: if (ctsbuf[tsunit].b_flags & B_ERROR) ! 233: /* ! 234: * Try it again in case it went off-line ! 235: */ ! 236: tscommand(dev, TS_SENSE, 1); ! 237: if (tsinit(ui->ui_ctlr)) { ! 238: sc->sc_openf = 0; ! 239: return (ENXIO); ! 240: } ! 241: if ((sc->sc_ts.t_sts.s_xs0&TS_ONL) == 0) { ! 242: sc->sc_openf = 0; ! 243: uprintf("ts%d: not online\n", tsunit); ! 244: return (EIO); ! 245: } ! 246: if ((flag&FWRITE) && (sc->sc_ts.t_sts.s_xs0&TS_WLK)) { ! 247: sc->sc_openf = 0; ! 248: uprintf("ts%d: no write ring\n", tsunit); ! 249: return (EIO); ! 250: } ! 251: sc->sc_blkno = (daddr_t)0; ! 252: sc->sc_nxrec = INF; ! 253: sc->sc_lastiow = 0; ! 254: sc->sc_blks = 0; ! 255: sc->sc_softerrs = 0; ! 256: sc->sc_tpr = tprintf_open(); ! 257: return (0); ! 258: } ! 259: ! 260: /* ! 261: * Close tape device. ! 262: * ! 263: * If tape was open for writing or last operation was ! 264: * a write, then write two EOF's and backspace over the last one. ! 265: * Unless this is a non-rewinding special file, rewind the tape. ! 266: * Make the tape available to others. ! 267: */ ! 268: tsclose(dev, flag) ! 269: register dev_t dev; ! 270: register int flag; ! 271: { ! 272: register struct ts_softc *sc = &ts_softc[TSUNIT(dev)]; ! 273: ! 274: if (flag == FWRITE || (flag&FWRITE) && sc->sc_lastiow) { ! 275: tscommand(dev, TS_WEOF, 1); ! 276: tscommand(dev, TS_WEOF, 1); ! 277: tscommand(dev, TS_SREV, 1); ! 278: } ! 279: if ((minor(dev)&T_NOREWIND) == 0) ! 280: /* ! 281: * 0 count means don't hang waiting for rewind complete ! 282: * rather ctsbuf stays busy until the operation completes ! 283: * preventing further opens from completing by ! 284: * preventing a TS_SENSE from completing. ! 285: */ ! 286: tscommand(dev, TS_REW, 0); ! 287: if (sc->sc_blks > 100 && sc->sc_softerrs > sc->sc_blks / 100) ! 288: log(LOG_INFO, "ts%d: %d soft errors in %d blocks\n", ! 289: TSUNIT(dev), sc->sc_softerrs, sc->sc_blks); ! 290: tprintf_close(sc->sc_tpr); ! 291: sc->sc_openf = 0; ! 292: return (0); ! 293: } ! 294: ! 295: /* ! 296: * Initialize a TS11. Set device characteristics. ! 297: */ ! 298: tsinit(ctlr) ! 299: register int ctlr; ! 300: { ! 301: register struct ts_softc *sc = &ts_softc[ctlr]; ! 302: register struct uba_ctlr *um = tsminfo[ctlr]; ! 303: register struct tsdevice *addr = (struct tsdevice *)um->um_addr; ! 304: register int i; ! 305: ! 306: if (addr->tssr & (TS_NBA|TS_OFL) || sc->sc_ts.t_sts.s_xs0 & TS_BOT) { ! 307: addr->tssr = 0; /* subsystem initialize */ ! 308: tswait(addr); ! 309: i = (int)&sc->sc_ubaddr->t_char; ! 310: sc->sc_ts.t_cmd.c_loba = i; ! 311: sc->sc_ts.t_cmd.c_hiba = (i >> 16) & 3; ! 312: sc->sc_ts.t_cmd.c_size = sizeof(struct ts_char); ! 313: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_CVC | TS_SETCHR; ! 314: sc->sc_ts.t_char.char_addr = (int)&sc->sc_ubaddr->t_sts; ! 315: sc->sc_ts.t_char.char_size = sizeof(struct ts_sts); ! 316: sc->sc_ts.t_char.char_mode = TS_ESS | TS_EAI | TS_ERI | ! 317: /* TS_ENB | */ sc->sc_density; ! 318: addr->tsdb = sc->sc_uba; ! 319: tswait(addr); ! 320: if (addr->tssr & TS_NBA) ! 321: return(1); ! 322: } ! 323: return(0); ! 324: } ! 325: ! 326: /* ! 327: * Execute a command on the tape drive ! 328: * a specified number of times. ! 329: */ ! 330: tscommand(dev, com, count) ! 331: dev_t dev; ! 332: int com, count; ! 333: { ! 334: register struct buf *bp; ! 335: register int s; ! 336: int didsleep = 0; ! 337: ! 338: bp = &ctsbuf[TSUNIT(dev)]; ! 339: s = spl5(); ! 340: while (bp->b_flags&B_BUSY) { ! 341: /* ! 342: * This special check is because B_BUSY never ! 343: * gets cleared in the non-waiting rewind case. ! 344: */ ! 345: if (bp->b_repcnt == 0 && (bp->b_flags&B_DONE)) ! 346: break; ! 347: bp->b_flags |= B_WANTED; ! 348: sleep((caddr_t)bp, PRIBIO); ! 349: didsleep = 1; ! 350: } ! 351: bp->b_flags = B_BUSY|B_READ; ! 352: splx(s); ! 353: if (didsleep) ! 354: (void) tsinit(tsdinfo[TSUNIT(dev)]->ui_ctlr); ! 355: bp->b_dev = dev; ! 356: bp->b_repcnt = count; ! 357: bp->b_command = com; ! 358: bp->b_blkno = 0; ! 359: tsstrategy(bp); ! 360: /* ! 361: * In case of rewind from close, don't wait. ! 362: * This is the only case where count can be 0. ! 363: */ ! 364: if (count == 0) ! 365: return; ! 366: biowait(bp); ! 367: if (bp->b_flags&B_WANTED) ! 368: wakeup((caddr_t)bp); ! 369: bp->b_flags &= B_ERROR; ! 370: } ! 371: ! 372: /* ! 373: * Queue a tape operation. ! 374: */ ! 375: tsstrategy(bp) ! 376: register struct buf *bp; ! 377: { ! 378: register int tsunit = TSUNIT(bp->b_dev); ! 379: register struct uba_ctlr *um; ! 380: register struct buf *dp; ! 381: int s; ! 382: ! 383: /* ! 384: * Put transfer at end of controller queue ! 385: */ ! 386: bp->av_forw = NULL; ! 387: um = tsdinfo[tsunit]->ui_mi; ! 388: dp = &tsutab[tsunit]; ! 389: s = spl5(); ! 390: if (dp->b_actf == NULL) ! 391: dp->b_actf = bp; ! 392: else ! 393: dp->b_actl->av_forw = bp; ! 394: dp->b_actl = bp; ! 395: um->um_tab.b_actf = um->um_tab.b_actl = dp; ! 396: /* ! 397: * If the controller is not busy, get ! 398: * it going. ! 399: */ ! 400: if (um->um_tab.b_active == 0) ! 401: tsstart(um); ! 402: splx(s); ! 403: } ! 404: ! 405: /* ! 406: * Start activity on a ts controller. ! 407: */ ! 408: tsstart(um) ! 409: register struct uba_ctlr *um; ! 410: { ! 411: register struct buf *bp; ! 412: register struct tsdevice *addr = (struct tsdevice *)um->um_addr; ! 413: register struct ts_softc *sc; ! 414: register struct uba_device *ui; ! 415: register int tsunit; ! 416: int cmd; ! 417: daddr_t blkno; ! 418: ! 419: /* ! 420: * Start the controller if there is something for it to do. ! 421: */ ! 422: loop: ! 423: if ((bp = um->um_tab.b_actf->b_actf) == NULL) { ! 424: um->um_tab.b_active = 0; ! 425: return; ! 426: } ! 427: tsunit = TSUNIT(bp->b_dev); ! 428: ui = tsdinfo[tsunit]; ! 429: sc = &ts_softc[tsunit]; ! 430: /* ! 431: * Default is that last command was NOT a write command; ! 432: * if we finish a write command we will notice this in tsintr(). ! 433: */ ! 434: sc->sc_lastiow = 0; ! 435: if (sc->sc_openf < 0 || (addr->tssr&TS_OFL)) { ! 436: /* ! 437: * Have had a hard error on a non-raw tape ! 438: * or the tape unit is now unavailable ! 439: * (e.g. taken off line). ! 440: */ ! 441: bp->b_flags |= B_ERROR; ! 442: goto next; ! 443: } ! 444: if (bp == &ctsbuf[tsunit]) { ! 445: /* ! 446: * Execute control operation with the specified count. ! 447: */ ! 448: um->um_tab.b_active = ! 449: bp->b_command == TS_REW ? SREW : SCOM; ! 450: sc->sc_ts.t_cmd.c_repcnt = bp->b_repcnt; ! 451: goto dobpcmd; ! 452: } ! 453: /* ! 454: * For raw I/O, save the current block ! 455: * number in case we have to retry. ! 456: */ ! 457: if (bp->b_flags & B_RAW) { ! 458: if (um->um_tab.b_errcnt == 0) ! 459: sc->sc_blkno = bdbtofsb(bp->b_blkno); ! 460: } else { ! 461: /* ! 462: * Handle boundary cases for operation ! 463: * on non-raw tapes. ! 464: */ ! 465: if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) { ! 466: /* ! 467: * Can't read past known end-of-file. ! 468: */ ! 469: bp->b_flags |= B_ERROR; ! 470: bp->b_error = ENXIO; ! 471: goto next; ! 472: } ! 473: if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec && ! 474: bp->b_flags&B_READ) { ! 475: /* ! 476: * Reading at end of file returns 0 bytes. ! 477: */ ! 478: bp->b_resid = bp->b_bcount; ! 479: clrbuf(bp); ! 480: goto next; ! 481: } ! 482: if ((bp->b_flags&B_READ) == 0) ! 483: /* ! 484: * Writing sets EOF ! 485: */ ! 486: sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1; ! 487: } ! 488: ! 489: /* ! 490: * If the data transfer command is in the correct place, ! 491: * set up all the registers except the csr, and give ! 492: * control over to the UNIBUS adapter routines, to ! 493: * wait for resources to start the i/o. ! 494: */ ! 495: if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) { ! 496: sc->sc_ts.t_cmd.c_size = bp->b_bcount; ! 497: if ((bp->b_flags&B_READ) == 0) ! 498: cmd = TS_WCOM; ! 499: else ! 500: cmd = TS_RCOM; ! 501: if (um->um_tab.b_errcnt) ! 502: cmd |= TS_RETRY; ! 503: um->um_tab.b_active = SIO; ! 504: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_CVC | TS_IE | cmd; ! 505: (void) ubago(ui); ! 506: return; ! 507: } ! 508: /* ! 509: * Tape positioned incorrectly; ! 510: * set to seek forwards or backwards to the correct spot. ! 511: * This happens for raw tapes only on error retries. ! 512: */ ! 513: um->um_tab.b_active = SSEEK; ! 514: if (blkno < bdbtofsb(bp->b_blkno)) { ! 515: bp->b_command = TS_SFORW; ! 516: sc->sc_ts.t_cmd.c_repcnt = bdbtofsb(bp->b_blkno) - blkno; ! 517: } else { ! 518: bp->b_command = TS_SREV; ! 519: sc->sc_ts.t_cmd.c_repcnt = blkno - bdbtofsb(bp->b_blkno); ! 520: } ! 521: dobpcmd: ! 522: /* ! 523: * Do the command in bp. ! 524: */ ! 525: sc->sc_ts.t_cmd.c_cmd = TS_ACK | TS_CVC | TS_IE | bp->b_command; ! 526: addr->tsdb = sc->sc_uba; ! 527: return; ! 528: ! 529: next: ! 530: /* ! 531: * Done with this operation due to error or ! 532: * the fact that it doesn't do anything. ! 533: * Release UBA resources (if any), dequeue ! 534: * the transfer and continue processing this slave. ! 535: */ ! 536: if (um->um_ubinfo) ! 537: ubadone(um); ! 538: um->um_tab.b_errcnt = 0; ! 539: um->um_tab.b_actf->b_actf = bp->av_forw; ! 540: biodone(bp); ! 541: goto loop; ! 542: } ! 543: ! 544: /* ! 545: * The UNIBUS resources we needed have been ! 546: * allocated to us; start the device. ! 547: */ ! 548: tsdgo(um) ! 549: register struct uba_ctlr *um; ! 550: { ! 551: register struct ts_softc *sc = &ts_softc[um->um_ctlr]; ! 552: register int i; ! 553: ! 554: /* ! 555: * The uba code uses byte-offset mode if using bdp; ! 556: * mask off the low bit here. ! 557: */ ! 558: i = UBAI_ADDR(um->um_ubinfo); ! 559: if (UBAI_BDP(um->um_ubinfo)) ! 560: i &= ~1; ! 561: sc->sc_ts.t_cmd.c_loba = i; ! 562: sc->sc_ts.t_cmd.c_hiba = (i >> 16) & 3; ! 563: ((struct tsdevice *)um->um_addr)->tsdb = sc->sc_uba; ! 564: } ! 565: ! 566: /* ! 567: * Ts interrupt routine. ! 568: */ ! 569: /*ARGSUSED*/ ! 570: tsintr(tsunit) ! 571: register int tsunit; ! 572: { ! 573: register struct buf *bp; ! 574: register struct uba_ctlr *um; ! 575: register struct tsdevice *addr; ! 576: register struct ts_softc *sc; ! 577: register int state; ! 578: ! 579: #ifdef QBA ! 580: (void) spl5(); ! 581: #endif ! 582: um = tsdinfo[tsunit]->ui_mi; ! 583: if ((bp = um->um_tab.b_actf->b_actf) == NULL) ! 584: return; ! 585: addr = (struct tsdevice *)um->um_addr; ! 586: /* ! 587: * If last command was a rewind, and tape is still ! 588: * rewinding, wait for the rewind complete interrupt. ! 589: * ! 590: * SHOULD NEVER GET AN INTERRUPT IN THIS STATE. ! 591: */ ! 592: if (um->um_tab.b_active == SREW) { ! 593: um->um_tab.b_active = SCOM; ! 594: if ((addr->tssr&TS_SSR) == 0) ! 595: return; ! 596: } ! 597: /* ! 598: * An operation completed... record status ! 599: */ ! 600: sc = &ts_softc[um->um_ctlr]; ! 601: if ((bp->b_flags & B_READ) == 0) ! 602: sc->sc_lastiow = 1; ! 603: state = um->um_tab.b_active; ! 604: /* ! 605: * Check for errors. ! 606: */ ! 607: if (addr->tssr&TS_SC) { ! 608: switch (addr->tssr & TS_TC) { ! 609: case TS_UNREC: /* unrecoverable */ ! 610: case TS_FATAL: /* fatal error */ ! 611: case TS_RECNM: /* recoverable, no motion */ ! 612: break; ! 613: case TS_ATTN: /* attention */ ! 614: if (sc->sc_ts.t_sts.s_xs0 & TS_VCK) { ! 615: /* volume check - may have changed tapes */ ! 616: bp->b_flags |= B_ERROR; ! 617: goto ignoreerr; ! 618: } ! 619: break; ! 620: ! 621: case TS_SUCC: /* success termination */ ! 622: printf("ts%d: success\n", tsunit); ! 623: goto ignoreerr; ! 624: ! 625: case TS_ALERT: /* tape status alert */ ! 626: /* ! 627: * If we hit the end of the tape file, ! 628: * update our position. ! 629: */ ! 630: if (sc->sc_ts.t_sts.s_xs0 & (TS_TMK|TS_EOT)) { ! 631: tsseteof(bp); /* set blkno and nxrec */ ! 632: state = SCOM; /* force completion */ ! 633: /* ! 634: * Stuff bc so it will be unstuffed correctly ! 635: * later to get resid. ! 636: */ ! 637: sc->sc_ts.t_sts.s_rbpcr = bp->b_bcount; ! 638: goto opdone; ! 639: } ! 640: /* ! 641: * If we were reading raw tape and the record was too ! 642: * long or too short, we don't consider this an error. ! 643: */ ! 644: if ((bp->b_flags & (B_READ|B_RAW)) == (B_READ|B_RAW) && ! 645: sc->sc_ts.t_sts.s_xs0&(TS_RLS|TS_RLL)) ! 646: goto ignoreerr; ! 647: /* FALLTHROUGH */ ! 648: ! 649: case TS_RECOV: /* recoverable, tape moved */ ! 650: /* ! 651: * If this was an i/o operation retry up to 8 times. ! 652: */ ! 653: if (state == SIO) { ! 654: if (++um->um_tab.b_errcnt < 7) { ! 655: ubadone(um); ! 656: goto opcont; ! 657: } else ! 658: sc->sc_blkno++; ! 659: } else { ! 660: /* ! 661: * Non-i/o errors on non-raw tape ! 662: * cause it to close. ! 663: */ ! 664: if ((bp->b_flags&B_RAW) == 0 && ! 665: sc->sc_openf > 0) ! 666: sc->sc_openf = -1; ! 667: } ! 668: break; ! 669: ! 670: case TS_REJECT: /* function reject */ ! 671: if (state == SIO && sc->sc_ts.t_sts.s_xs0 & TS_WLE) ! 672: tprintf(sc->sc_tpr, "ts%d: write locked\n", ! 673: tsunit); ! 674: if ((sc->sc_ts.t_sts.s_xs0 & TS_ONL) == 0) ! 675: tprintf(sc->sc_tpr, "ts%d: offline\n", ! 676: tsunit); ! 677: break; ! 678: } ! 679: /* ! 680: * Couldn't recover error ! 681: */ ! 682: tprintf(sc->sc_tpr, "ts%d: hard error bn%d tssr=%b xs0=%b", ! 683: tsunit, bp->b_blkno, addr->tssr, TSSR_BITS, ! 684: sc->sc_ts.t_sts.s_xs0, TSXS0_BITS); ! 685: if (sc->sc_ts.t_sts.s_xs1) ! 686: tprintf(sc->sc_tpr, " xs1=%b", sc->sc_ts.t_sts.s_xs1, ! 687: TSXS1_BITS); ! 688: if (sc->sc_ts.t_sts.s_xs2) ! 689: tprintf(sc->sc_tpr, " xs2=%b", sc->sc_ts.t_sts.s_xs2, ! 690: TSXS2_BITS); ! 691: if (sc->sc_ts.t_sts.s_xs3) ! 692: tprintf(sc->sc_tpr, " xs3=%b", sc->sc_ts.t_sts.s_xs3, ! 693: TSXS3_BITS); ! 694: tprintf(sc->sc_tpr, "\n"); ! 695: bp->b_flags |= B_ERROR; ! 696: goto opdone; ! 697: } ! 698: /* ! 699: * Advance tape control FSM. ! 700: */ ! 701: ignoreerr: ! 702: switch (state) { ! 703: ! 704: case SIO: ! 705: /* ! 706: * Read/write increments tape block number ! 707: */ ! 708: sc->sc_blkno++; ! 709: sc->sc_blks++; ! 710: if (um->um_tab.b_errcnt) ! 711: sc->sc_softerrs++; ! 712: goto opdone; ! 713: ! 714: case SCOM: ! 715: /* ! 716: * For forward/backward space record update current position. ! 717: */ ! 718: if (bp == &ctsbuf[tsunit]) ! 719: switch ((int)bp->b_command) { ! 720: ! 721: case TS_SFORW: ! 722: sc->sc_blkno += bp->b_repcnt; ! 723: break; ! 724: ! 725: case TS_SREV: ! 726: sc->sc_blkno -= bp->b_repcnt; ! 727: break; ! 728: } ! 729: goto opdone; ! 730: ! 731: case SSEEK: ! 732: sc->sc_blkno = bdbtofsb(bp->b_blkno); ! 733: goto opcont; ! 734: ! 735: default: ! 736: panic("tsintr"); ! 737: } ! 738: opdone: ! 739: /* ! 740: * Reset error count and remove ! 741: * from device queue. ! 742: */ ! 743: um->um_tab.b_errcnt = 0; ! 744: um->um_tab.b_actf->b_actf = bp->av_forw; ! 745: bp->b_resid = sc->sc_ts.t_sts.s_rbpcr; ! 746: ubadone(um); ! 747: biodone(bp); ! 748: if (um->um_tab.b_actf->b_actf == 0) { ! 749: um->um_tab.b_active = 0; ! 750: return; ! 751: } ! 752: opcont: ! 753: tsstart(um); ! 754: } ! 755: ! 756: tsseteof(bp) ! 757: register struct buf *bp; ! 758: { ! 759: register int tsunit = TSUNIT(bp->b_dev); ! 760: register struct ts_softc *sc = &ts_softc[tsdinfo[tsunit]->ui_ctlr]; ! 761: ! 762: if (bp == &ctsbuf[tsunit]) { ! 763: if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) { ! 764: /* reversing */ ! 765: sc->sc_nxrec = bdbtofsb(bp->b_blkno) - ! 766: sc->sc_ts.t_sts.s_rbpcr; ! 767: sc->sc_blkno = sc->sc_nxrec; ! 768: } else { ! 769: /* spacing forward */ ! 770: sc->sc_blkno = bdbtofsb(bp->b_blkno) + ! 771: sc->sc_ts.t_sts.s_rbpcr; ! 772: sc->sc_nxrec = sc->sc_blkno - 1; ! 773: } ! 774: return; ! 775: } ! 776: /* eof on read */ ! 777: sc->sc_nxrec = bdbtofsb(bp->b_blkno); ! 778: } ! 779: ! 780: tsreset(uban) ! 781: int uban; ! 782: { ! 783: register struct uba_ctlr *um; ! 784: register struct uba_device *ui; ! 785: register int ts11, i; ! 786: ! 787: for (ts11 = 0; ts11 < NTS; ts11++) { ! 788: if ((um = tsminfo[ts11]) == 0 || um->um_alive == 0 || ! 789: um->um_ubanum != uban) ! 790: continue; ! 791: printf(" ts%d", ts11); ! 792: um->um_tab.b_active = 0; ! 793: um->um_tab.b_actf = um->um_tab.b_actl = 0; ! 794: if (ts_softc[ts11].sc_openf > 0) ! 795: ts_softc[ts11].sc_openf = -1; ! 796: if (um->um_ubinfo) { ! 797: printf("<%d>", UBAI_BDP(um->um_ubinfo)); ! 798: um->um_ubinfo = 0; ! 799: } ! 800: /* ! 801: * tsdinfo should be 1-to-1 with tsminfo, but someone ! 802: * might have screwed up the config file: ! 803: */ ! 804: for (i = 0; i < NTS; i++) { ! 805: if ((ui = tsdinfo[i]) != NULL && ! 806: ui->ui_alive && ui->ui_mi == um) { ! 807: um->um_tab.b_actf = um->um_tab.b_actl = ! 808: &tsutab[i]; ! 809: break; ! 810: } ! 811: } ! 812: tsmap(&ts_softc[ts11], uban, (int *)NULL); ! 813: (void) tsinit(ts11); ! 814: tsstart(um); ! 815: } ! 816: } ! 817: ! 818: /*ARGSUSED*/ ! 819: tsioctl(dev, cmd, data, flag) ! 820: caddr_t data; ! 821: dev_t dev; ! 822: { ! 823: int tsunit = TSUNIT(dev); ! 824: register struct ts_softc *sc = &ts_softc[tsdinfo[tsunit]->ui_ctlr]; ! 825: register struct buf *bp = &ctsbuf[TSUNIT(dev)]; ! 826: register int callcount; ! 827: int fcount, error = 0; ! 828: struct mtop *mtop; ! 829: struct mtget *mtget; ! 830: /* we depend of the values and order of the MT codes here */ ! 831: static int tsops[] = ! 832: {TS_WEOF,TS_SFORWF,TS_SREVF,TS_SFORW,TS_SREV,TS_REW,TS_OFFL,TS_SENSE}; ! 833: ! 834: switch (cmd) { ! 835: ! 836: case MTIOCTOP: /* tape operation */ ! 837: mtop = (struct mtop *)data; ! 838: switch (mtop->mt_op) { ! 839: ! 840: case MTWEOF: ! 841: callcount = mtop->mt_count; ! 842: fcount = 1; ! 843: break; ! 844: ! 845: case MTFSF: case MTBSF: ! 846: case MTFSR: case MTBSR: ! 847: callcount = 1; ! 848: fcount = mtop->mt_count; ! 849: break; ! 850: ! 851: case MTREW: case MTOFFL: case MTNOP: ! 852: callcount = 1; ! 853: fcount = 1; ! 854: break; ! 855: ! 856: default: ! 857: return (ENXIO); ! 858: } ! 859: if (callcount <= 0 || fcount <= 0) ! 860: return (EINVAL); ! 861: while (--callcount >= 0) { ! 862: tscommand(dev, tsops[mtop->mt_op], fcount); ! 863: if ((mtop->mt_op == MTFSR || mtop->mt_op == MTBSR) && ! 864: bp->b_resid) ! 865: return (EIO); ! 866: if ((bp->b_flags&B_ERROR) || ! 867: sc->sc_ts.t_sts.s_xs0&TS_BOT) ! 868: break; ! 869: } ! 870: if (bp->b_flags&B_ERROR) ! 871: if ((error = bp->b_error)==0) ! 872: return (EIO); ! 873: return (error); ! 874: ! 875: case MTIOCGET: ! 876: mtget = (struct mtget *)data; ! 877: mtget->mt_dsreg = 0; ! 878: mtget->mt_erreg = sc->sc_ts.t_sts.s_xs0; ! 879: mtget->mt_resid = sc->sc_resid; ! 880: mtget->mt_type = MT_ISTS; ! 881: break; ! 882: ! 883: default: ! 884: return (ENXIO); ! 885: } ! 886: return (0); ! 887: } ! 888: ! 889: #define DBSIZE 20 ! 890: ! 891: tsdump(dev) ! 892: dev_t dev; ! 893: { ! 894: register struct uba_device *ui; ! 895: register struct uba_regs *uba; ! 896: register struct tsdevice *addr; ! 897: register int i; ! 898: register struct pte *io; ! 899: int blk, num, unit, reg, start; ! 900: u_short db; ! 901: struct ts_tsdata *tc, *tc_ubaddr; ! 902: ! 903: unit = TSUNIT(dev); ! 904: if (unit >= NTS) ! 905: return (ENXIO); ! 906: #define phys(a,b) ((b)((int)(a)&0x7fffffff)) ! 907: ui = phys(tsdinfo[unit], struct uba_device *); ! 908: if (ui->ui_alive == 0) ! 909: return (ENXIO); ! 910: uba = phys(ui->ui_hd, struct uba_hd *)->uh_physuba; ! 911: ubainit(uba); ! 912: addr = (struct tsdevice *)ui->ui_physaddr; ! 913: ! 914: /* map a ts_tsdata structure */ ! 915: tc = phys(&ts_softc[0].sc_ts, struct ts_tsdata *); ! 916: num = btoc(sizeof(struct ts_tsdata)) + 1; ! 917: io = &uba->uba_map[reg = NUBMREG - num]; ! 918: for (i = 0; i < num; i++) ! 919: *(int *)io++ = UBAMR_MRV | (btop(tc) + i); ! 920: i = (((int)tc & PGOFSET) | (reg << 9)); ! 921: tc_ubaddr = (struct ts_tsdata *)i; ! 922: db = i + ((i >> 16) & 3); ! 923: ! 924: /* init the drive */ ! 925: addr->tssr = 0; ! 926: tswait(addr); ! 927: if ((addr->tssr & (TS_NBA|TS_OFL)) != TS_NBA) ! 928: return (EFAULT); ! 929: ! 930: /* set characteristics */ ! 931: i = (int)&tc_ubaddr->t_char; ! 932: tc->t_cmd.c_loba = i; ! 933: tc->t_cmd.c_hiba = (i >> 16) & 3; ! 934: tc->t_cmd.c_size = sizeof(struct ts_char); ! 935: tc->t_cmd.c_cmd = TS_ACK | TS_CVC | TS_SETCHR; ! 936: tc->t_char.char_addr = (int)&tc_ubaddr->t_sts; ! 937: tc->t_char.char_size = sizeof(struct ts_sts); ! 938: tc->t_char.char_mode = TS_ESS; ! 939: addr->tsdb = db; ! 940: tswait(addr); ! 941: if (addr->tssr & TS_NBA) ! 942: return (ENXIO); ! 943: ! 944: /* dump */ ! 945: tc->t_cmd.c_cmd = TS_ACK | TS_WCOM; ! 946: tc->t_cmd.c_repcnt = 1; ! 947: num = maxfree; ! 948: for (start = 0, num = maxfree; num > 0; start += blk, num -= blk) { ! 949: blk = num > DBSIZE ? DBSIZE : num; ! 950: io = uba->uba_map; ! 951: for (i = 0; i < blk; i++) ! 952: *(int *)io++ = UBAMR_MRV | (1 << UBAMR_DPSHIFT) | ! 953: (start + i); ! 954: *(int *)io = 0; ! 955: addr->tsdb = db; ! 956: tswait(addr); ! 957: } ! 958: ! 959: /* eof */ ! 960: tc->t_cmd.c_cmd = TS_WEOF; ! 961: addr->tsdb = db; ! 962: tswait(addr); ! 963: addr->tsdb = db; ! 964: tswait(addr); ! 965: ! 966: if (addr->tssr&TS_SC) ! 967: return (EIO); ! 968: addr->tssr = 0; ! 969: tswait(addr); ! 970: return (0); ! 971: } ! 972: ! 973: tswait(addr) ! 974: register struct tsdevice *addr; ! 975: { ! 976: ! 977: while ((addr->tssr & TS_SSR) == 0) ! 978: /* void */; ! 979: } ! 980: ! 981: #endif /* NTS > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.