![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to challoc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / chunix|
Return to challoc.c CVS log | Up to [Research Unix] / researchv8dc / sys / chunix |
1.1 root 1: /*
2: * challoc.c
3: * Storage allocation routines for the Chaos N.C.P. for allocating
4: * packets, connections, and (possibly) tty structures for connections treated
5: * as UNIX tty's
6: */
7: #include "../chunix/chsys.h"
8: #include "../chunix/chconf.h"
9: #include "../chaos/chaos.h"
10: #include "../h/buf.h"
11:
12: #define BUFPRI PRIBIO /* Sleep priority for buffers */
13: #define b_bits b_blkno /* Bit map for chaos bufs in buffer (0=free) */
14: #define b_list b_resid /* Index in chsize that buffer belongs to */
15: #define b_nfree b_bcount /* Number of free chaos buffers in buffer */
16: #ifdef VMUNIX
17: #define CHMAXBUF 25
18: #define CHNMAXPKT 18
19: #define CHBSIZE BUFSIZE
20: #else
21: #define CHMAXBUF 12
22: #define CHNMAXPKT 9
23: #ifdef UCB_BUFOUT
24: #define CHBSIZE BUFSIZE
25: extern char abuffers[NABUF][CHBSIZE];
26: #else
27: #define CHBSIZE (BSIZE(0)+BSLOP)
28: extern char buffers[NBUF][CHBSIZE];
29: #endif UCB_BUFOUT
30: #endif VMUNIX
31:
32: /*
33: * Structure for keeping track of various sizes of chaos buffers.
34: * Initialized values should be parameterized.
35: */
36: struct chsize {
37: short ch_bufsize; /* Size of packets to allocate from buffer */
38: short ch_mxbufs; /* Maximum buffers to allocate to this size */
39: short ch_bufcount; /* The count of buffers already allocated */
40: short ch_buffree; /* Number of free buffers on this list now */
41: struct buf *ch_bufptr; /* Pointer to buffers of this size */
42: } Chsizes[] = {
43: #define CHMINPKT 32
44: { CHMINPKT, 1, },
45: { 128, 2, },
46: { 512, CHNMAXPKT, },
47: #endif
48: };
49:
50: #define NSIZES (sizeof(Chsizes)/sizeof(Chsizes[0]))
51:
52: int Chbufwait; /* Someone's waiting for buffers */
53: struct buf *Chbuflist; /* Unassigned buffers */
54: int Chnbufs;
55:
56: /*
57: * Allocate a chunk at least "size" large,
58: * set flag means called from interrupt level - don't hang waiting for buffers
59: * just return NULL
60: */
61: char *
62: ch_alloc(size, flag)
63: {
64: register struct chsize *sp;
65: register struct buf *bp;
66: register int j;
67: long bit;
68: int opl;
69:
70: opl = spl6();
71: again:
72: for (sp = Chsizes; sp < &Chsizes[NSIZES]; sp++) {
73: if (sp->ch_bufsize < size)
74: continue;
75: if (sp->ch_buffree == 0) {
76: if (sp->ch_bufcount == sp->ch_mxbufs ||
77: (bp = Chbuflist) == NULL)
78: continue;
79: Chbuflist = bp->av_forw;
80: bp->av_forw = sp->ch_bufptr;
81: sp->ch_bufptr = bp;
82: bp->b_nfree = j = BSIZE(0) / sp->ch_bufsize;
83: bp->b_bits = 0;
84: bp->b_list = sp - Chsizes;
85: sp->ch_buffree += j;
86: sp->ch_bufcount++;
87: } else
88: for (bp = sp->ch_bufptr;; bp = bp->av_forw)
89: if (bp == NULL)
90: panic("buffer lost somewhere");
91: else if (bp->b_nfree != 0)
92: break;
93: /* Here bp points to a buffer to allocate */
94: for (bit = 1L, j = 0; ; bit <<= 1, j++)
95: if (!(bit & bp->b_bits))
96: break;
97: bp->b_bits |= bit;
98: bp->b_nfree--;
99: sp->ch_buffree--;
100: debug(DALLOC,printf("Alloc: size=%d,adr = %x\n", size, bp->b_un.b_addr+(j * sp->ch_bufsize)));
101: splx(opl);
102: return (bp->b_un.b_addr+(j * sp->ch_bufsize));
103: }
104: if (!flag) {
105: Chbufwait++;
106: sleep((caddr_t)&Chbufwait, BUFPRI);
107: goto again;
108: }
109: debug(DALLOC|DABNOR,printf("Alloc: size=%d, failed\n", size));
110: splx(opl);
111: return((caddr_t)0);
112: }
113: /*
114: * Free the previously allocated storage at "p"
115: */
116: ch_free(p)
117: char *p;
118: {
119: register struct buf *bp;
120: register struct chsize *sp;
121: register int opl;
122: long bit;
123:
124: #ifdef UCB_BUFOUT
125: bp = &abuf[(p - abuffers) / CHBSIZE];
126: #else
127: bp = &buf[(p - buffers) / CHBSIZE];
128: #endif
129: sp = &Chsizes[bp->b_list];
130: debug(DALLOC,printf("Free: addr=%x\n", p));
131: bit = 1L << ((p - bp->b_un.b_addr) / sp->ch_bufsize);
132: if (!(bp->b_bits & bit)) {
133: printf("Free: buffer %x already freed\n", p);
134: panic("Chaos buffer already freed");
135: }
136: bp->b_nfree++;
137: bp->b_bits &= ~bit;
138: sp->ch_buffree++;
139: opl = spl6();
140: if (Chbufwait) {
141: wakeup((caddr_t)&Chbufwait);
142: Chbufwait = 0;
143: }
144: splx(opl);
145: }
146: #ifdef DEBUG
147: /*
148: * Check that address p is in the range of possible allocated packets
149: */
150: ch_badaddr(p)
151: char *p;
152: {
153: register struct buf *bp;
154: register struct chsize *sp;
155: register int opl = spl6();
156:
157: for (sp = Chsizes; sp < &Chsizes[NSIZES]; sp++)
158: for (bp = sp->ch_bufptr; bp; bp = bp->av_forw)
159: if (p >= bp->b_un.b_addr &&
160: p < bp->b_un.b_addr + BSIZE(0)) {
161: splx(opl);
162: return(0);
163: }
164: splx(opl);
165: return(1);
166: }
167: #endif
168: /*
169: * Return the size of the place pointed at by "p"
170: */
171: ch_size(p)
172: char *p;
173: {
174: register struct buf *bp;
175:
176: #ifdef UCB_BUFOUT
177: bp = &abuf[(p - abuffers) / CHBSIZE];
178: #else
179: bp = &buf[(p - buffers) / CHBSIZE];
180: #endif
181: return (Chsizes[bp->b_list].ch_bufsize);
182: }
183: /*
184: * Allocate some space when a new connection is created
185: */
186: ch_bufalloc()
187: {
188: register int cnt;
189: register struct buf *bp;
190: struct buf *geteblk();
191:
192: if (sizeof(bp->b_bits) != 4)
193: panic("challoc bits");
194: if (Chnbufs < 8)
195: cnt = 4;
196: else
197: cnt = 1;
198: if ((Chnbufs + cnt) > CHMAXBUF)
199: return;
200: Chnbufs += cnt;
201: for (; cnt > 0; cnt--) {
202: #ifndef VMUNIX
203: #ifdef UCB_BUFOUT
204: if (abfreelist.av_forw == &abfreelist)
205: #else
206: if (bfreelist.av_forw == &bfreelist)
207: #endif
208: break;
209: #endif VMUNIX
210: bp = geteblk();
211: LOCK;
212: bp->av_forw = Chbuflist;
213: Chbuflist = bp;
214: UNLOCK;
215: }
216: Chnbufs -= cnt;
217: }
218:
219: ch_buffree()
220: {
221: register int cnt;
222: register struct buf *bp;
223:
224: if (Chnbufs <= 8)
225: cnt = 4;
226: else
227: cnt = 1;
228: if (Chnbufs - cnt >= CHMAXBUF)
229: return;
230: LOCK;
231: for (; cnt > 0 && (bp = Chbuflist) != NULL; cnt--) {
232: Chbuflist = bp->av_forw;
233: #ifdef UCB_BUFOUT
234: abrelse(bp);
235: #else
236: brelse(bp);
237: #endif
238: Chnbufs--;
239: }
240: UNLOCK;
241: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.