/* A bitmap is used to track which physical memory pages are used, and which
- * are available for allocation by alloc_phys_page.
+ * are available for allocation by alloc_ppage.
*
* last_alloc_idx keeps track of the last 32bit element in the bitmap array
* where a free page was found. It's guaranteed that all the elements before
}
printf("Total usable RAM: %u.%u %s\n", total, 100 * rem / 1024, suffix[i]);
- bmsize = max_pg / 8; /* size of the useful bitmap in bytes */
+ /* size of the useful part of the bitmap in bytes padded to 4-byte
+ * boundaries to allow 32bit at a time operations.
+ */
+ bmsize = (max_pg / 32 + 1) * 4;
- /* mark all pages occupied by the bitmap as usef */
+ /* mark all pages occupied by the bitmap as used */
used_end = (uint32_t)bitmap + bmsize - 1;
- printf("marking pages up to %x (page: %d) as used\n", used_end, ADDR_TO_PAGE(used_end));
-
- for(i=0; i<=used_end; i++) {
+ max_pg = ADDR_TO_PAGE(used_end);
+ printf("marking pages up to %x (page: %d) as used\n", used_end, max_pg);
+ for(i=0; i<=max_pg; i++) {
mark_page(i, USED);
}
}
-/* alloc_phys_page finds the first available page of physical memory,
- * marks it as used in the bitmap, and returns its number. If there's
- * no unused physical page, -1 is returned.
- */
int alloc_ppage(void)
{
- int i, idx, max, intr_state;
+ return alloc_ppages(1);
+}
+
+/* free_ppage marks the physical page, free in the allocation bitmap.
+ *
+ * CAUTION: no checks are done that this page should actually be freed or not.
+ * If you call free_ppage with the address of some part of memory that was
+ * originally reserved due to it being in a memory hole or part of the kernel
+ * image or whatever, it will be subsequently allocatable by alloc_ppage.
+ */
+void free_ppage(int pg)
+{
+ int bmidx = BM_IDX(pg);
+
+ int intr_state = get_intr_flag();
+ disable_intr();
+
+ if(IS_FREE(pg)) {
+ panic("free_ppage(%d): I thought that was already free!\n", pg);
+ }
+
+ mark_page(pg, FREE);
+ if(bmidx < last_alloc_idx) {
+ last_alloc_idx = bmidx;
+ }
+
+ set_intr_flag(intr_state);
+}
+
+
+int alloc_ppages(int count)
+{
+ int i, pg, idx, max, intr_state, found_free = 0;
intr_state = get_intr_flag();
disable_intr();
while(idx <= max) {
/* if at least one bit is 0 then we have at least
- * one free page. find it and allocate it.
+ * one free page. find it and try to allocate a range starting from there
*/
if(bitmap[idx] != 0xffffffff) {
for(i=0; i<32; i++) {
- int pg = idx * 32 + i;
+ pg = idx * 32 + i;
if(IS_FREE(pg)) {
- mark_page(pg, USED);
-
- last_alloc_idx = idx;
-
- /*printf("alloc_phys_page() -> %x (page: %d)\n", PAGE_TO_ADDR(pg), pg);*/
-
- set_intr_flag(intr_state);
- return pg;
+ if(!found_free) {
+ last_alloc_idx = idx;
+ found_free = 1;
+ }
+
+ if(alloc_ppage_range(pg, count) != -1) {
+ set_intr_flag(intr_state);
+ return pg;
+ }
}
}
- panic("can't happen: alloc_ppage (mem.c)\n");
}
idx++;
}
return -1;
}
-/* free_ppage marks the physical page, free in the allocation bitmap.
- *
- * CAUTION: no checks are done that this page should actually be freed or not.
- * If you call free_phys_page with the address of some part of memory that was
- * originally reserved due to it being in a memory hole or part of the kernel
- * image or whatever, it will be subsequently allocatable by alloc_phys_page.
- */
-void free_ppage(int pg)
+void free_ppages(int pg0, int count)
{
- int bmidx = BM_IDX(pg);
+ int i;
- int intr_state = get_intr_flag();
- disable_intr();
-
- if(IS_FREE(pg)) {
- panic("free_ppage(%d): I thought that was already free!\n", pg);
+ for(i=0; i<count; i++) {
+ free_ppage(pg0++);
}
-
- mark_page(pg, FREE);
- if(bmidx < last_alloc_idx) {
- last_alloc_idx = bmidx;
- }
-
- set_intr_flag(intr_state);
}
-
int alloc_ppage_range(int start, int size)
{
int i, pg = start;
+ int intr_state;
+
+ intr_state = get_intr_flag();
+ disable_intr();
/* first validate that no page in the requested range is allocated */
for(i=0; i<size; i++) {
for(i=0; i<size; i++) {
mark_page(pg++, USED);
}
+
+ set_intr_flag(intr_state);
return 0;
}