![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev|
Return to cd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
9: *
10: * Redistribution is only permitted until one year after the first shipment
11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
12: * binary forms are permitted provided that: (1) source distributions retain
13: * this entire copyright notice and comment, and (2) distributions including
14: * binaries display the following acknowledgement: This product includes
15: * software developed by the University of California, Berkeley and its
16: * contributors'' in the documentation or other materials provided with the
17: * distribution and in all advertising materials mentioning features or use
18: * of this software. Neither the name of the University nor the names of
19: * its contributors may be used to endorse or promote products derived from
20: * this software without specific prior written permission.
21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24: *
25: * from: Utah $Hdr: cd.c 1.4 89/09/17$
26: *
27: * @(#)cd.c 7.1 (Berkeley) 5/8/90
28: */
29:
30: /*
31: * "Concatenated" disk driver.
32: */
33: #include "cd.h"
34: #if NCD > 0
35:
36: #include "param.h"
37: #include "systm.h"
38: #include "errno.h"
39: #include "dkstat.h"
40: #include "buf.h"
41: #include "malloc.h"
42: #include "conf.h"
43:
44: #include "cdvar.h"
45:
46: #ifdef DEBUG
47: int cddebug = 0x00;
48: #define CDB_FOLLOW 0x01
49: #define CDB_INIT 0x02
50: #define CDB_IO 0x04
51: #endif
52:
53: struct buf cdbuf[NCD];
54: struct buf *cdbuffer();
55: int cdiodone();
56:
57: #define cdunit(x) ((minor(x) >> 3) & 0x7) /* for consistency */
58:
59: #define getcbuf() \
60: ((struct buf *)malloc(sizeof(struct buf), M_DEVBUF, M_WAITOK))
61: #define putcbuf(bp) \
62: free((caddr_t)(bp), M_DEVBUF)
63:
64: struct cd_softc {
65: int sc_flags; /* flags */
66: size_t sc_size; /* size of cd */
67: int sc_ileave; /* interleave */
68: int sc_ncdisks; /* number of components */
69: struct cdcinfo sc_cinfo[NCDISKS]; /* component info */
70: struct cdiinfo *sc_itable; /* interleave table */
71: int sc_usecnt; /* number of requests active */
72: struct buf *sc_bp; /* "current" request */
73: int sc_dk; /* disk index */
74: } cd_softc[NCD];
75:
76: /* sc_flags */
77: #define CDF_ALIVE 0x01
78: #define CDF_INITED 0x02
79:
80: cdinit(cd)
81: struct cddevice *cd;
82: {
83: register struct cd_softc *cs = &cd_softc[cd->cd_unit];
84: register struct cdcinfo *ci;
85: register size_t size;
86: register int ix;
87: size_t minsize;
88: dev_t dev;
89:
90: #ifdef DEBUG
91: if (cddebug & (CDB_FOLLOW|CDB_INIT))
92: printf("cdinit: unit %d\n", cd->cd_unit);
93: #endif
94: cs->sc_dk = cd->cd_dk;
95: cs->sc_size = 0;
96: cs->sc_ileave = cd->cd_interleave;
97: cs->sc_ncdisks = 0;
98: /*
99: * Verify that each component piece exists and record
100: * relevant information about it.
101: */
102: minsize = 0;
103: for (ix = 0; ix < NCDISKS; ix++) {
104: if ((dev = cd->cd_dev[ix]) == NODEV)
105: break;
106: ci = &cs->sc_cinfo[ix];
107: ci->ci_dev = dev;
108: /*
109: * Calculate size (truncated to interleave boundary
110: * if necessary.
111: */
112: if (bdevsw[major(dev)].d_psize) {
113: size = (*bdevsw[major(dev)].d_psize)(dev);
114: if (size <= 0)
115: size = 0;
116: } else
117: size = 0;
118: if (cs->sc_ileave > 1)
119: size -= size % cs->sc_ileave;
120: if (size == 0)
121: return(0);
122: if (minsize == 0 || size < minsize)
123: minsize = size;
124: ci->ci_size = size;
125: cs->sc_size += size;
126: cs->sc_ncdisks++;
127: }
128: /*
129: * If uniform interleave is desired set all sizes to that of
130: * the smallest component.
131: */
132: if (cd->cd_flags & CDF_UNIFORM) {
133: for (ci = cs->sc_cinfo;
134: ci < &cs->sc_cinfo[cs->sc_ncdisks]; ci++)
135: ci->ci_size = minsize;
136: cs->sc_size = cs->sc_ncdisks * minsize;
137: }
138: /*
139: * Construct the interleave table
140: */
141: if (!cdinterleave(cs))
142: return(0);
143: if (cd->cd_dk >= 0)
144: dk_wpms[cd->cd_dk] = 32 * (60 * DEV_BSIZE / 2); /* XXX */
145: printf("cd%d: %d components (%d blocks) concatenated",
146: cd->cd_unit, cs->sc_ncdisks, cs->sc_size);
147: if (cs->sc_ileave)
148: printf(", %d block interleave\n", cs->sc_ileave);
149: else
150: printf(" serially\n");
151: cs->sc_flags = CDF_ALIVE | CDF_INITED;
152: return(1);
153: }
154:
155: cdinterleave(cs)
156: register struct cd_softc *cs;
157: {
158: register struct cdcinfo *ci, *smallci;
159: register struct cdiinfo *ii;
160: register daddr_t bn, lbn;
161: register int ix;
162: u_long size;
163:
164: #ifdef DEBUG
165: if (cddebug & CDB_INIT)
166: printf("cdinterleave(%x): ileave %d\n", cs, cs->sc_ileave);
167: #endif
168: /*
169: * Allocate an interleave table.
170: * Chances are this is too big, but we don't care.
171: */
172: size = (cs->sc_ncdisks + 1) * sizeof(struct cdiinfo);
173: cs->sc_itable = (struct cdiinfo *)malloc(size, M_DEVBUF, M_WAITOK);
174: bzero((caddr_t)cs->sc_itable, size);
175: /*
176: * Trivial case: no interleave (actually interleave of disk size).
177: * Each table entry represent a single component in its entirety.
178: */
179: if (cs->sc_ileave == 0) {
180: bn = 0;
181: ii = cs->sc_itable;
182: for (ix = 0; ix < cs->sc_ncdisks; ix++) {
183: ii->ii_ndisk = 1;
184: ii->ii_startblk = bn;
185: ii->ii_startoff = 0;
186: ii->ii_index[0] = ix;
187: bn += cs->sc_cinfo[ix].ci_size;
188: ii++;
189: }
190: ii->ii_ndisk = 0;
191: #ifdef DEBUG
192: if (cddebug & CDB_INIT)
193: printiinfo(cs->sc_itable);
194: #endif
195: return(1);
196: }
197: /*
198: * The following isn't fast or pretty; it doesn't have to be.
199: */
200: size = 0;
201: bn = lbn = 0;
202: for (ii = cs->sc_itable; ; ii++) {
203: /*
204: * Locate the smallest of the remaining components
205: */
206: smallci = NULL;
207: for (ci = cs->sc_cinfo;
208: ci < &cs->sc_cinfo[cs->sc_ncdisks]; ci++)
209: if (ci->ci_size > size &&
210: (smallci == NULL ||
211: ci->ci_size < smallci->ci_size))
212: smallci = ci;
213: /*
214: * Nobody left, all done
215: */
216: if (smallci == NULL) {
217: ii->ii_ndisk = 0;
218: break;
219: }
220: /*
221: * Record starting logical block and component offset
222: */
223: ii->ii_startblk = bn / cs->sc_ileave;
224: ii->ii_startoff = lbn;
225: /*
226: * Determine how many disks take part in this interleave
227: * and record their indices.
228: */
229: ix = 0;
230: for (ci = cs->sc_cinfo;
231: ci < &cs->sc_cinfo[cs->sc_ncdisks]; ci++)
232: if (ci->ci_size >= smallci->ci_size)
233: ii->ii_index[ix++] = ci - cs->sc_cinfo;
234: ii->ii_ndisk = ix;
235: bn += ix * (smallci->ci_size - size);
236: lbn = smallci->ci_size / cs->sc_ileave;
237: size = smallci->ci_size;
238: }
239: #ifdef DEBUG
240: if (cddebug & CDB_INIT)
241: printiinfo(cs->sc_itable);
242: #endif
243: return(1);
244: }
245:
246: #ifdef DEBUG
247: printiinfo(ii)
248: struct cdiinfo *ii;
249: {
250: register int ix, i;
251:
252: for (ix = 0; ii->ii_ndisk; ix++, ii++) {
253: printf(" itab[%d]: #dk %d sblk %d soff %d",
254: ix, ii->ii_ndisk, ii->ii_startblk, ii->ii_startoff);
255: for (i = 0; i < ii->ii_ndisk; i++)
256: printf(" %d", ii->ii_index[i]);
257: printf("\n");
258: }
259: }
260: #endif
261:
262: cdopen(dev, flags)
263: dev_t dev;
264: {
265: int unit = cdunit(dev);
266: register struct cd_softc *cs = &cd_softc[unit];
267:
268: #ifdef DEBUG
269: if (cddebug & CDB_FOLLOW)
270: printf("cdopen(%x, %x)\n", dev, flags);
271: #endif
272: if (unit >= NCD || (cs->sc_flags & CDF_ALIVE) == 0)
273: return(ENXIO);
274: return(0);
275: }
276:
277: cdstrategy(bp)
278: register struct buf *bp;
279: {
280: register int unit = cdunit(bp->b_dev);
281: register struct cd_softc *cs = &cd_softc[unit];
282: register int bn, sz;
283: int s;
284:
285: #ifdef DEBUG
286: if (cddebug & CDB_FOLLOW)
287: printf("cdstrategy(%x): unit %d\n", bp, unit);
288: #endif
289: if ((cs->sc_flags & CDF_INITED) == 0) {
290: bp->b_error = ENXIO;
291: goto bad;
292: }
293: bn = bp->b_blkno;
294: sz = (bp->b_bcount + (DEV_BSIZE - 1)) >> DEV_BSHIFT;
295: bp->b_resid = bp->b_bcount;
296: if (bn < 0 || bn + sz > cs->sc_size) {
297: if (bn == cs->sc_size)
298: goto done;
299: bp->b_error = EINVAL;
300: goto bad;
301: }
302: /*
303: * "Start" the unit.
304: * XXX: the use of sc_bp is just to retain the "traditional"
305: * interface to the start routine.
306: */
307: s = splbio();
308: cs->sc_bp = bp;
309: cdstart(unit);
310: splx(s);
311: return;
312: bad:
313: bp->b_flags |= B_ERROR;
314: done:
315: iodone(bp);
316: }
317:
318: cdstart(unit)
319: int unit;
320: {
321: register struct cd_softc *cs = &cd_softc[unit];
322: register struct buf *bp = cs->sc_bp;
323: register long bcount, rcount;
324: struct buf *cbp;
325: caddr_t addr;
326: daddr_t bn;
327:
328: #ifdef DEBUG
329: if (cddebug & CDB_FOLLOW)
330: printf("cdstart(%d)\n", unit);
331: #endif
332: /*
333: * Instumentation (not real meaningful)
334: */
335: cs->sc_usecnt++;
336: if (cs->sc_dk >= 0) {
337: dk_busy |= 1 << cs->sc_dk;
338: dk_xfer[cs->sc_dk]++;
339: dk_wds[cs->sc_dk] += bp->b_bcount >> 6;
340: }
341: /*
342: * Allocate component buffers and fire off the requests
343: */
344: bn = bp->b_blkno;
345: addr = bp->b_un.b_addr;
346: for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) {
347: cbp = cdbuffer(cs, bp, bn, addr, bcount);
348: rcount = cbp->b_bcount;
349: (*bdevsw[major(cbp->b_dev)].d_strategy)(cbp);
350: bn += btodb(rcount);
351: addr += rcount;
352: }
353: }
354:
355: /*
356: * Build a component buffer header.
357: */
358: struct buf *
359: cdbuffer(cs, bp, bn, addr, bcount)
360: register struct cd_softc *cs;
361: struct buf *bp;
362: daddr_t bn;
363: caddr_t addr;
364: long bcount;
365: {
366: register struct cdcinfo *ci;
367: register struct buf *cbp;
368: register daddr_t cbn, cboff;
369:
370: #ifdef DEBUG
371: if (cddebug & CDB_IO)
372: printf("cdbuffer(%x, %x, %d, %x, %d)\n",
373: cs, bp, bn, addr, bcount);
374: #endif
375: /*
376: * Determine which component bn falls in.
377: */
378: cbn = bn;
379: cboff = 0;
380: /*
381: * Serially concatenated
382: */
383: if (cs->sc_ileave == 0) {
384: register daddr_t sblk;
385:
386: sblk = 0;
387: for (ci = cs->sc_cinfo; cbn >= sblk + ci->ci_size; ci++)
388: sblk += ci->ci_size;
389: cbn -= sblk;
390: }
391: /*
392: * Interleaved
393: */
394: else {
395: register struct cdiinfo *ii;
396: int cdisk, off;
397:
398: cboff = cbn % cs->sc_ileave;
399: cbn /= cs->sc_ileave;
400: for (ii = cs->sc_itable; ii->ii_ndisk; ii++)
401: if (ii->ii_startblk > cbn)
402: break;
403: ii--;
404: off = cbn - ii->ii_startblk;
405: if (ii->ii_ndisk == 1) {
406: cdisk = ii->ii_index[0];
407: cbn = ii->ii_startoff + off;
408: } else {
409: cdisk = ii->ii_index[off % ii->ii_ndisk];
410: cbn = ii->ii_startoff + off / ii->ii_ndisk;
411: }
412: cbn *= cs->sc_ileave;
413: ci = &cs->sc_cinfo[cdisk];
414: }
415: /*
416: * Fill in the component buf structure.
417: */
418: cbp = getcbuf();
419: cbp->b_flags = bp->b_flags | B_CALL;
420: cbp->b_iodone = cdiodone;
421: cbp->b_proc = bp->b_proc;
422: cbp->b_dev = ci->ci_dev;
423: cbp->b_blkno = cbn + cboff;
424: cbp->b_un.b_addr = addr;
425: if (cs->sc_ileave == 0)
426: cbp->b_bcount = dbtob(ci->ci_size - cbn);
427: else
428: cbp->b_bcount = dbtob(cs->sc_ileave - cboff);
429: if (cbp->b_bcount > bcount)
430: cbp->b_bcount = bcount;
431: /*
432: * XXX: context for cdiodone
433: */
434: cbp->b_vp = (struct vnode *)bp;
435: cbp->b_pfcent = ((cs - cd_softc) << 16) | (ci - cs->sc_cinfo);
436: #ifdef DEBUG
437: if (cddebug & CDB_IO)
438: printf(" dev %x(u%d): cbp %x bn %d addr %x bcnt %d\n",
439: ci->ci_dev, ci-cs->sc_cinfo, cbp, cbp->b_blkno,
440: cbp->b_un.b_addr, cbp->b_bcount);
441: #endif
442: return(cbp);
443: }
444:
445: cdintr(unit)
446: int unit;
447: {
448: register struct cd_softc *cs = &cd_softc[unit];
449: register struct buf *bp = cs->sc_bp;
450:
451: #ifdef DEBUG
452: if (cddebug & CDB_FOLLOW)
453: printf("cdintr(%d)\n", unit);
454: #endif
455: /*
456: * Request is done for better or worse, wakeup the top half.
457: */
458: if (--cs->sc_usecnt == 0 && cs->sc_dk >= 0)
459: dk_busy &= ~(1 << cs->sc_dk);
460: if (bp->b_flags & B_ERROR)
461: bp->b_resid = bp->b_bcount;
462: iodone(bp);
463: }
464:
465: /*
466: * Called by iodone at interrupt time.
467: * Mark the component as done and if all components are done,
468: * take a cd interrupt.
469: */
470: cdiodone(cbp)
471: register struct buf *cbp;
472: {
473: register struct buf *bp = (struct buf *)cbp->b_vp; /* XXX */
474: register int unit = (cbp->b_pfcent >> 16) & 0xFFFF; /* XXX */
475: int count, s;
476:
477: s = splbio();
478: #ifdef DEBUG
479: if (cddebug & CDB_FOLLOW)
480: printf("cdiodone(%x)\n", cbp);
481: if (cddebug & CDB_IO) {
482: printf("cdiodone: bp %x bcount %d resid %d\n",
483: bp, bp->b_bcount, bp->b_resid);
484: printf(" dev %x(u%d), cbp %x bn %d addr %x bcnt %d\n",
485: cbp->b_dev, cbp->b_pfcent & 0xFFFF, cbp,
486: cbp->b_blkno, cbp->b_un.b_addr, cbp->b_bcount);
487: }
488: #endif
489:
490: if (cbp->b_flags & B_ERROR) {
491: bp->b_flags |= B_ERROR;
492: bp->b_error = geterror(cbp);
493: #ifdef DEBUG
494: printf("cd%d: error %d on component %d\n",
495: unit, bp->b_error, cbp->b_pfcent & 0xFFFF);
496: #endif
497: }
498: count = cbp->b_bcount;
499: putcbuf(cbp);
500:
501: /*
502: * If all done, "interrupt".
503: * Again, sc_bp is only used to preserve the traditional interface.
504: */
505: bp->b_resid -= count;
506: if (bp->b_resid < 0)
507: panic("cdiodone: count");
508: if (bp->b_resid == 0) {
509: cd_softc[unit].sc_bp = bp;
510: cdintr(unit);
511: }
512: splx(s);
513: }
514:
515: cdread(dev, uio)
516: dev_t dev;
517: struct uio *uio;
518: {
519: register int unit = cdunit(dev);
520:
521: #ifdef DEBUG
522: if (cddebug & CDB_FOLLOW)
523: printf("cdread(%x, %x)\n", dev, uio);
524: #endif
525: return(physio(cdstrategy, &cdbuf[unit], dev, B_READ, minphys, uio));
526: }
527:
528: cdwrite(dev, uio)
529: dev_t dev;
530: struct uio *uio;
531: {
532: register int unit = cdunit(dev);
533:
534: #ifdef DEBUG
535: if (cddebug & CDB_FOLLOW)
536: printf("cdwrite(%x, %x)\n", dev, uio);
537: #endif
538: return(physio(cdstrategy, &cdbuf[unit], dev, B_WRITE, minphys, uio));
539: }
540:
541: cdioctl(dev, cmd, data, flag)
542: dev_t dev;
543: int cmd;
544: caddr_t data;
545: int flag;
546: {
547: return(EINVAL);
548: }
549:
550: cdsize(dev)
551: dev_t dev;
552: {
553: int unit = cdunit(dev);
554: register struct cd_softc *cs = &cd_softc[unit];
555:
556: if (unit >= NCD || (cs->sc_flags & CDF_INITED) == 0)
557: return(-1);
558: return(cs->sc_size);
559: }
560:
561: cddump(dev)
562: {
563: return(ENXIO);
564: }
565: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.