![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / sys / vaxuba|
Return to rl.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vaxuba |
1.1 root 1: /* rl.c 6.1 83/07/29 */
2:
3: #include "rl.h"
4: #if NRL > 0
5: /*
6: * UNIBUS RL02 disk driver
7: */
8: #include "../machine/pte.h"
9:
10: #include "../h/param.h"
11: #include "../h/systm.h"
12: #include "../h/dk.h"
13: #include "../h/dkbad.h"
14: #include "../h/buf.h"
15: #include "../h/conf.h"
16: #include "../h/dir.h"
17: #include "../h/user.h"
18: #include "../h/map.h"
19: #include "../h/vm.h"
20: #include "../h/cmap.h"
21: #include "../h/uio.h"
22: #include "../h/kernel.h"
23:
24: #include "../vax/cpu.h"
25: #include "../vax/nexus.h"
26: #include "../vaxuba/ubavar.h"
27: #include "../vaxuba/ubareg.h"
28: #include "../vaxuba/rlreg.h"
29:
30: /* Pending Controller items and statistics */
31: struct rl_softc {
32: int rl_softas; /* Attention sumary, (seeks pending) */
33: int rl_ndrive; /* Number of drives on controller */
34: int rl_wticks; /* Monitor time for function */
35: } rl_softc[NHL];
36:
37: /*
38: * State of controller from last transfer.
39: * Since only one transfer can be done at a time per
40: * controller, only allocate one for each controller.
41: */
42: struct rl_stat {
43: short rl_cyl[4]; /* Current cylinder for each drive */
44: short rl_dn; /* drive number currently transferring */
45: short rl_cylnhd; /* current cylinder and head of transfer */
46: u_short rl_bleft; /* bytes left to transfer */
47: u_short rl_bpart; /* bytes transferred */
48: } rl_stat[NHL];
49:
50: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
51: /* Last cylinder not used. Saved for Bad Sector File */
52: struct size {
53: daddr_t nblocks;
54: int cyloff;
55: } rl02_sizes[8] = {
56: 15884, 0, /* A=cyl 0 thru 397 */
57: 4520, 398, /* B=cyl 398 thru 510 */
58: -1, 0, /* C=cyl 0 thru 511 */
59: 4520, 398, /* D=cyl 398 thru 510 */
60: 0, 0, /* F= Not Defined */
61: 20440, 0, /* G=cyl 0 thru 510 */
62: 0, 0, /* H= Not Defined */
63: };
64: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
65:
66: int rlprobe(), rlslave(), rlattach(), rldgo(), rlintr();
67: struct uba_ctlr *rlminfo[NHL];
68: struct uba_device *rldinfo[NRL];
69: struct uba_device *rlip[NHL][4];
70:
71: /* RL02 driver structure */
72: u_short rlstd[] = { 0174400 };
73: struct uba_driver hldriver =
74: { rlprobe, rlslave, rlattach, rldgo, rlstd, "rl", rldinfo, "hl", rlminfo };
75:
76: /* User table per controller */
77: struct buf rlutab[NRL];
78:
79: /* RL02 drive structure */
80: struct RL02 {
81: short nbpt; /* Number of 512 byte blocks/track */
82: short ntrak;
83: short nbpc; /* Number of 512 byte blocks/cylinder */
84: short ncyl;
85: short btrak; /* Number of bytes/track */
86: struct size *sizes;
87: } rl02 = {
88: 20, 2, 40, 512, 20*512, rl02_sizes /* rl02/DEC*/
89: };
90:
91: struct buf rrlbuf[NRL];
92:
93: #define b_cylin b_resid /* Last seek as CYL<<1 | HD */
94:
95: #ifdef INTRLVE
96: daddr_t dkblock();
97: #endif
98:
99: int rlwstart, rlwatch(); /* Have started guardian */
100:
101: /* Check that controller exists */
102: /*ARGSUSED*/
103: rlprobe(reg)
104: caddr_t reg;
105: {
106: register int br, cvec;
107:
108: #ifdef lint
109: br = 0; cvec = br; br = cvec;
110: rlintr(0);
111: #endif
112: ((struct rldevice *)reg)->rlcs = RL_IE | RL_NOOP;
113: DELAY(10);
114: ((struct rldevice *)reg)->rlcs &= ~RL_IE;
115: return (sizeof (struct rldevice));
116: }
117:
118: rlslave(ui, reg)
119: struct uba_device *ui;
120: caddr_t reg;
121: {
122: register struct rldevice *rladdr = (struct rldevice *)reg;
123: short ctr = 0;
124:
125: /*
126: * DEC reports that:
127: * For some unknown reason the RL02 (seems to be only drive 1)
128: * does not return a valid drive status the first time that a
129: * GET STATUS request is issued for the drive, in fact it can
130: * take up to three or more GET STATUS requests to obtain the
131: * correct status.
132: * In order to overcome this, the driver has been modified to
133: * issue a GET STATUS request and validate the drive status
134: * returned. If a valid status is not returned after eight
135: * attempts, then an error message is printed.
136: */
137: do {
138: rladdr->rlda.getstat = RL_RESET;
139: rladdr->rlcs = (ui->ui_slave <<8) | RL_GETSTAT; /* Get status*/
140: rlwait(rladdr);
141: } while ((rladdr->rlmp.getstat&RLMP_STATUS) != RLMP_STATOK && ++ctr<8);
142: if ((rladdr->rlcs & RL_DE) || (ctr >= 8))
143: return (0);
144: if ((rladdr->rlmp.getstat & RLMP_DT) == 0 ) {
145: printf("rl%d: rl01's not supported\n", ui->ui_slave);
146: return(0);
147: }
148: return (1);
149: }
150:
151: rlattach(ui)
152: register struct uba_device *ui;
153: {
154: register struct rldevice *rladdr;
155:
156: if (rlwstart == 0) {
157: timeout(rlwatch, (caddr_t)0, hz);
158: rlwstart++;
159: }
160: /* Initialize iostat values */
161: if (ui->ui_dk >= 0)
162: dk_mspw[ui->ui_dk] = .000003906; /* 16bit transfer time? */
163: rlip[ui->ui_ctlr][ui->ui_slave] = ui;
164: rl_softc[ui->ui_ctlr].rl_ndrive++;
165: rladdr = (struct rldevice *)ui->ui_addr;
166: /* reset controller */
167: rladdr->rlda.getstat = RL_RESET; /* SHOULD BE REPEATED? */
168: rladdr->rlcs = (ui->ui_slave << 8) | RL_GETSTAT; /* Reset DE bit */
169: rlwait(rladdr);
170: /* determine disk posistion */
171: rladdr->rlcs = (ui->ui_slave << 8) | RL_RHDR;
172: rlwait(rladdr);
173: /* save disk drive posistion */
174: rl_stat[ui->ui_ctlr].rl_cyl[ui->ui_slave] =
175: (rladdr->rlmp.readhdr & 0177700) >> 6;
176: rl_stat[ui->ui_ctlr].rl_dn = -1;
177: }
178:
179: rlopen(dev)
180: dev_t dev;
181: {
182: register int unit = minor(dev) >> 3;
183: register struct uba_device *ui;
184:
185: if (unit >= NRL || (ui = rldinfo[unit]) == 0 || ui->ui_alive == 0)
186: return (ENXIO);
187: return (0);
188: }
189:
190: rlstrategy(bp)
191: register struct buf *bp;
192: {
193: register struct uba_device *ui;
194: register int drive;
195: register struct buf *dp;
196: int partition = minor(bp->b_dev) & 07, s;
197: long bn, sz;
198:
199: sz = (bp->b_bcount+511) >> 9;
200: drive = dkunit(bp);
201: if (drive >= NRL)
202: goto bad;
203: ui = rldinfo[drive];
204: if (ui == 0 || ui->ui_alive == 0)
205: goto bad;
206: if (bp->b_blkno < 0 ||
207: (bn = dkblock(bp))+sz > rl02.sizes[partition].nblocks)
208: goto bad;
209: /* bn is in 512 byte block size */
210: bp->b_cylin = bn/rl02.nbpc + rl02.sizes[partition].cyloff;
211: s = spl5();
212: dp = &rlutab[ui->ui_unit];
213: disksort(dp, bp);
214: if (dp->b_active == 0) {
215: rlustart(ui);
216: bp = &ui->ui_mi->um_tab;
217: if (bp->b_actf && bp->b_active == 0)
218: rlstart(ui->ui_mi);
219: }
220: splx(s);
221: return;
222:
223: bad:
224: bp->b_flags |= B_ERROR;
225: iodone(bp);
226: return;
227: }
228:
229: /*
230: * Unit start routine.
231: * Seek the drive to be where the data is
232: * and then generate another interrupt
233: * to actually start the transfer.
234: */
235: rlustart(ui)
236: register struct uba_device *ui;
237: {
238: register struct buf *bp, *dp;
239: register struct uba_ctlr *um;
240: register struct rldevice *rladdr;
241: daddr_t bn;
242: short hd, diff;
243:
244: if (ui == 0)
245: return;
246: um = ui->ui_mi;
247: dk_busy &= ~(1 << ui->ui_dk);
248: dp = &rlutab[ui->ui_unit];
249: if ((bp = dp->b_actf) == NULL)
250: return;
251: /*
252: * If the controller is active, just remember
253: * that this device has to be positioned...
254: */
255: if (um->um_tab.b_active) {
256: rl_softc[um->um_ctlr].rl_softas |= 1<<ui->ui_slave;
257: return;
258: }
259: /*
260: * If we have already positioned this drive,
261: * then just put it on the ready queue.
262: */
263: if (dp->b_active)
264: goto done;
265: dp->b_active = 1; /* positioning drive */
266: rladdr = (struct rldevice *)um->um_addr;
267:
268: /*
269: * Figure out where this transfer is going to
270: * and see if we are seeked correctly.
271: */
272: bn = dkblock(bp); /* Block # desired */
273: /*
274: * Map 512 byte logical disk blocks
275: * to 256 byte sectors (rl02's are stupid).
276: */
277: hd = (bn / rl02.nbpt) & 1; /* Get head required */
278: diff = (rl_stat[um->um_ctlr].rl_cyl[ui->ui_slave] >> 1) - bp->b_cylin;
279: if ( diff == 0 && (rl_stat[um->um_ctlr].rl_cyl[ui->ui_slave] & 1) == hd)
280: goto done; /* on cylinder and head */
281: /*
282: * Not at correct position.
283: */
284: rl_stat[um->um_ctlr].rl_cyl[ui->ui_slave] = (bp->b_cylin << 1) | hd;
285: if (diff < 0)
286: rladdr->rlda.seek = -diff << 7 | RLDA_HGH | hd << 4;
287: else
288: rladdr->rlda.seek = diff << 7 | RLDA_LOW | hd << 4;
289: rladdr->rlcs = (ui->ui_slave << 8) | RL_SEEK;
290:
291: /*
292: * Mark unit busy for iostat.
293: */
294: if (ui->ui_dk >= 0) {
295: dk_busy |= 1<<ui->ui_dk;
296: dk_seek[ui->ui_dk]++;
297: }
298: rlwait(rladdr);
299: done:
300: /*
301: * Device is ready to go.
302: * Put it on the ready queue for the controller
303: * (unless its already there.)
304: */
305: if (dp->b_active != 2) {
306: dp->b_forw = NULL;
307: if (um->um_tab.b_actf == NULL)
308: um->um_tab.b_actf = dp;
309: else
310: um->um_tab.b_actl->b_forw = dp;
311: um->um_tab.b_actl = dp;
312: dp->b_active = 2; /* Request on ready queue */
313: }
314: }
315:
316: /*
317: * Start up a transfer on a drive.
318: */
319: rlstart(um)
320: register struct uba_ctlr *um;
321: {
322: register struct buf *bp, *dp;
323: register struct uba_device *ui;
324: register struct rldevice *rladdr;
325: register struct rl_stat *st = &rl_stat[um->um_ctlr];
326: daddr_t bn;
327: short sn, cyl, cmd;
328:
329: loop:
330: if ((dp = um->um_tab.b_actf) == NULL) {
331: st->rl_dn = -1;
332: st->rl_cylnhd = 0;
333: st->rl_bleft = 0;
334: st->rl_bpart = 0;
335: return;
336: }
337: if ((bp = dp->b_actf) == NULL) {
338: um->um_tab.b_actf = dp->b_forw;
339: goto loop;
340: }
341: /*
342: * Mark controller busy, and
343: * determine destination.
344: */
345: um->um_tab.b_active++;
346: ui = rldinfo[dkunit(bp)]; /* Controller */
347: bn = dkblock(bp); /* 512 byte Block number */
348: cyl = bp->b_cylin << 1; /* Cylinder */
349: cyl |= (bn / rl02.nbpt) & 1; /* Get head required */
350: sn = (bn % rl02.nbpt) << 1; /* Sector number */
351: rladdr = (struct rldevice *)ui->ui_addr;
352: rlwait(rladdr);
353: rladdr->rlda.rw = cyl<<6 | sn;
354: /* save away current transfers drive status */
355: st->rl_dn = ui->ui_slave;
356: st->rl_cylnhd = cyl;
357: st->rl_bleft = bp->b_bcount;
358: st->rl_bpart = rl02.btrak - (sn * NRLBPSC);
359: /*
360: * RL02 must seek between cylinders and between tracks,
361: * determine maximum data transfer at this time.
362: */
363: if (st->rl_bleft < st->rl_bpart)
364: st->rl_bpart = st->rl_bleft;
365: rladdr->rlmp.rw = -(st->rl_bpart >> 1);
366: if (bp->b_flags & B_READ)
367: cmd = RL_IE | RL_READ | (ui->ui_slave << 8);
368: else
369: cmd = RL_IE | RL_WRITE | (ui->ui_slave << 8);
370: um->um_cmd = cmd;
371: (void) ubago(ui);
372: }
373:
374: rldgo(um)
375: register struct uba_ctlr *um;
376: {
377: register struct rldevice *rladdr = (struct rldevice *)um->um_addr;
378:
379: rladdr->rlba = um->um_ubinfo;
380: rladdr->rlcs = um->um_cmd|((um->um_ubinfo>>12)&RL_BAE);
381: }
382:
383: /*
384: * Handle a disk interrupt.
385: */
386: rlintr(rl21)
387: register rl21;
388: {
389: register struct buf *bp, *dp;
390: register struct uba_ctlr *um = rlminfo[rl21];
391: register struct uba_device *ui;
392: register struct rldevice *rladdr = (struct rldevice *)um->um_addr;
393: register unit;
394: struct rl_softc *rl = &rl_softc[um->um_ctlr];
395: struct rl_stat *st = &rl_stat[um->um_ctlr];
396: int as = rl->rl_softas, status;
397:
398: rl->rl_wticks = 0;
399: rl->rl_softas = 0;
400: dp = um->um_tab.b_actf;
401: bp = dp->b_actf;
402: ui = rldinfo[dkunit(bp)];
403: dk_busy &= ~(1 << ui->ui_dk);
404:
405: /*
406: * Check for and process errors on
407: * either the drive or the controller.
408: */
409: if (rladdr->rlcs & RL_ERR) {
410: u_short err;
411: rlwait(rladdr);
412: err = rladdr->rlcs;
413: /* get staus and reset controller */
414: rladdr->rlda.getstat = RL_GSTAT;
415: rladdr->rlcs = (ui->ui_slave << 8) | RL_GETSTAT;
416: rlwait(rladdr);
417: status = rladdr->rlmp.getstat;
418: /* reset drive */
419: rladdr->rlda.getstat = RL_RESET;
420: rladdr->rlcs = (ui->ui_slave <<8) | RL_GETSTAT; /* Get status*/
421: rlwait(rladdr);
422: if ((status & RLMP_WL) == RLMP_WL) {
423: /*
424: * Give up on write protected devices
425: * immediately.
426: */
427: printf("rl%d: write protected\n", dkunit(bp));
428: bp->b_flags |= B_ERROR;
429: } else if (++um->um_tab.b_errcnt > 10) {
430: /*
431: * After 10 retries give up.
432: */
433: harderr(bp, "rl");
434: printf("cs=%b mp=%b\n", err, RLCS_BITS,
435: status, RLER_BITS);
436: bp->b_flags |= B_ERROR;
437: } else
438: um->um_tab.b_active = 0; /* force retry */
439: /* determine disk position */
440: rladdr->rlcs = (ui->ui_slave << 8) | RL_RHDR;
441: rlwait(rladdr);
442: /* save disk drive position */
443: st->rl_cyl[ui->ui_slave] =
444: (rladdr->rlmp.readhdr & 0177700) >> 6;
445: }
446: /*
447: * If still ``active'', then don't need any more retries.
448: */
449: if (um->um_tab.b_active) {
450: /* RL02 check if more data from previous request */
451: if ((bp->b_flags & B_ERROR) == 0 &&
452: (int)(st->rl_bleft -= st->rl_bpart) > 0) {
453: /*
454: * The following code was modeled from the rk07
455: * driver when an ECC error occured. It has to
456: * fix the bits then restart the transfer which is
457: * what we have to do (restart transfer).
458: */
459: int reg, npf, o, cmd, ubaddr, diff, head;
460:
461: /* seek to next head/track */
462: /* increment head and/or cylinder */
463: st->rl_cylnhd++;
464: diff = (st->rl_cyl[ui->ui_slave] >> 1) -
465: (st->rl_cylnhd >> 1);
466: st->rl_cyl[ui->ui_slave] = st->rl_cylnhd;
467: head = st->rl_cylnhd & 1;
468: rlwait(rladdr);
469: if (diff < 0)
470: rladdr->rlda.seek =
471: -diff << 7 | RLDA_HGH | head << 4;
472: else
473: rladdr->rlda.seek =
474: diff << 7 | RLDA_LOW | head << 4;
475: rladdr->rlcs = (ui->ui_slave << 8) | RL_SEEK;
476: npf = btop( bp->b_bcount - st->rl_bleft );
477: reg = btop(um->um_ubinfo&0x3ffff) + npf;
478: o = (int)bp->b_un.b_addr & PGOFSET;
479: ubapurge(um);
480: um->um_tab.b_active++;
481: rlwait(rladdr);
482: rladdr->rlda.rw = st->rl_cylnhd << 6;
483: if (st->rl_bleft < (st->rl_bpart = rl02.btrak))
484: st->rl_bpart = st->rl_bleft;
485: rladdr->rlmp.rw = -(st->rl_bpart >> 1);
486: cmd = (bp->b_flags&B_READ ? RL_READ : RL_WRITE) |
487: RL_IE | (ui->ui_slave << 8);
488: ubaddr = (int)ptob(reg) + o;
489: cmd |= ((ubaddr >> 12) & RL_BAE);
490: rladdr->rlba = ubaddr;
491: rladdr->rlcs = cmd;
492: return;
493: }
494: um->um_tab.b_active = 0;
495: um->um_tab.b_errcnt = 0;
496: dp->b_active = 0;
497: dp->b_errcnt = 0;
498: /* "b_resid" words remaining after error */
499: bp->b_resid = st->rl_bleft;
500: um->um_tab.b_actf = dp->b_forw;
501: dp->b_actf = bp->av_forw;
502: st->rl_dn = -1;
503: st->rl_bpart = st->rl_bleft = 0;
504: iodone(bp);
505: /*
506: * If this unit has more work to do,
507: * then start it up right away.
508: */
509: if (dp->b_actf)
510: rlustart(ui);
511: as &= ~(1<<ui->ui_slave);
512: } else
513: as |= (1<<ui->ui_slave);
514: ubadone(um);
515: /* reset state info */
516: st->rl_dn = -1;
517: st->rl_cylnhd = st->rl_bpart = st->rl_bleft = 0;
518: /*
519: * Process other units which need attention.
520: * For each unit which needs attention, call
521: * the unit start routine to place the slave
522: * on the controller device queue.
523: */
524: while (unit = ffs(as)) {
525: unit--; /* was 1 origin */
526: as &= ~(1<<unit);
527: rlustart(rlip[rl21][unit]);
528: }
529: /*
530: * If the controller is not transferring, but
531: * there are devices ready to transfer, start
532: * the controller.
533: */
534: if (um->um_tab.b_actf && um->um_tab.b_active == 0)
535: rlstart(um);
536: }
537:
538: rlwait(rladdr)
539: register struct rldevice *rladdr;
540: {
541:
542: while ((rladdr->rlcs & RL_CRDY) == 0)
543: ;
544: }
545:
546: rlread(dev, uio)
547: dev_t dev;
548: struct uio *uio;
549: {
550: register int unit = minor(dev) >> 3;
551:
552: if (unit >= NRL)
553: return (ENXIO);
554: return (physio(rlstrategy, &rrlbuf[unit], dev, B_READ, minphys, uio));
555: }
556:
557: rlwrite(dev, uio)
558: dev_t dev;
559: struct uio *uio;
560: {
561: register int unit = minor(dev) >> 3;
562:
563: if (unit >= NRL)
564: return (ENXIO);
565: return (physio(rlstrategy, &rrlbuf[unit], dev, B_WRITE, minphys, uio));
566: }
567:
568: /*
569: * Reset driver after UBA init.
570: * Cancel software state of all pending transfers
571: * and restart all units and the controller.
572: */
573: rlreset(uban)
574: int uban;
575: {
576: register struct uba_ctlr *um;
577: register struct uba_device *ui;
578: register struct rldevice *rladdr;
579: register struct rl_stat *st;
580: register int rl21, unit;
581:
582: for (rl21 = 0; rl21 < NHL; rl21++) {
583: if ((um = rlminfo[rl21]) == 0 || um->um_ubanum != uban ||
584: um->um_alive == 0)
585: continue;
586: printf(" hl%d", rl21);
587: rladdr = (struct rldevice *)um->um_addr;
588: st = &rl_stat[rl21];
589: um->um_tab.b_active = 0;
590: um->um_tab.b_actf = um->um_tab.b_actl = 0;
591: if (um->um_ubinfo) {
592: printf("<%d>", (um->um_ubinfo>>28)&0xf);
593: um->um_ubinfo = 0;
594: }
595: /* reset controller */
596: st->rl_dn = -1;
597: st->rl_cylnhd = 0;
598: st->rl_bleft = 0;
599: st->rl_bpart = 0;
600: rlwait(rladdr);
601: for (unit = 0; unit < NRL; unit++) {
602: rladdr->rlcs = (unit << 8) | RL_GETSTAT;
603: rlwait(rladdr);
604: /* Determine disk posistion */
605: rladdr->rlcs = (unit << 8) | RL_RHDR;
606: rlwait(rladdr);
607: /* save disk drive posistion */
608: st->rl_cyl[unit] =
609: (rladdr->rlmp.readhdr & 0177700) >> 6;
610: if ((ui = rldinfo[unit]) == 0)
611: continue;
612: if (ui->ui_alive == 0 || ui->ui_mi != um)
613: continue;
614: rlutab[unit].b_active = 0;
615: rlustart(ui);
616: }
617: rlstart(um);
618: }
619: }
620:
621: /*
622: * Wake up every second and if an interrupt is pending
623: * but nothing has happened increment a counter.
624: * If nothing happens for 20 seconds, reset the UNIBUS
625: * and begin anew.
626: */
627: rlwatch()
628: {
629: register struct uba_ctlr *um;
630: register rl21, unit;
631: register struct rl_softc *rl;
632:
633: timeout(rlwatch, (caddr_t)0, hz);
634: for (rl21 = 0; rl21 < NHL; rl21++) {
635: um = rlminfo[rl21];
636: if (um == 0 || um->um_alive == 0)
637: continue;
638: rl = &rl_softc[rl21];
639: if (um->um_tab.b_active == 0) {
640: for (unit = 0; unit < NRL; unit++)
641: if (rlutab[unit].b_active &&
642: rldinfo[unit]->ui_mi == um)
643: goto active;
644: rl->rl_wticks = 0;
645: continue;
646: }
647: active:
648: rl->rl_wticks++;
649: if (rl->rl_wticks >= 20) {
650: rl->rl_wticks = 0;
651: printf("hl%d: lost interrupt\n", rl21);
652: ubareset(um->um_ubanum);
653: }
654: }
655: }
656:
657: /*ARGSUSED*/
658: rldump(dev)
659: dev_t dev;
660: {
661:
662: /* don't think there is room on swap for it anyway. */
663: }
664:
665: rlsize(dev)
666: dev_t dev;
667: {
668: register int unit = minor(dev) >> 3;
669: register struct uba_device *ui;
670:
671: if (unit >= NRL || (ui = rldinfo[unit]) == 0 || ui->ui_alive == 0)
672: return (-1);
673: return (rl02.sizes[minor(dev) & 07].nblocks);
674: }
675: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.