在哪里可以得到malloc的源码呢？

BosCourage

谢谢了！
偶想看看这个神秘的东西了

Lilov

1. 
   
2. #include "../h/param.h"
   
3. #include "../h/systm.h"
   
4. #include "../h/uba.h"
   
5. #include "../h/map.h"
   
6. #include "../h/page.h"
   
7. #include "../h/mem.h"
   
8. 
   
9. /*
   
10. * Allocate 'size' units from the given
    
11. * map. Return the base of the allocated
    
12. * space.
    
13. * In a map, the addresses are increasing and the
    
14. * list is terminated by a 0 size.
    
15. * The swap map unit is 512 bytes.
    
16. * Algorithm is first-fit.
    
17. */
    
18. malloc(mp, size)
    
19. struct map *mp;
    
20. {
    
21.         register unsigned int a;
    
22.         register struct map *bp;
    
23. 
    
24.         for (bp=mp; bp->m_size; bp++) {
    
25.                 if (bp->m_size >= size) {
    
26.                         a = bp->m_addr;
    
27.                         bp->m_addr += size;
    
28.                         if ((bp->m_size -= size) == 0) {
    
29.                                 do {
    
30.                                         bp++;
    
31.                                         (bp-1)->m_addr = bp->m_addr;
    
32.                                 } while ((bp-1)->m_size = bp->m_size);
    
33.                         }
    
34.                         return(a);
    
35.                 }
    
36.         }
    
37.         return(0);
    
38. }
    
39. 
    
40. /*
    
41. * Free the previously allocated space aa
    
42. * of size units into the specified map.
    
43. * Sort aa into map and combine on
    
44. * one or both ends if possible.
    
45. */
    
46. mfree(mp, size, a)
    
47. struct map *mp;
    
48. register unsigned int a;
    
49. {
    
50.         register struct map *bp;
    
51.         register unsigned int t;
    
52. 
    
53.         bp = mp;
    
54.         for (; bp->m_addr<=a && bp->m_size!=0; bp++);
    
55.         if (bp>mp && (bp-1)->m_addr+(bp-1)->m_size == a) {
    
56.                 (bp-1)->m_size += size;
    
57.                 if (a+size == bp->m_addr) {
    
58.                         (bp-1)->m_size += bp->m_size;
    
59.                         while (bp->m_size) {
    
60.                                 bp++;
    
61.                                 (bp-1)->m_addr = bp->m_addr;
    
62.                                 (bp-1)->m_size = bp->m_size;
    
63.                         }
    
64.                 }
    
65.         } else {
    
66.                 if (a+size == bp->m_addr && bp->m_size) {
    
67.                         bp->m_addr -= size;
    
68.                         bp->m_size += size;
    
69.                 } else if (size) {
    
70.                         do {
    
71.                                 t = bp->m_addr;
    
72.                                 bp->m_addr = a;
    
73.                                 a = t;
    
74.                                 t = bp->m_size;
    
75.                                 bp->m_size = size;
    
76.                                 bp++;
    
77.                         } while (size = t);
    
78.                 }
    
79.         }
    
80. }
    
81. 
    
82. 
    
83. 
    
84. 
    
85. /*
    
86. * allocate memory
    
87. * Note: the memory map is stored in the array
    
88. * `memmap', one bit per page frame.  If the
    
89. * i'th bit of memmap is 0, then page frame i
    
90. * is free (available), if 1, then it is allocated.
    
91. * Up to NICMEM free page frame numbers are
    
92. * stored in the array mem.m_pnum.
    
93. */
    
94. memall(base, size)
    
95. register int *base;
    
96. {
    
97.         register int i, pos, ndx, mask;
    
98. 
    
99.         if (size <= 0 || size > freemem)
    
100.                 return(0);
     
101.         if (mem.m_free < 0)
     
102.                 panic("bad mem free-list");
     
103.         for(i=size; --i>=0; ) {
     
104.                 if (mem.m_free == 0) {
     
105.                         pos = lastpos + 1;
     
106.                         if (pos >= maxfree)
     
107.                                 pos = firstfree;
     
108.                         while(mem.m_free<NICMEM) {
     
109.                                 if ((memmap[pos>>5]&masktab[pos&0x1f])==0)
     
110.                                         mem.m_pnum[mem.m_free++] = pos;
     
111.                                 if (pos == lastpos)
     
112.                                         break;
     
113.                                 if (++pos >= maxfree)
     
114.                                         pos = firstfree;
     
115.                         }
     
116.                         if (mem.m_free <= 0)
     
117.                                 panic("lost mem");
     
118.                         lastpos = pos;
     
119.                 }
     
120.                 pos = mem.m_pnum[--mem.m_free];
     
121.                 mask = masktab[pos&0x1f];
     
122.                 ndx = pos >> 5;
     
123.                 if (memmap[ndx]&mask)
     
124.                         panic("dup alloc");
     
125.                 memmap[ndx] |= mask;
     
126.                 *base++ = pos;
     
127.                 freemem--;
     
128.         }
     
129.         return(size);
     
130. }
     
131. 
     
132. 
     
133. /*
     
134. * Free memory
     
135. */
     
136. memfree(base, size)
     
137. register int *base, size;
     
138. {
     
139.         register int ndx, mask;
     
140. 
     
141.         while(--size>=0) {
     
142.                 *base &= PG_PFNUM;
     
143.                 if (*base<firstfree || *base>=maxfree)
     
144.                         panic("bad mem free");
     
145.                 if (mem.m_free < NICMEM && mem.m_free >= 0)
     
146.                         mem.m_pnum[mem.m_free++] = *base;
     
147.                 ndx = *base >> 5;
     
148.                 mask = masktab[*base++ & 0x1f];
     
149.                 if ((memmap[ndx]&mask)==0)
     
150.                         panic("dup free");
     
151.                 memmap[ndx] &= ~mask;
     
152.                 freemem++;
     
153.         }
     
154. }
     
155. 
     
156. /*
     
157. * Initialize memory map
     
158. */
     
159. meminit(first, last)
     
160. {
     
161.         firstfree = first;
     
162.         maxfree = lastpos = last;
     
163.         freemem = last - first;
     
164.         mem.m_free = 0;
     
165. }
     

复制代码

willing_wlmq

man malloc应该可以看到头文件