This source file includes following definitions.
- __bad_pagetable
- __bad_page
- show_mem
- paging_init
- mem_init
- si_meminfo
1
2
3
4
5
6
7 #include <linux/config.h>
8 #include <linux/signal.h>
9 #include <linux/sched.h>
10 #include <linux/head.h>
11 #include <linux/kernel.h>
12 #include <linux/errno.h>
13 #include <linux/string.h>
14 #include <linux/types.h>
15 #include <linux/ptrace.h>
16 #include <linux/mman.h>
17 #include <linux/mm.h>
18 #include <linux/swap.h>
19 #include <linux/smp.h>
20 #ifdef CONFIG_BLK_DEV_INITRD
21 #include <linux/blk.h>
22 #endif
23
24 #include <asm/system.h>
25 #include <asm/segment.h>
26 #include <asm/pgtable.h>
27 #include <asm/dma.h>
28
29
30
31
32 #ifdef __SMP__
33 #undef USE_PENTIUM_MM
34 #endif
35
36 extern void die_if_kernel(char *,struct pt_regs *,long);
37 extern void show_net_buffers(void);
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52 pte_t * __bad_pagetable(void)
53 {
54 extern char empty_bad_page_table[PAGE_SIZE];
55
56 __asm__ __volatile__("cld ; rep ; stosl":
57 :"a" (pte_val(BAD_PAGE)),
58 "D" ((long) empty_bad_page_table),
59 "c" (PAGE_SIZE/4)
60 :"di","cx");
61 return (pte_t *) empty_bad_page_table;
62 }
63
64 pte_t __bad_page(void)
65 {
66 extern char empty_bad_page[PAGE_SIZE];
67
68 __asm__ __volatile__("cld ; rep ; stosl":
69 :"a" (0),
70 "D" ((long) empty_bad_page),
71 "c" (PAGE_SIZE/4)
72 :"di","cx");
73 return pte_mkdirty(mk_pte((unsigned long) empty_bad_page, PAGE_SHARED));
74 }
75
76 void show_mem(void)
77 {
78 int i,free = 0,total = 0,reserved = 0;
79 int shared = 0;
80
81 printk("Mem-info:\n");
82 show_free_areas();
83 printk("Free swap: %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
84 i = high_memory >> PAGE_SHIFT;
85 while (i-- > 0) {
86 total++;
87 if (mem_map[i].reserved)
88 reserved++;
89 else if (!mem_map[i].count)
90 free++;
91 else
92 shared += mem_map[i].count-1;
93 }
94 printk("%d pages of RAM\n",total);
95 printk("%d free pages\n",free);
96 printk("%d reserved pages\n",reserved);
97 printk("%d pages shared\n",shared);
98 show_buffers();
99 #ifdef CONFIG_NET
100 show_net_buffers();
101 #endif
102 }
103
104 extern unsigned long free_area_init(unsigned long, unsigned long);
105
106
107
108
109
110
111
112
113 unsigned long paging_init(unsigned long start_mem, unsigned long end_mem)
114 {
115 pgd_t * pg_dir;
116 pte_t * pg_table;
117 unsigned long tmp;
118 unsigned long address;
119
120
121
122
123
124
125
126
127 #if 0
128 memset((void *) 0, 0, PAGE_SIZE);
129 #endif
130 #ifdef __SMP__
131 if (!smp_scan_config(0x0,0x400))
132 {
133
134
135
136
137 if (!smp_scan_config(639*0x400,0x400))
138 smp_scan_config(0xF0000,0x10000);
139 }
140
141
142
143
144
145
146
147 #endif
148 #ifdef TEST_VERIFY_AREA
149 wp_works_ok = 0;
150 #endif
151 start_mem = PAGE_ALIGN(start_mem);
152 address = 0;
153 pg_dir = swapper_pg_dir;
154 while (address < end_mem) {
155 #ifdef USE_PENTIUM_MM
156 if (address <= end_mem + 4*1024*1024 &&
157 (x86_capability & 8)) {
158 #ifdef GAS_KNOWS_CR4
159 __asm__("movl %%cr4,%%eax\n\t"
160 "orl $16,%%eax\n\t"
161 "movl %%eax,%%cr4"
162 : : :"ax");
163 #else
164 __asm__(".byte 0x0f,0x20,0xe0\n\t"
165 "orl $16,%%eax\n\t"
166 ".byte 0x0f,0x22,0xe0"
167 : : :"ax");
168 #endif
169 wp_works_ok = 1;
170 pgd_val(pg_dir[0]) = _PAGE_TABLE | _PAGE_4M | address;
171 pgd_val(pg_dir[768]) = _PAGE_TABLE | _PAGE_4M | address;
172 pg_dir++;
173 address += 4*1024*1024;
174 continue;
175 }
176 #endif
177
178 pg_table = (pte_t *) (PAGE_MASK & pgd_val(pg_dir[768]));
179 if (!pg_table) {
180 pg_table = (pte_t *) start_mem;
181 start_mem += PAGE_SIZE;
182 }
183
184
185 pgd_val(pg_dir[0]) = _PAGE_TABLE | (unsigned long) pg_table;
186 pgd_val(pg_dir[768]) = _PAGE_TABLE | (unsigned long) pg_table;
187 pg_dir++;
188 for (tmp = 0 ; tmp < PTRS_PER_PTE ; tmp++,pg_table++) {
189 if (address < end_mem)
190 set_pte(pg_table, mk_pte(address, PAGE_SHARED));
191 else
192 pte_clear(pg_table);
193 address += PAGE_SIZE;
194 }
195 }
196 flush_tlb();
197 return free_area_init(start_mem, end_mem);
198 }
199
200 void mem_init(unsigned long start_mem, unsigned long end_mem)
201 {
202 unsigned long start_low_mem = PAGE_SIZE;
203 int codepages = 0;
204 int reservedpages = 0;
205 int datapages = 0;
206 unsigned long tmp;
207 extern int _etext;
208
209 end_mem &= PAGE_MASK;
210 high_memory = end_mem;
211
212
213 memset(empty_zero_page, 0, PAGE_SIZE);
214
215
216 start_low_mem = PAGE_ALIGN(start_low_mem);
217
218 #ifdef __SMP__
219
220
221
222 start_low_mem += PAGE_SIZE;
223 start_low_mem = smp_alloc_memory(start_low_mem);
224 #endif
225 start_mem = PAGE_ALIGN(start_mem);
226
227
228
229
230
231
232 while (start_low_mem < 0x9f000) {
233 mem_map[MAP_NR(start_low_mem)].reserved = 0;
234 start_low_mem += PAGE_SIZE;
235 }
236
237 while (start_mem < high_memory) {
238 mem_map[MAP_NR(start_mem)].reserved = 0;
239 start_mem += PAGE_SIZE;
240 }
241 for (tmp = 0 ; tmp < high_memory ; tmp += PAGE_SIZE) {
242 if (tmp >= MAX_DMA_ADDRESS)
243 mem_map[MAP_NR(tmp)].dma = 0;
244 if (mem_map[MAP_NR(tmp)].reserved) {
245 if (tmp >= 0xA0000 && tmp < 0x100000)
246 reservedpages++;
247 else if (tmp < (unsigned long) &_etext)
248 codepages++;
249 else
250 datapages++;
251 continue;
252 }
253 mem_map[MAP_NR(tmp)].count = 1;
254 #ifdef CONFIG_BLK_DEV_INITRD
255 if (!initrd_start || (tmp < initrd_start || tmp >=
256 initrd_end))
257 #endif
258 free_page(tmp);
259 }
260 tmp = nr_free_pages << PAGE_SHIFT;
261 printk("Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data)\n",
262 tmp >> 10,
263 high_memory >> 10,
264 codepages << (PAGE_SHIFT-10),
265 reservedpages << (PAGE_SHIFT-10),
266 datapages << (PAGE_SHIFT-10));
267
268 if (wp_works_ok < 0) {
269 pg0[0] = pte_val(mk_pte(0, PAGE_READONLY));
270 flush_tlb();
271 __asm__ __volatile__("movb 0,%%al ; movb %%al,0": : :"ax", "memory");
272 pg0[0] = 0;
273 flush_tlb();
274 if (wp_works_ok < 0)
275 wp_works_ok = 0;
276 }
277 return;
278 }
279
280 void si_meminfo(struct sysinfo *val)
281 {
282 int i;
283
284 i = high_memory >> PAGE_SHIFT;
285 val->totalram = 0;
286 val->sharedram = 0;
287 val->freeram = nr_free_pages << PAGE_SHIFT;
288 val->bufferram = buffermem;
289 while (i-- > 0) {
290 if (mem_map[i].reserved)
291 continue;
292 val->totalram++;
293 if (!mem_map[i].count)
294 continue;
295 val->sharedram += mem_map[i].count-1;
296 }
297 val->totalram <<= PAGE_SHIFT;
298 val->sharedram <<= PAGE_SHIFT;
299 return;
300 }