![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stream.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / io|
Return to stream.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 root 1: /*
2: * primitives dealing in stream blocks
3: */
4:
5: #include "sys/param.h"
6: #include "sys/stream.h"
7: #include "sys/mtpr.h"
8: #include "sys/buf.h"
9:
10: #define M_HIPRI 127 /* for use by putbq */
11:
12: extern struct block cblock[];
13: extern struct buf *cblkbuf[];
14: extern struct queue queue[];
15: extern int blkcnt, blkbcnt, queuecnt;
16: struct queue *qhead; /* head of queues to run */
17: struct queue *qtail; /* last queue */
18:
19: /*
20: * blocks are kept in handful of free lists,
21: * each containing blocks of a particular size.
22: * there are MAXLEVEL sizes, each SPLITSIZE times bigger than the last.
23: * the system starts out with blkbcnt blocks of the largest size
24: * (which are in fact buffers from bio)
25: * and blkcnt-blkbcnt blocks of the smallest size.
26: * if there are no blocks of the requested size,
27: * larger ones are split to make some.
28: * the smallest blocks (level 0) are a special case:
29: * the data lives in the block header,
30: * and there's no point splitting larger blocks to make more
31: * because there are no headers to use after splitting.
32: */
33:
34: #define MAXLEVEL 6
35: #define SPLITSIZE 4
36:
37: int rbsize[MAXLEVEL] = { 4, 16, 64, 256, 1024, 4096 }; /* real block sizes */
38: int bsize[MAXLEVEL] = { 4, 16, 64, 256, 256, 256 }; /* size for q limits */
39: struct block *qfreelist[MAXLEVEL];
40: short blkfree[MAXLEVEL];
41: short blkall[MAXLEVEL];
42: short blkmax[MAXLEVEL];
43:
44: /*
45: * hooks for debugging
46: * turn this on only if you need it;
47: * it's quite slow
48: */
49: #if STDEBUG
50:
51: static int qiniting;
52: #define BADBP(bp) ((bp)!=&cblock[(bp)-cblock])
53:
54: static
55: badfreelist(lev)
56: register lev;
57: {
58: register i = 0;
59: register struct block *bp;
60:
61: /* look for block that is already on the free list */
62: for(bp=qfreelist[lev];bp!=0;bp=bp->next)
63: i++;
64: if(i!=blkfree[lev]){
65: printf("blkfree[%d]==%d i==%d\n", lev, blkfree[lev], i);
66: panic("bad free list 1");
67: }
68: }
69:
70: static
71: duplicateblock(lev, bp)
72: register lev;
73: register struct block *bp;
74: {
75: register i = 0;
76: register struct block *nbp;
77:
78: /* look for block that is already on the free list */
79: for(nbp=qfreelist[lev];nbp!=0;nbp=nbp->next) {
80: if(nbp==bp)
81: panic("duplicate free");
82: i++;
83: }
84: if(i!=blkfree[lev]){
85: printf("blkfree[%d]==%d i==%d\n", lev, blkfree[lev], i);
86: panic("bad free list 2");
87: }
88: }
89: #endif
90:
91: /*
92: * more debugging: trace the owner of a block
93: * not so slow, but very VAX-dependent.
94: */
95: #if BLKOWNER
96: #define MAXOWNER 2000 /* this many blocks will be traced */
97: #define CALLER(x) *(&x+5) /* x is an int, and is first auto in function */
98: int blkowner[MAXOWNER];
99: #endif
100:
101: qinit()
102: {
103: register i;
104: register struct buf *bp;
105:
106: #if STDEBUG
107: qiniting=1;
108: #endif
109: for (i = 0; i<blkbcnt; i++) {
110: if ((bp = geteblk()) == NULL)
111: break; /* probably not best */
112: cblock[i].class = MAXLEVEL-1;
113: cblock[i].base = (u_char *)&bp->b_un.b_addr[0];
114: cblock[i].lim = (u_char *)&bp->b_un.b_addr[bp->b_bcount];
115: cblock[i].rbufix = i;
116: cblkbuf[i] = bp;
117: freeb(&cblock[i]);
118: }
119: blkall[MAXLEVEL-1] = 0;
120: for ( ; i<blkcnt; i++) {
121: cblock[i].class = 0;
122: cblock[i].base = &cblock[i].data[0];
123: cblock[i].lim = &cblock[i].data[sizeof(cblock[0].data)];
124: cblock[i].rbufix = NOBUFIX;
125: freeb(&cblock[i]);
126: }
127: blkall[0] = 0;
128: #if STDEBUG
129: qiniting=0;
130: #endif
131: }
132:
133: static bsplit();
134:
135: struct block *
136: allocb(size)
137: {
138: #if BLKOWNER
139: int x;
140: #endif
141: register struct block *bp;
142: register lev;
143: register s;
144:
145: for (lev = 0; lev < MAXLEVEL; lev++) {
146: if (size <= rbsize[lev])
147: break;
148: }
149: if (lev >= MAXLEVEL)
150: panic("allocb bad size");
151: s = spl6();
152: #if STDEBUG
153: badfreelist(lev);
154: #endif
155:
156: /* check for free block of right size */
157: if ((bp = qfreelist[lev]) == NULL) {
158: bsplit(lev+1); /* else try to split larger block */
159: if ((bp = qfreelist[lev]) == NULL) {
160: if (size != QBSIZE) {
161: splx(s);
162: return (allocb(QBSIZE)); /* last chance */
163: }
164: panic("allocb no block");
165: }
166: }
167: qfreelist[lev] = bp->next;
168: blkall[lev]++;
169: if (blkall[lev] > blkmax[lev])
170: blkmax[lev] = blkall[lev];
171: blkfree[lev]--;
172: #if BLKOWNER
173: if ((x = bp-cblock) < MAXOWNER)
174: blkowner[x] = CALLER(x);
175: #endif
176: splx(s);
177: bp->type = M_DATA;
178: bp->next = NULL;
179: bp->rptr = bp->base;
180: bp->wptr = bp->base;
181: bp->bufix = bp->rbufix;
182: bp->class &= ~S_DELIM;
183: #if STDEBUG
184: if (BADBP(bp))
185: panic("allocb");
186: #endif
187: return(bp);
188: }
189:
190: static
191: bsplit(lev)
192: register lev;
193: {
194: register struct block *bp, *bp1;
195: register i, size;
196:
197: if (lev>=MAXLEVEL)
198: return;
199: if ((bp = qfreelist[lev]) == NULL) {
200: bsplit(lev+1);
201: if ((bp = qfreelist[lev]) == NULL)
202: return;
203: }
204: qfreelist[lev] = bp->next;
205: blkfree[lev]--;
206: size = (bp->lim - bp->base)/SPLITSIZE;
207: lev--; /* the blocks we're creating */
208: for (i=1; i<SPLITSIZE; i++) {
209: if ((bp1 = qfreelist[0]) == NULL)
210: return;
211: qfreelist[0] = bp1->next;
212: blkfree[0]--;
213: bp1->base = bp->base;
214: bp->base += size;
215: bp1->lim = bp1->base+size;
216: bp1->class = lev;
217: bp1->rbufix = bp->rbufix;
218: bp1->next = qfreelist[lev];
219: qfreelist[lev] = bp1;
220: blkfree[lev]++;
221: }
222: bp->class = lev;
223: bp->next = qfreelist[lev];
224: qfreelist[lev] = bp;
225: blkfree[lev]++;
226: }
227:
228: /*
229: * if this is a large block and its data can be squeezed
230: * into a smaller block, do it.
231: */
232: struct block *
233: cramb(bp)
234: register struct block *bp;
235: {
236: register struct block *nbp;
237: register int n;
238:
239: n = bp->wptr - bp->rptr;
240: if((bp->class&CL_MASK) < 3 || n > rbsize[(bp->class&CL_MASK)-1])
241: return bp;
242: nbp = allocb(n);
243: if(nbp==NULL)
244: return bp;
245: if(nbp->lim-nbp->wptr < n) {
246: freeb(nbp);
247: return bp;
248: }
249: bcopy(bp->rptr, nbp->wptr, n);
250: nbp->wptr += n;
251: nbp->type = bp->type;
252: if (bp->class & S_DELIM)
253: nbp->class |= S_DELIM;
254: freeb(bp);
255: return nbp;
256: }
257:
258: /*
259: * make a block that points to the same data
260: * as some existing block
261: */
262: struct block *
263: dupb(bp)
264: register struct block *bp;
265: {
266: #if BLKOWNER
267: int x;
268: #endif
269: register struct block *nbp;
270:
271: if ((nbp = allocb(0)) == NULL)
272: return (NULL);
273: nbp->type = bp->type;
274: nbp->rptr = bp->rptr;
275: nbp->wptr = bp->wptr;
276: nbp->bufix = bp->bufix;
277: nbp->class |= bp->class&S_DELIM;
278: #if BLKOWNER
279: if ((x = nbp-cblock) < MAXOWNER)
280: blkowner[x] = CALLER(x);
281: #endif
282: return (nbp);
283: }
284:
285: freeb(bp)
286: register struct block *bp;
287: {
288: register s = spl6();
289: register lev;
290:
291: lev = bp->class&CL_MASK;
292: #if STDEBUG
293: if (BADBP(bp))
294: panic("freeb");
295: duplicateblock(lev, bp);
296: if (blkall[lev] <= 0 && !qiniting)
297: panic("freeb excess free");
298: #endif
299: bp->next = qfreelist[lev];
300: qfreelist[lev] = bp;
301: blkall[lev]--;
302: blkfree[lev]++;
303: splx(s);
304: }
305:
306: struct block *
307: getq(q)
308: register struct queue *q;
309: {
310: #if BLKOWNER
311: int x;
312: #endif
313: register struct block *bp;
314: register s = spl6();
315:
316: if ((bp = q->first) == NULL) {
317: if ((q->flag&QENAB) == 0)
318: q->flag |= QWANTR;
319: } else {
320: if ((q->first = bp->next) == NULL)
321: q->last = NULL;
322: q->count -= bsize[bp->class&CL_MASK];
323: if (q->count < q->qinfo->limit)
324: q->flag &= ~QFULL;
325: q->flag &= ~QWANTR;
326: #if BLKOWNER
327: if ((x = bp-cblock) < MAXOWNER)
328: blkowner[x] = CALLER(x);
329: #endif
330: }
331: if (q->count<=q->qinfo->lolimit && q->flag&QWANTW && OTHERQ(q)->next) {
332: register struct queue *bq = backq(q);
333: if (bq->qinfo->srvp)
334: qenable(bq);
335: q->flag &= ~QWANTW;
336: }
337: splx(s);
338: #if STDEBUG
339: if(bp && BADBP(bp))
340: panic("getq");
341: #endif
342: return(bp);
343: }
344:
345: putq(q, bp)
346: register struct queue *q;
347: register struct block *bp;
348: {
349: int s;
350:
351: #if STDEBUG
352: if (BADBP(bp))
353: panic("putq");
354: #endif
355: if (bp->type==M_FLUSH)
356: flushq(q, 0);
357: s = spl6();
358: if (q->first==NULL) { /* empty, just tack on */
359: q->first = bp;
360: q->last = bp;
361: bp->next = NULL;
362: } else if (bp->type<QPCTL || q->last->type>=QPCTL) { /* put at end */
363: register struct block *lastp = q->last;
364: register n = bp->wptr - bp->rptr;
365: if (bp->type==M_DATA && lastp->type==M_DATA
366: && (lastp->class&S_DELIM)==0
367: && n <= lastp->lim-lastp->wptr && lastp->wptr>=lastp->base) {
368: bcopy(bp->rptr, lastp->wptr, n);
369: lastp->wptr += n;
370: if (bp->class&S_DELIM)
371: lastp->class |= S_DELIM;
372: freeb(bp);
373: bp = NULL;
374: } else {
375: lastp->next = bp;
376: q->last = bp;
377: bp->next = NULL;
378: }
379: } else { /* pri, put after any others */
380: register struct block *nbp = q->first;
381: if (nbp->type < QPCTL) {
382: bp->next = q->first;
383: q->first = bp;
384: } else {
385: while (nbp->next->type>=QPCTL)
386: nbp = nbp->next;
387: bp->next = nbp->next;
388: nbp->next = bp;
389: }
390: }
391: if (bp) {
392: q->count += bsize[bp->class&CL_MASK];
393: if (bp->type >= QPCTL && bp->type!= M_HIPRI)
394: q->flag |= QWANTR;
395: }
396: if (q->count >= q->qinfo->limit)
397: q->flag |= QFULL|QWANTW;
398: if ((q->flag & (QWANTR|QENAB|QNOENB)) == QWANTR && q->qinfo->srvp)
399: qenable(q);
400: splx(s);
401: }
402:
403: /*
404: * Put stuff back at beginning of Q
405: * (but after any priority msgs)
406: */
407: putbq(q, bp)
408: register struct queue *q;
409: register struct block *bp;
410: {
411: register savetype = bp->type;
412: register s = spl6();
413:
414: bp->type = M_HIPRI; /* fake priority, to force to start */
415: putq(q, bp);
416: bp->type = savetype;
417: splx(s);
418: }
419:
420: /*
421: * empty a queue. Leave any non-data messages, unless flag is 1.
422: */
423: flushq(q, flag)
424: register struct queue *q;
425: {
426: register struct block *bp, *nbp;
427: register s = spl6();
428:
429: bp = q->first;
430: q->first = NULL;
431: if (q->last)
432: q->last->next = NULL;
433: q->last = NULL;
434: q->count = 0;
435: q->flag &= ~QFULL;
436: while (bp) {
437: nbp = bp->next;
438: if (bp->type != M_DATA && bp->type != M_DELIM
439: && bp->type != M_CTL && bp->type != M_DELAY
440: && bp->type != M_FLUSH && !flag)
441: putq(q, bp);
442: else {
443: if (bp->type == M_PASS)
444: printf("flushing PASS %x\n",*(int *)(bp->rptr));
445: freeb(bp);
446: }
447: bp = nbp;
448: }
449: if (q->flag&QWANTW && OTHERQ(q)->next) {
450: q->flag &= ~QWANTW;
451: qenable(backq(q));
452: }
453: splx(s);
454: }
455:
456: /*
457: * allocate a pair of queues
458: */
459: struct queue *
460: allocq()
461: {
462: register struct queue *qp;
463: static struct queue zeroR =
464: { NULL,NULL,NULL,NULL,NULL,NULL,0,QUSE|QREADR};
465: static struct queue zeroW =
466: { NULL,NULL,NULL,NULL,NULL,NULL,0,QUSE};
467:
468: for (qp = queue; qp < &queue[queuecnt]; qp += 2) {
469: if ((qp->flag & QUSE) == 0) {
470: *qp = zeroR;
471: *WR(qp) = zeroW;
472: return(qp);
473: }
474: }
475: return(NULL);
476: }
477:
478: /*
479: * put routine that shouldn't be called
480: */
481: noput(q, c)
482: struct queue *q;
483: {
484: panic("noput");
485: }
486:
487: /*
488: * Put one data char on a queue, using f
489: */
490: putd(f, q, c)
491: int (*f)();
492: register struct queue *q;
493: {
494: register struct block *bp;
495: register s = spl6();
496:
497: if (f==putq && (bp = q->last) && bp->type==M_DATA && bp->wptr<bp->lim
498: && (bp->class&S_DELIM)==0) {
499: *bp->wptr++ = c;
500: splx(s);
501: } else {
502: splx(s);
503: if ((bp = allocb(16)) == NULL)
504: return(0);
505: *bp->wptr++ = c;
506: (*f)(q, bp);
507: }
508: return(1);
509: }
510:
511: /*
512: * Put a block of type c on queue
513: */
514: putctl(q, c)
515: struct queue *q;
516: {
517: register struct block *bp;
518:
519: if ((bp = allocb(0)) == NULL)
520: return(0);
521: bp->type = c;
522: (*q->qinfo->putp)(q, bp);
523: return(1);
524: }
525:
526: /*
527: * Put a block of type c, delimited, on queue
528: */
529: putctld(q, c)
530: struct queue *q;
531: {
532: register struct block *bp;
533:
534: if ((bp = allocb(0)) == NULL)
535: return(0);
536: bp->type = c;
537: bp->class |= S_DELIM;
538: (*q->qinfo->putp)(q, bp);
539: return(1);
540: }
541:
542: /*
543: * Block of type c, with one byte of data
544: */
545: putctl1(q, c, p)
546: struct queue *q;
547: {
548: register struct block *bp;
549:
550: if ((bp = allocb(1)) == NULL)
551: return(0);
552: bp->type = c;
553: *bp->wptr++ = p;
554: (*q->qinfo->putp)(q, bp);
555: return(1);
556: }
557:
558: /*
559: * Block of type c, delimited, with one byte of data
560: */
561: putctl1d(q, c, p)
562: struct queue *q;
563: {
564: register struct block *bp;
565:
566: if ((bp = allocb(1)) == NULL)
567: return(0);
568: bp->type = c;
569: bp->class |= S_DELIM;
570: *bp->wptr++ = p;
571: (*q->qinfo->putp)(q, bp);
572: return(1);
573: }
574:
575: /*
576: * block with two parameters
577: */
578: putctl2(q, c, p1, p2)
579: struct queue *q;
580: {
581: register struct block *bp;
582:
583: if ((bp = allocb(2)) == NULL)
584: return(0);
585: bp->type = c;
586: *bp->wptr++ = p1;
587: *bp->wptr++ = p2;
588: (*q->qinfo->putp)(q, bp);
589: return(1);
590: }
591:
592: /*
593: * put control record, using putq instead of queue's putp
594: */
595: qpctl(q, d)
596: register struct queue *q;
597: {
598: register struct block *bp = allocb(1);
599:
600: if (bp) {
601: bp->type = d;
602: putq(q, bp);
603: }
604: }
605:
606: qpctl1(q, c, d)
607: register struct queue *q;
608: {
609: register struct block *bp = allocb(1);
610:
611: if (bp) {
612: bp->type = c;
613: *bp->wptr++ = d;
614: putq(q, bp);
615: }
616: }
617:
618: qpctld(q, d)
619: register struct queue *q;
620: {
621: register struct block *bp = allocb(1);
622:
623: if (bp) {
624: bp->type = d;
625: bp->class |= S_DELIM;
626: putq(q, bp);
627: }
628: }
629:
630: /*
631: * Copy a literal record onto queue
632: */
633: putcpy(q, cp, n)
634: register struct queue *q;
635: register char *cp;
636: {
637: register struct block *bp;
638: register nm;
639:
640: while (n) {
641: if ((bp = allocb(n)) == NULL) /* sorry */
642: return;
643: bp->type = M_DATA;
644: nm = bp->lim - bp->wptr;
645: if (nm > n)
646: nm = n;
647: bcopy(cp, bp->wptr, nm);
648: cp += nm;
649: bp->wptr += nm;
650: n -= nm;
651: (*q->qinfo->putp)(q, bp);
652: }
653: }
654:
655: /*
656: * return the queue upstream from this one
657: */
658: struct queue *
659: backq(q)
660: register struct queue *q;
661: {
662: q = OTHERQ(q);
663: if (q->next) {
664: q = q->next;
665: return(OTHERQ(q));
666: }
667: q = OTHERQ(q);
668: printf("backq called with no back (Q %x)\n", q);
669: panic("backq");
670: return(NULL);
671: }
672:
673: /*
674: * Send a block back up the queue in reverse from this
675: * one (e.g. to respond to ioctls)
676: */
677: qreply(q, bp)
678: register struct queue *q;
679: struct block *bp;
680: {
681: q = OTHERQ(q);
682: (*q->next->qinfo->putp)(q->next, bp);
683: }
684:
685: /*
686: * Enable a queue: put it on list of those whose srvp's are
687: * ready to run.
688: */
689: qenable(q)
690: register struct queue *q;
691: {
692: register s;
693:
694: s = spl6();
695: if (q->flag & QENAB) {
696: splx(s);
697: return;
698: }
699: if (q->qinfo->srvp==NULL) {
700: splx(s);
701: return;
702: }
703: q->flag |= QENAB;
704: q->link = NULL;
705: if (qhead==NULL)
706: qhead = q;
707: else
708: qtail->link = q;
709: qtail = q;
710: setqsched();
711: splx(s);
712: }
713:
714: /*
715: * Run the srvp's of each enabled queue
716: * -- Should not be reentered
717: */
718: queuerun()
719: {
720: register struct queue *q;
721: register s;
722: extern int queueflag;
723: extern char *panicstr;
724:
725: if (panicstr)
726: return; /* to minimize destruction */
727: s = spl6();
728: queueflag++;
729: while (q = qhead) {
730: if ((qhead = q->link) == NULL)
731: qtail = NULL;
732: q->flag &= ~QENAB;
733: splx(s);
734: if (q->qinfo->srvp != NULL)
735: (*q->qinfo->srvp)(q);
736: else
737: printf("Q %x run with no srvp\n", q);
738: spl6();
739: }
740: queueflag--;
741: splx(s);
742: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.