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