![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_malloc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / kern|
Return to kern_malloc.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 root 1: /*
2: * Copyright (c) 1987, 1991 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)kern_malloc.c 7.25 (Berkeley) 5/8/91
34: */
35:
36: #include "param.h"
37: #include "proc.h"
38: #include "map.h"
39: #include "kernel.h"
40: #include "malloc.h"
41: #include "vm/vm.h"
42: #include "vm/vm_kern.h"
43:
44: struct kmembuckets bucket[MINBUCKET + 16];
45: struct kmemstats kmemstats[M_LAST];
46: struct kmemusage *kmemusage;
47: char *kmembase, *kmemlimit;
48: char *memname[] = INITKMEMNAMES;
49:
50: /*
51: * Allocate a block of memory
52: */
53: void *
54: malloc(size, type, flags)
55: unsigned long size;
56: int type, flags;
57: {
58: register struct kmembuckets *kbp;
59: register struct kmemusage *kup;
60: long indx, npg, alloc, allocsize;
61: int s;
62: caddr_t va, cp, savedlist;
63: #ifdef KMEMSTATS
64: register struct kmemstats *ksp = &kmemstats[type];
65:
66: if (((unsigned long)type) > M_LAST)
67: panic("malloc - bogus type");
68: #endif
69:
70: indx = BUCKETINDX(size);
71: kbp = &bucket[indx];
72: s = splimp();
73: #ifdef KMEMSTATS
74: while (ksp->ks_memuse >= ksp->ks_limit) {
75: if (flags & M_NOWAIT) {
76: splx(s);
77: return ((void *) NULL);
78: }
79: if (ksp->ks_limblocks < 65535)
80: ksp->ks_limblocks++;
81: tsleep((caddr_t)ksp, PSWP+2, memname[type], 0);
82: }
83: #endif
84: if (kbp->kb_next == NULL) {
85: if (size > MAXALLOCSAVE)
86: allocsize = roundup(size, CLBYTES);
87: else
88: allocsize = 1 << indx;
89: npg = clrnd(btoc(allocsize));
90: va = (caddr_t) kmem_malloc(kmem_map, (vm_size_t)ctob(npg),
91: !(flags & M_NOWAIT));
92: if (va == NULL) {
93: splx(s);
94: return ((void *) NULL);
95: }
96: #ifdef KMEMSTATS
97: kbp->kb_total += kbp->kb_elmpercl;
98: #endif
99: kup = btokup(va);
100: kup->ku_indx = indx;
101: if (allocsize > MAXALLOCSAVE) {
102: if (npg > 65535)
103: panic("malloc: allocation too large");
104: kup->ku_pagecnt = npg;
105: #ifdef KMEMSTATS
106: ksp->ks_memuse += allocsize;
107: #endif
108: goto out;
109: }
110: #ifdef KMEMSTATS
111: kup->ku_freecnt = kbp->kb_elmpercl;
112: kbp->kb_totalfree += kbp->kb_elmpercl;
113: #endif
114: /*
115: * Just in case we blocked while allocating memory,
116: * and someone else also allocated memory for this
117: * bucket, don't assume the list is still empty.
118: */
119: savedlist = kbp->kb_next;
120: kbp->kb_next = va + (npg * NBPG) - allocsize;
121: for (cp = kbp->kb_next; cp > va; cp -= allocsize)
122: *(caddr_t *)cp = cp - allocsize;
123: *(caddr_t *)cp = savedlist;
124: }
125: va = kbp->kb_next;
126: kbp->kb_next = *(caddr_t *)va;
127: #ifdef KMEMSTATS
128: kup = btokup(va);
129: if (kup->ku_indx != indx)
130: panic("malloc: wrong bucket");
131: if (kup->ku_freecnt == 0)
132: panic("malloc: lost data");
133: kup->ku_freecnt--;
134: kbp->kb_totalfree--;
135: ksp->ks_memuse += 1 << indx;
136: out:
137: kbp->kb_calls++;
138: ksp->ks_inuse++;
139: ksp->ks_calls++;
140: if (ksp->ks_memuse > ksp->ks_maxused)
141: ksp->ks_maxused = ksp->ks_memuse;
142: #else
143: out:
144: #endif
145: splx(s);
146: return ((void *) va);
147: }
148:
149: #ifdef DIAGNOSTIC
150: long addrmask[] = { 0x00000000,
151: 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
152: 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
153: 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
154: 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
155: };
156: #endif /* DIAGNOSTIC */
157:
158: /*
159: * Free a block of memory allocated by malloc.
160: */
161: void
162: free(addr, type)
163: void *addr;
164: int type;
165: {
166: register struct kmembuckets *kbp;
167: register struct kmemusage *kup;
168: long alloc, size;
169: int s;
170: #ifdef KMEMSTATS
171: register struct kmemstats *ksp = &kmemstats[type];
172: #endif
173:
174: kup = btokup(addr);
175: size = 1 << kup->ku_indx;
176: #ifdef DIAGNOSTIC
177: if (size > NBPG * CLSIZE)
178: alloc = addrmask[BUCKETINDX(NBPG * CLSIZE)];
179: else
180: alloc = addrmask[kup->ku_indx];
181: if (((u_long)addr & alloc) != 0) {
182: printf("free: unaligned addr 0x%x, size %d, type %d, mask %d\n",
183: addr, size, type, alloc);
184: panic("free: unaligned addr");
185: }
186: #endif /* DIAGNOSTIC */
187: kbp = &bucket[kup->ku_indx];
188: s = splimp();
189: if (size > MAXALLOCSAVE) {
190: kmem_free(kmem_map, (vm_offset_t)addr, ctob(kup->ku_pagecnt));
191: #ifdef KMEMSTATS
192: size = kup->ku_pagecnt << PGSHIFT;
193: ksp->ks_memuse -= size;
194: kup->ku_indx = 0;
195: kup->ku_pagecnt = 0;
196: if (ksp->ks_memuse + size >= ksp->ks_limit &&
197: ksp->ks_memuse < ksp->ks_limit)
198: wakeup((caddr_t)ksp);
199: ksp->ks_inuse--;
200: kbp->kb_total -= 1;
201: #endif
202: splx(s);
203: return;
204: }
205: #ifdef KMEMSTATS
206: kup->ku_freecnt++;
207: if (kup->ku_freecnt >= kbp->kb_elmpercl)
208: if (kup->ku_freecnt > kbp->kb_elmpercl)
209: panic("free: multiple frees");
210: else if (kbp->kb_totalfree > kbp->kb_highwat)
211: kbp->kb_couldfree++;
212: kbp->kb_totalfree++;
213: ksp->ks_memuse -= size;
214: if (ksp->ks_memuse + size >= ksp->ks_limit &&
215: ksp->ks_memuse < ksp->ks_limit)
216: wakeup((caddr_t)ksp);
217: ksp->ks_inuse--;
218: #endif
219: *(caddr_t *)addr = kbp->kb_next;
220: kbp->kb_next = addr;
221: splx(s);
222: }
223:
224: /*
225: * Initialize the kernel memory allocator
226: */
227: kmeminit()
228: {
229: register long indx;
230: int npg;
231:
232: #if ((MAXALLOCSAVE & (MAXALLOCSAVE - 1)) != 0)
233: ERROR!_kmeminit:_MAXALLOCSAVE_not_power_of_2
234: #endif
235: #if (MAXALLOCSAVE > MINALLOCSIZE * 32768)
236: ERROR!_kmeminit:_MAXALLOCSAVE_too_big
237: #endif
238: #if (MAXALLOCSAVE < CLBYTES)
239: ERROR!_kmeminit:_MAXALLOCSAVE_too_small
240: #endif
241: npg = VM_KMEM_SIZE/ NBPG;
242: kmemusage = (struct kmemusage *) kmem_alloc(kernel_map,
243: (vm_size_t)(npg * sizeof(struct kmemusage)));
244: kmem_map = kmem_suballoc(kernel_map, (vm_offset_t)&kmembase,
245: (vm_offset_t)&kmemlimit, (vm_size_t)(npg * NBPG), FALSE);
246: #ifdef KMEMSTATS
247: for (indx = 0; indx < MINBUCKET + 16; indx++) {
248: if (1 << indx >= CLBYTES)
249: bucket[indx].kb_elmpercl = 1;
250: else
251: bucket[indx].kb_elmpercl = CLBYTES / (1 << indx);
252: bucket[indx].kb_highwat = 5 * bucket[indx].kb_elmpercl;
253: }
254: for (indx = 0; indx < M_LAST; indx++)
255: kmemstats[indx].ks_limit = npg * NBPG * 6 / 10;
256: #endif
257: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.