Annotation of prex-old/sys/mem/page.c, Revision 1.1.1.1
1.1 nbrk 1: /*-
2: * Copyright (c) 2005-2006, Kohsuke Ohtani
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. Neither the name of the author nor the names of any co-contributors
14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: */
29:
30: /*
31: * page.c - physical page allocator
32: */
33:
34: /*
35: * This is a simple list-based page allocator.
36: *
37: * When the remaining page is exhausted, what should we do ?
38: * If the system can stop with panic() here, the error check of many
39: * portions in kernel is not necessary, and kernel code can become
40: * more simple. But, in general, even if a page is exhausted,
41: * a kernel can not be stopped but it should return an error and
42: * continue processing.
43: * If the memory becomes short during boot time, kernel and drivers
44: * can use panic() in that case.
45: */
46:
47: #include <kernel.h>
48: #include <page.h>
49: #include <sched.h>
50:
51: /*
52: * page_block is put on the head of the first page of
53: * each free block.
54: */
55: struct page_block {
56: struct page_block *next;
57: struct page_block *prev;
58: size_t size; /* number of bytes of this block */
59: };
60:
61: static struct page_block page_head; /* first free block */
62:
63: static size_t total_bytes;
64: static size_t used_bytes;
65:
66: /*
67: * page_alloc - allocate continuous pages of the specified size.
68: * @size: number of bytes to allocate
69: *
70: * This routine returns the physical address of a new free page block,
71: * or returns NULL on failure. The requested size is automatically
72: * round up to the page boundary.
73: * The allocated memory is _not_ filled with 0.
74: */
75: void *
76: page_alloc(size_t size)
77: {
78: struct page_block *blk, *tmp;
79:
80: ASSERT(size != 0);
81:
82: sched_lock();
83:
84: /*
85: * Find the free block that has enough size.
86: */
87: size = (size_t)PAGE_ALIGN(size);
88: blk = &page_head;
89: do {
90: blk = blk->next;
91: if (blk == &page_head) {
92: sched_unlock();
93: printk("page_alloc: out of memory\n");
94: return NULL; /* Not found. */
95: }
96: } while (blk->size < size);
97:
98: /*
99: * If found block size is exactly same with requested,
100: * just remove it from a free list. Otherwise, the
101: * found block is divided into two and first half is
102: * used for allocation.
103: */
104: if (blk->size == size) {
105: blk->prev->next = blk->next;
106: blk->next->prev = blk->prev;
107: } else {
108: tmp = (struct page_block *)((u_long)blk + size);
109: tmp->size = blk->size - size;
110: tmp->prev = blk->prev;
111: tmp->next = blk->next;
112: blk->prev->next = tmp;
113: blk->next->prev = tmp;
114: }
115: used_bytes += size;
116: sched_unlock();
117:
118: return virt_to_phys(blk);
119: }
120:
121: /*
122: * Free page block.
123: *
124: * This allocator does not maintain the size of allocated page block.
125: * The caller must provide the size information of the block.
126: */
127: void
128: page_free(void *addr, size_t size)
129: {
130: struct page_block *blk, *prev;
131:
132: ASSERT(addr != NULL);
133: ASSERT(size != 0);
134:
135: sched_lock();
136:
137: size = (size_t)PAGE_ALIGN(size);
138: blk = phys_to_virt(addr);
139:
140: /*
141: * Find the target position in list.
142: */
143: for (prev = &page_head; prev->next < blk; prev = prev->next) {
144: if (prev->next == &page_head)
145: break;
146: }
147: #ifdef DEBUG
148: if (prev != &page_head)
149: ASSERT((u_long)prev + prev->size <= (u_long)blk);
150: if (prev->next != &page_head)
151: ASSERT((u_long)blk + size <= (u_long)prev->next);
152: #endif /* DEBUG */
153:
154: /*
155: * Insert new block into list.
156: */
157: blk->size = size;
158: blk->prev = prev;
159: blk->next = prev->next;
160: prev->next->prev = blk;
161: prev->next = blk;
162:
163: /*
164: * If the adjoining block is free, it combines and
165: * is made on block.
166: */
167: if (blk->next != &page_head &&
168: ((u_long)blk + blk->size) == (u_long)blk->next) {
169: blk->size += blk->next->size;
170: blk->next = blk->next->next;
171: blk->next->prev = blk;
172: }
173: if (blk->prev != &page_head &&
174: (u_long)blk->prev + blk->prev->size == (u_long)blk) {
175: blk->prev->size += blk->size;
176: blk->prev->next = blk->next;
177: blk->next->prev = blk->prev;
178: }
179: used_bytes -= size;
180: sched_unlock();
181: }
182:
183: /*
184: * The function to reserve pages in specific address.
185: * Return 0 on success, or -1 on failure
186: */
187: int
188: page_reserve(void *addr, size_t size)
189: {
190: struct page_block *blk, *tmp;
191: u_long end;
192:
193: if (size == 0)
194: return 0;
195:
196: addr = phys_to_virt(addr);
197: end = PAGE_ALIGN((u_long)addr + size);
198: addr = (void *)PAGE_TRUNC(addr);
199: size = (size_t)(end - (u_long)addr);
200:
201: /*
202: * Find the block which includes specified block.
203: */
204: blk = page_head.next;
205: for (;;) {
206: if (blk == &page_head)
207: panic("page_reserve");
208: if ((u_long)blk <= (u_long)addr
209: && end <= (u_long)blk + blk->size)
210: break;
211: blk = blk->next;
212: }
213: if ((u_long)blk == (u_long)addr && blk->size == size) {
214: /*
215: * Unlink the block from free list.
216: */
217: blk->prev->next = blk->next;
218: blk->next->prev = blk->prev;
219: } else {
220: /*
221: * Split this block.
222: */
223: if ((u_long)blk + blk->size != end) {
224: tmp = (struct page_block *)end;
225: tmp->size = (size_t)((u_long)blk + blk->size - end);
226: tmp->next = blk->next;
227: tmp->prev = blk;
228:
229: blk->size -= tmp->size;
230: blk->next->prev = tmp;
231: blk->next = tmp;
232: }
233: if ((u_long)blk == (u_long)addr) {
234: blk->prev->next = blk->next;
235: blk->next->prev = blk->prev;
236: } else
237: blk->size = (size_t)((u_long)addr - (u_long)blk);
238: }
239: used_bytes += size;
240: return 0;
241: }
242:
243: void
244: page_info(size_t *total, size_t *free)
245: {
246:
247: *total = total_bytes;
248: *free = total_bytes - used_bytes;
249: }
250:
251: #if defined(DEBUG) && defined(CONFIG_KDUMP)
252: void
253: page_dump(void)
254: {
255: struct page_block *blk;
256: void *addr;
257: struct mem_map *mem;
258: struct module *img;
259: int i;
260:
261: printk("Page dump:\n");
262: printk(" free pages:\n");
263: printk(" start end size\n");
264: printk(" -------- -------- --------\n");
265:
266: blk = page_head.next;
267: do {
268: addr = virt_to_phys(blk);
269: printk(" %08x - %08x %8x\n", addr, (u_long)addr + blk->size,
270: blk->size);
271: blk = blk->next;
272: } while (blk != &page_head);
273: printk(" used=%dK free=%dK total=%dK\n\n",
274: used_bytes / 1024, (total_bytes - used_bytes) / 1024,
275: total_bytes / 1024);
276:
277: img = (struct module *)&boot_info->kernel;
278: printk(" kernel: %08x - %08x (%dK)\n",
279: img->phys, img->phys + img->size, img->size / 1024);
280:
281: img = (struct module *)&boot_info->driver;
282: printk(" driver: %08x - %08x (%dK)\n",
283: img->phys, img->phys + img->size, img->size / 1024);
284:
285: for (i = 0; i < NRESMEM; i++) {
286: mem = &boot_info->reserved[i];
287: if (mem->size != 0) {
288: printk(" reserved: %08x - %08x (%dK)\n",
289: mem->start, mem->start + mem->size,
290: mem->size / 1024);
291: }
292: }
293: #ifdef CONFIG_RAMDISK
294: mem = (struct mem_map *)&boot_info->ram_disk;
295: printk(" RAM disk: %08x - %08x (%dK)\n",
296: mem->start, mem->start + mem->size, mem->size / 1024);
297: #endif
298: }
299: #endif
300:
301: /*
302: * Initialize page allocator.
303: * page_init() must be called prior to other memory manager's
304: * initializations.
305: */
306: void
307: page_init(void)
308: {
309: struct page_block *blk;
310: struct mem_map *mem;
311: int i;
312:
313: printk("Memory: base=%x size=%dK\n", boot_info->main_mem.start,
314: boot_info->main_mem.size / 1024);
315:
316: /*
317: * First, create one block containing all memory pages.
318: */
319: blk = (struct page_block *)boot_info->main_mem.start;
320: blk = phys_to_virt(blk);
321: blk->size = boot_info->main_mem.size;
322: if (blk->size == 0)
323: panic("page_init: no pages");
324: blk->prev = blk->next = &page_head;
325: page_head.next = page_head.prev = blk;
326:
327: /*
328: * Then, the system reserved pages are marked as a used block.
329: */
330: for (i = 0; i < NRESMEM; i++) {
331: mem = &boot_info->reserved[i];
332: if (mem->size != 0)
333: page_reserve((void *)mem->start, mem->size);
334: }
335: total_bytes = boot_info->main_mem.size - used_bytes;
336: used_bytes = 0;
337:
338: /*
339: * Reserve pages for all boot modules.
340: */
341: mem = &boot_info->modules;
342: page_reserve((void *)mem->start, mem->size);
343: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to page.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / sys / mem