![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ra.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / lsys / io|
Return to ra.c CVS log | Up to [Research Unix] / researchv10dc / lsys / io |
1.1 root 1: /*
2: * DSA disk class driver
3: * drives RA-class disks
4: * hooked up through an MSCP port
5: */
6:
7: #include "sys/param.h"
8: #include "sys/buf.h"
9: #include "sys/udaioc.h"
10: #include "sys/ra.h"
11: #include "sys/mscp.h"
12: #include "sys/user.h"
13: #include "sys/file.h"
14: #include "sys/conf.h"
15:
16: extern struct msaddr raaddr[];
17: extern struct radisk radisk[];
18: extern int racnt;
19: static long rarefno; /* ref seq num */
20: extern struct buf rabuf[];
21: static struct buf rctbuf; /* for reading replacement table */
22:
23: static rareplace(), raonline(), rasonl(), racinit();
24:
25: int raopen(), raread(), rawrite(), raioctl(), rastrategy(), raclose();
26: struct bdevsw rabdev = bdinit(raopen, raclose, rastrategy, 0);
27: struct cdevsw racdev = cdinit(raopen, raclose, raread, rawrite, raioctl);
28:
29: /*
30: * UNIT(d) == logical unit number;
31: * the physical unit number is in raaddr[UNIT(d)].unit
32: */
33: #define UNIT(dev) (((dev)>>3) & 07)
34: #define PART(dev) ((dev)&07)
35: #define NPART 8
36: #define HUGE 0x7fffffff /* very large 32-bit number */
37:
38: struct size {
39: daddr_t nblocks;
40: daddr_t blkoff;
41: } ra_sizes[NPART] = {
42: 10240, 0,
43: 20480, 10240,
44: 249848, 30720,
45: 249848, 280568,
46: 249848, 530416,
47: HUGE, 780264,
48: 749544, 30720, /* slices 2,3,4 */
49: HUGE, 0, /* whole drive */
50: };
51:
52: /*
53: * reused bits of buf/iobuf struct
54: */
55:
56: #define b_next av_forw /* next buffer in queue */
57: #define b_pkt av_back /* pointer to mscp command */
58: #define b_crf b_resid /* saved refno for pending command */
59:
60: /*
61: * flags in radisk.flags
62: */
63:
64: #define ONLINE 01 /* drive is online */
65: #define WONLINE 02 /* waiting for online */
66: #define GOTDI 04 /* got unit info */
67: #define RPLOCK 010 /* replacement in progress */
68: #define RPWANT 020 /* want RPLOCK */
69: #define RPDONE 040 /* replacement done */
70: #define SPDOWN 0100 /* spin down on last close */
71:
72: /*
73: * random numbers
74: */
75:
76: #define PRIONL (PZERO-1)
77: #define SECTOR 512 /* size of an MSCP sector */
78: #define IDRA 0 /* connection ID for MSCP */
79:
80: /*
81: * open a drive, if necessary
82: */
83:
84: int raseql(), radg();
85:
86: raopen(dev, flag)
87: dev_t dev;
88: {
89: register int unit;
90: register struct radisk *ra;
91: register struct msaddr *rp;
92:
93: unit = UNIT(dev);
94: if (unit >= racnt) {
95: u.u_error = ENXIO;
96: return;
97: }
98: ra = &radisk[unit];
99: rp = &raaddr[unit];
100: if (ra->open == 0) {
101: if (rp->ctype < 0 || rp->ctype >= nmsport
102: || (ra->port = msportsw[rp->ctype]) == NULL) {
103: u.u_error = ENXIO;
104: return;
105: }
106: ra->di.radsize = HUGE;
107: if ((*ra->port->mp_init)(rp->ctl, rp->ctype, 0, IDRA, raseql, radg) == 0) {
108: u.u_error = ENXIO;
109: return;
110: }
111: racinit(ra, rp);
112: }
113: ra->open |= 1<<PART(dev);
114: spl6();
115: if ((ra->flags & ONLINE) == 0)
116: raonline(ra, rp);
117: spl0();
118: if ((ra->flags & ONLINE) == 0)
119: u.u_error = ENXIO;
120: }
121:
122: raclose(dev)
123: {
124: register struct radisk *ra;
125: register struct msaddr *rp;
126: register struct mscmd *mp;
127:
128: ra = &radisk[UNIT(dev)];
129: rp = &raaddr[UNIT(dev)];
130: ra->open &=~ (1<<PART(dev));
131: if (ra->open || (ra->flags & ONLINE) == 0)
132: return;
133: mp = (*ra->port->mp_get)(rp->ctl);
134: mp->m_crf = ++rarefno;
135: mp->m_unit = rp->unit;
136: mp->m_opcd = OPAVL; /* put it offline */
137: if ((ra->flags & SPDOWN) == 0)
138: mp->m_mod = 0;
139: else {
140: mp->m_mod = MDSPD;
141: ra->flags &=~ SPDOWN;
142: }
143: mp->m_unfl = 0;
144: mp->m_dvpm = 0; /* ? */
145: ra->flags &=~ ONLINE;
146: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
147: }
148:
149: int rastrategy();
150:
151: raread(dev)
152: {
153: physio(rastrategy, &rabuf[UNIT(dev)], dev, B_READ, minphys);
154: }
155:
156: rawrite(dev)
157: {
158: physio(rastrategy, &rabuf[UNIT(dev)], dev, B_WRITE, minphys);
159: }
160:
161: /*
162: * strategy routine;
163: * used as strategy by all port drivers
164: * send the packet right away
165: */
166:
167: rastrategy(bp)
168: register struct buf *bp;
169: {
170: register struct radisk *ra;
171: register struct mscmd *mp;
172: register int unit;
173: register struct size *sp;
174: register struct msaddr *rp;
175: int count;
176: daddr_t limit;
177:
178: unit = UNIT(minor(bp->b_dev));
179: ra = &radisk[unit];
180: rp = &raaddr[unit];
181: sp = &ra_sizes[PART(minor(bp->b_dev))];
182: limit = ra->di.radsize - sp->blkoff;
183: if (limit > sp->nblocks)
184: limit = sp->nblocks;
185: if (bp->b_blkno >= limit && bp != &rctbuf) {
186: if (bp->b_blkno == sp->nblocks)
187: bp->b_resid = bp->b_bcount;
188: else {
189: bp->b_error = ENOSPC;
190: bp->b_flags |= B_ERROR;
191: }
192: iodone(bp);
193: return;
194: }
195: count = bp->b_bcount;
196: if (count/SECTOR + bp->b_blkno > limit && bp != &rctbuf)
197: count = (limit - bp->b_blkno) * SECTOR;
198: spl6();
199: if ((ra->flags & ONLINE) == 0 && raonline(ra, rp) == 0) {
200: bp->b_flags |= B_ERROR;
201: iodone(bp);
202: spl0();
203: return;
204: }
205: mp = (*ra->port->mp_get)(rp->ctl);
206: mp->m_crf = ++rarefno;
207: mp->m_unit = rp->unit;
208: mp->m_opcd = (bp->b_flags & B_READ) ? OPRD : OPWR;
209: mp->m_mod = 0;
210: mp->m_bcnt = count;
211: mp->m_lbn = bp->b_blkno + sp->blkoff;
212: (*ra->port->mp_map)(rp->ctl, mp, bp);
213: bp->b_pkt = (struct buf *)mp;
214: bp->b_crf = mp->m_crf;
215: bp->b_next = NULL;
216: if (ra->actf)
217: ra->actl->b_next = bp;
218: else
219: ra->actf = bp;
220: ra->actl = bp;
221: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
222: spl0();
223: }
224:
225: /*
226: * ioctl
227: * principally for bad block replacement
228: */
229:
230: raioctl(dev, cmd, addr, flag)
231: dev_t dev;
232: caddr_t addr;
233: {
234: register union arg {
235: struct ud_rctbuf r;
236: struct ud_repl b;
237: } *uap;
238: register struct radisk *ra;
239: register int i;
240:
241: ra = &radisk[UNIT(dev)];
242: if ((ra->flags & (ONLINE|GOTDI)) != (ONLINE|GOTDI)) {
243: /* should bring it online here */
244: u.u_error = EIO;
245: return;
246: }
247: uap = (union arg *)addr;
248: switch(cmd) {
249: default:
250: u.u_error = ENOTTY;
251: return;
252:
253: case UIOCHAR:
254: if (copyout((caddr_t)&ra->di, addr, sizeof(struct ud_unit)))
255: u.u_error = EFAULT;
256: return;
257:
258: case UIORRCT:
259: if(uap->r.lbn < 0 || uap->r.lbn > ra->di.rctsize) {
260: u.u_error = EIO;
261: return;
262: }
263: /*
264: * try different copies until one works
265: */
266: for (i = 0; i < ra->di.copies; i++) {
267: u.u_count = SECTOR; /* block size on disk */
268: u.u_offset = ltoL((uap->r.lbn + ra->di.radsize) * SECTOR);
269: u.u_offset = Lladd(u.u_offset,i * ra->di.rctsize * SECTOR);
270: u.u_base = uap->r.buf;
271: u.u_segflg = SEGUDATA;
272: u.u_error = 0;
273: physio(rastrategy, &rctbuf, dev, B_READ, minphys);
274: if (u.u_error == 0)
275: break;
276: }
277: return;
278:
279: case UIOWRCT:
280: if ((flag & FWRITE) == 0) {
281: u.u_error = EBADF;
282: return;
283: }
284: if(uap->r.lbn < 0 || uap->r.lbn > ra->di.rctsize) {
285: u.u_error = EIO;
286: return;
287: }
288: /*
289: * write every copy we can
290: * should do read-after-write
291: */
292: for (i = 0; i < ra->di.copies; i++) {
293: u.u_count = SECTOR; /* block size on disk */
294: u.u_offset = ltoL((uap->r.lbn + ra->di.radsize) * SECTOR);
295: u.u_offset = Lladd(u.u_offset, i * ra->di.rctsize * SECTOR);
296: u.u_base = uap->r.buf;
297: u.u_segflg = SEGUDATA;
298: physio(rastrategy, &rctbuf, dev, B_WRITE, minphys);
299: u.u_error = 0;
300: }
301: return;
302:
303: case UIOREPL:
304: if ((flag & FWRITE) == 0) {
305: u.u_error = EBADF;
306: return;
307: }
308: rareplace(dev, uap->b.lbn, uap->b.replbn, uap->b.prim);
309: return;
310:
311: case UIOSPDW:
312: ra->flags |= SPDOWN;
313: return;
314:
315: case UIORST:
316: (*ra->port->mp_init)(raaddr[UNIT(dev)].ctl, raaddr[UNIT(dev)].ctype, 1, IDRA, raseql, radg);
317: return;
318: }
319:
320: }
321:
322: static
323: rareplace(dev, badlbn, replbn, prim)
324: int dev;
325: daddr_t badlbn;
326: daddr_t replbn;
327: int prim;
328: {
329: register struct mscmd *mp;
330: register struct radisk *ra;
331: register struct msaddr *rp;
332: register int unit;
333:
334: unit = UNIT(minor(dev));
335: ra = &radisk[unit];
336: rp = &raaddr[unit];
337: spl6();
338: while (ra->flags & RPLOCK) {
339: ra->flags |= RPWANT;
340: sleep((caddr_t)&ra->flags, PZERO + 1);
341: }
342: ra->flags |= RPLOCK;
343: printf("ra%d replace %D with %D\n", unit, badlbn, replbn);
344: mp = (*ra->port->mp_get)(rp->ctl);
345: bzero((caddr_t)mp, sizeof(struct mscmd)); /* clear reserved fields */
346: mp->m_crf = ++rarefno;
347: mp->m_unit = rp->unit;
348: mp->m_opcd = OPRPL;
349: mp->m_rbn = replbn;
350: mp->m_lbn = badlbn;
351: mp->m_mod = prim ? MDPRI : 0;
352: ra->cmdcrf = mp->m_crf;
353: ra->cmdopc = OPRPL;
354: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
355: while ((ra->flags & RPDONE) == 0)
356: sleep((caddr_t)&ra->rplret, PZERO);
357: u.u_error = ra->rplret;
358: if (ra->flags & RPWANT)
359: wakeup((caddr_t)&ra->flags);
360: ra->flags &=~ (RPWANT|RPLOCK|RPDONE);
361: spl0();
362:
363: }
364:
365: /*
366: * here when the port gets a sequential message
367: */
368: raseql(ctl, type, ep)
369: int ctl, type;
370: register struct msend *ep;
371: {
372: register struct buf *bp;
373: register struct radisk *ra;
374: register int unit;
375: register struct buf *obp;
376: int sts;
377:
378: if (ep->m_opcd == 0 && ep->m_sts == STRST) {
379: rareset(ctl);
380: return;
381: }
382: for (unit = 0; unit < racnt; unit++)
383: if (raaddr[unit].ctl == ctl
384: && raaddr[unit].ctype == type
385: && raaddr[unit].unit == ep->m_unit)
386: break;
387: if (unit >= racnt) {
388: printf("ra%d ctl%d typ%d: stray mscp packet sts x%x opcode %o\n",
389: ep->m_unit, ctl, type, ep->m_sts, ep->m_opcd);
390: return;
391: }
392: ra = &radisk[unit];
393: sts = ep->m_sts & STMSK;
394: if (sts == STAVL || sts == STOFL)
395: ra->flags &=~ ONLINE; /* help! */
396: illcmd:
397: switch (ep->m_opcd & 0377) {
398: case OPEND: /* eg invalid command */
399: if (ep->m_crf == ra->cmdcrf) {
400: ep->m_opcd = ra->cmdopc | OPEND;
401: goto illcmd;
402: }
403: /* else check for pending read or write */
404: case OPRD|OPEND:
405: case OPWR|OPEND:
406: for (bp = ra->actf, obp = NULL; bp; obp = bp, bp = bp->b_next)
407: if (ep->m_crf == bp->b_crf)
408: break;
409: if (bp == NULL) {
410: printf("ra%d stray end: crf %d sts x%x opcode 0%o\n",
411: unit, ep->m_crf, ep->m_sts, ep->m_opcd & 0377);
412: return;
413: }
414: if (((struct mscmd *)(bp->b_pkt))->m_crf != ep->m_crf)
415: printf("ra%d sent %d got %d crf; flg %x dev %x\n",
416: unit, ((struct mscmd *)(bp->b_pkt))->m_crf,
417: ep->m_crf, bp->b_flags, bp->b_dev);
418: if (obp)
419: obp->b_next = bp->b_next;
420: else
421: ra->actf = bp->b_next;
422: if (bp == ra->actl)
423: ra->actl = obp;
424: bp->b_resid = bp->b_bcount - ep->m_bcnt;
425: if (sts != STSUC) {
426: bp->b_flags |= B_ERROR;
427: if (ep->m_sts == STBCK || ep->m_sts == STBK2) /* optical disk blank check */
428: bp->b_error = ENXIO;
429: else
430: printf("err on ra%d block %D: sts x%x\n", unit, bp->b_blkno, ep->m_sts);
431: }
432: (*ra->port->mp_unmap)(ctl, (struct mscmd *)bp->b_pkt);
433: iodone(bp);
434: return;
435:
436: case OPONL|OPEND:
437: rasonl(ra, ep);
438: return;
439:
440: case OPAVL|OPEND:
441: ra->flags &=~ ONLINE;
442: return;
443:
444: case OPGUS|OPEND:
445: if (sts != STSUC) {
446: printf("ra%d: can't get unit sts x%x\n", unit, ep->m_sts);
447: return;
448: }
449: ra->di.medium = ep->m_medi;
450: ra->di.tracksz = ep->m_trck;
451: ra->di.groupsz = ep->m_grp;
452: ra->di.cylsz = ep->m_cyl;
453: ra->di.rctsize = ep->m_rcts;
454: ra->di.rbns = ep->m_rbns;
455: ra->di.copies = ep->m_rctc;
456: ra->flags |= GOTDI;
457: return;
458:
459: case OPSCC|OPEND:
460: if (sts != STSUC)
461: printf("ra ctl%d typ%d: bad init\n", ctl, type);
462: return;
463:
464: case OPRPL|OPEND:
465: ra->rplret = 0;
466: if (sts != STSUC) {
467: printf("ra%d: rpl sts x%x\n", unit, ep->m_sts);
468: ra->rplret = EIO;
469: }
470: ra->flags |= RPDONE;
471: wakeup((caddr_t)&ra->rplret);
472: return;
473:
474: default:
475: printf("ra%d ctl%d typ%d: stray mscp msg opcd 0%o sts x%x\n",
476: ep->m_unit, ctl, type, ep->m_opcd&0377, ep->m_sts);
477: return;
478: }
479: }
480:
481: /*
482: * controller was reset
483: * discard all pending io,
484: * awake all sleepers,
485: * mark everything offline
486: */
487:
488: rareset(ctl)
489: int ctl;
490: {
491: register int unit;
492: register struct radisk *ra;
493: register struct buf *bp, *nbp;
494:
495: for (unit = 0; unit < racnt; unit++) {
496: if (raaddr[unit].ctl != ctl)
497: continue;
498: ra = &radisk[unit];
499: for (bp = ra->actf; bp; bp = nbp) {
500: nbp = bp->b_next;
501: (*ra->port->mp_unmap)(ctl, (struct mscmd *)bp->b_pkt);
502: bp->b_flags |= B_ERROR;
503: iodone(bp);
504: }
505: ra->actf = ra->actl = NULL;
506: ra->flags &=~ (ONLINE|WONLINE);
507: wakeup((caddr_t)ra);
508: }
509: }
510:
511: /*
512: * here with a datagram message
513: * explanations really shouldn't be in the driver
514: *
515: * the hack for event 8 ignores error packets from
516: * the US Design optical disk controller
517: * that really mean `read a blank spot on the disk
518: */
519:
520: static char *raevents[] = {
521: "ok",
522: "inv cmd",
523: "op aborted",
524: "offline",
525: "available",
526: "med fmt",
527: "write prot",
528: "comp err",
529: "data err",
530: "host buf access err",
531: "cntl err",
532: "drive err",
533: };
534: #define MAXEVT 0xb
535:
536: radg(ctl, type, ep)
537: int ctl, type;
538: register struct mserl *ep;
539: {
540: register u_short *sp; /* for sdi crap */
541: register int i; /* for useless design crap */
542: register unsigned char *cp; /* for useless design crap */
543:
544: if (ep->l_fmt == FMDSK && ep->l_evnt == STBCK && ep->l_flgs == 0)
545: return;
546: printf("ra%d ctl%d typ%d seq %d: %s err; fmt x%x ev x%x fl x%x\n",
547: ep->l_unit, ctl, type, ep->l_seq, /* phys unit, not log */
548: ep->l_flgs&(LFSUC|LFCON) ? "soft" : "hard",
549: ep->l_fmt, ep->l_evnt, ep->l_flgs&0377);
550: if ((ep->l_evnt & STMSK) <= MAXEVT)
551: printf("%s; ", raevents[ep->l_evnt & STMSK]);
552: switch (ep->l_fmt) {
553: case FMCNT:
554: /* now the thing should be marked disastrously bad */
555: printf("oops\n");
556: break;
557:
558: case FMBAD:
559: printf("host mem access; addr x%x\n", ep->l_badr);
560: break;
561:
562: case FMDSK:
563: printf("%sbn %d; lev x%x, retry x%x\n",
564: (ep->l_hdcd & 0xf0000000) == 0 ? "l" : "r",
565: ep->l_hdcd & 0x0fffffff, ep->l_lvl, ep->l_rtry);
566: break;
567:
568: case FMSDI:
569: printf("%sbn %d;",
570: (ep->l_hdcd & 0xf0000000) == 0 ? "l" : "r",
571: ep->l_hdcd & 0x0fffffff);
572: /*
573: * print the bytes in the same order used
574: * by the dec diagnostics
575: */
576: sp = (u_short *)&ep->l_sdi[3];
577: while (sp > (u_short *)ep->l_sdi)
578: printf(" %x", *--sp);
579: printf(" xx\n");
580: break;
581:
582: case FMSMD:
583: printf("cyl %d\n", ep->l_sdi[1]);
584: break;
585:
586: case 0x40: /* hack for useless design */
587: printf("scsi:");
588: cp = (unsigned char *)ep->l_sdi;
589: for(i = 0; i < 10; i++)
590: printf(" %x", *cp++);
591: printf(" [%x %x]\n", cp[0], cp[1]);
592: break;
593:
594: default:
595: printf("\n");
596: break;
597: }
598: }
599:
600: /*
601: * unit is believed offline
602: * try to bring it on
603: */
604:
605: static
606: raonline(ra, rp)
607: register struct radisk *ra;
608: register struct msaddr *rp;
609: {
610: register struct mscmd *mp;
611: int s;
612:
613: s = spl6();
614: if ((ra->flags & WONLINE) == 0) {
615: ra->flags &=~ GOTDI;
616: mp = (*ra->port->mp_get)(rp->ctl);
617: bzero((caddr_t)mp, sizeof(struct mscmd)); /* clear reserved fields */
618: mp->m_crf = ++rarefno;
619: mp->m_unit = rp->unit;
620: mp->m_opcd = OPONL;
621: ra->cmdcrf = mp->m_crf;
622: ra->cmdopc = OPONL;
623: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
624: ra->flags |= WONLINE;
625: }
626: while (ra->flags & WONLINE)
627: tsleep((caddr_t)ra, PRIONL, 60);
628: if ((ra->flags & ONLINE) == 0)
629: return (0);
630: if ((ra->flags & GOTDI) == 0) {
631: mp = (*ra->port->mp_get)(rp->ctl);
632: mp->m_crf = ++rarefno;
633: mp->m_unit = rp->unit;
634: mp->m_opcd = OPGUS;
635: mp->m_mod = 0;
636: mp->m_unfl = 0;
637: mp->m_dvpm = 0; /* ? */
638: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
639: }
640: splx(s);
641: return (1);
642: }
643:
644: static
645: rasonl(ra, ep)
646: register struct radisk *ra;
647: register struct msend *ep;
648: {
649:
650: if (ra->flags & WONLINE) {
651: ra->flags &=~ WONLINE;
652: wakeup((caddr_t)ra);
653: }
654: if ((ep->m_sts & STMSK) != STSUC)
655: return;
656: ra->flags |= ONLINE;
657: if (ra->di.radsize != HUGE && ra->di.radsize != ep->m_unsz)
658: printf("ra%d: changed size %d to %d\n", ra-radisk, ra->di.radsize, ep->m_unsz);
659: ra->di.radsize = ep->m_unsz;
660: }
661:
662: /*
663: * controller init
664: * set characteristics to turn off host timeouts
665: */
666:
667: static
668: racinit(ra, rp)
669: struct radisk *ra;
670: struct msaddr *rp;
671: {
672: register struct mscmd *mp;
673: register int s;
674:
675: mp = (*ra->port->mp_get)(rp->ctl);
676: mp->m_crf = ++rarefno;
677: mp->m_unit = rp->unit;
678: mp->m_opcd = OPSCC;
679: mp->m_mod = 0;
680: mp->m_cntf = CFMSC | CFTHS;
681: mp->m_vrsn = MSCPVER;
682: mp->m_htmo = 0; /* no timeout */
683: mp->m_time[0] = mp->m_time[1] = 0L;
684: s = spl6();
685: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
686: splx(s);
687: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.