Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Renamed fields of the kernel_args structure.

Browse Source 
Commented out the page_daemon to remove a warning.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@4968 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler 2003-10-07 23:09:21 +00:00
parent 9e88f0cfd2
commit b55d9c74f1
1 changed files with 37 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/kernel/core/vm/vm_page.c
View File

@ -16,7 +16,7 @@
#include <smp.h> #include <smp.h>
#include <OS.h> #include <OS.h>
#include <Errors.h> #include <Errors.h>
#include <boot/stage2.h> #include <boot/kernel_args.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
@ -113,6 +113,7 @@ static void move_page_to_queue(page_queue *from_q, page_queue *to_q, vm_page *pa
} }
#if 0
static int pageout_daemon() static int pageout_daemon()
{ {
int state; int state;
@ -188,6 +189,7 @@ static int pageout_daemon()
vm_cache_release_ref(page->cache_ref); vm_cache_release_ref(page->cache_ref);
} }
} }
#endif
int vm_page_init(kernel_args *ka) int vm_page_init(kernel_args *ka)
{ {
@ -211,13 +213,13 @@ int vm_page_init(kernel_args *ka)
page_active_queue.tail = NULL; page_active_queue.tail = NULL;
page_active_queue.count = 0; page_active_queue.count = 0;
// calculate the size of memory by looking at the phys_mem_range array // calculate the size of memory by looking at the physical_memory_range array
{ {
unsigned int last_phys_page = 0; unsigned int last_phys_page = 0;
physical_page_offset = ka->phys_mem_range[0].start / PAGE_SIZE; physical_page_offset = ka->physical_memory_range[0].start / PAGE_SIZE;
for (i = 0; i<ka->num_phys_mem_ranges; i++) { for (i = 0; i<ka->num_physical_memory_ranges; i++) {
last_phys_page = (ka->phys_mem_range[i].start + ka->phys_mem_range[i].size) / PAGE_SIZE - 1; last_phys_page = (ka->physical_memory_range[i].start + ka->physical_memory_range[i].size) / PAGE_SIZE - 1;
} }
dprintf("first phys page = 0x%lx, last 0x%x\n", physical_page_offset, last_phys_page); dprintf("first phys page = 0x%lx, last 0x%x\n", physical_page_offset, last_phys_page);
num_pages = last_phys_page - physical_page_offset; num_pages = last_phys_page - physical_page_offset;
@ -241,9 +243,9 @@ int vm_page_init(kernel_args *ka)
dprintf("initialized table\n"); dprintf("initialized table\n");
// mark some of the page ranges inuse // mark some of the page ranges inuse
for(i = 0; i < ka->num_phys_alloc_ranges; i++) { for (i = 0; i < ka->num_physical_allocated_ranges; i++) {
vm_mark_page_range_inuse(ka->phys_alloc_range[i].start / PAGE_SIZE, vm_mark_page_range_inuse(ka->physical_allocated_range[i].start / PAGE_SIZE,
ka->phys_alloc_range[i].size / PAGE_SIZE); ka->physical_allocated_range[i].size / PAGE_SIZE);
} }
// set the global max_commit variable // set the global max_commit variable
@ -777,31 +779,32 @@ static addr vm_alloc_vspace_from_ka_struct(kernel_args *ka, unsigned int size)
size = PAGE_ALIGN(size); size = PAGE_ALIGN(size);
// find a slot in the virtual allocation addr range // find a slot in the virtual allocation addr range
for(i=1; i<ka->num_virt_alloc_ranges; i++) { for (i = 1; i < ka->num_virtual_allocated_ranges; i++) {
last_valloc_entry = i; last_valloc_entry = i;
// check to see if the space between this one and the last is big enough // check to see if the space between this one and the last is big enough
if(ka->virt_alloc_range[i].start - if (ka->virtual_allocated_range[i].start
(ka->virt_alloc_range[i-1].start + ka->virt_alloc_range[i-1].size) >= size) { - (ka->virtual_allocated_range[i-1].start
+ ka->virtual_allocated_range[i-1].size) >= size) {
spot = ka->virt_alloc_range[i-1].start + ka->virt_alloc_range[i-1].size; spot = ka->virtual_allocated_range[i-1].start + ka->virtual_allocated_range[i-1].size;
ka->virt_alloc_range[i-1].size += size; ka->virtual_allocated_range[i-1].size += size;
goto out; goto out;
} }
} }
if(spot == 0) { if (spot == 0) {
// we hadn't found one between allocation ranges. this is ok. // we hadn't found one between allocation ranges. this is ok.
// see if there's a gap after the last one // see if there's a gap after the last one
if(ka->virt_alloc_range[last_valloc_entry].start + ka->virt_alloc_range[last_valloc_entry].size + size <= if (ka->virtual_allocated_range[last_valloc_entry].start
KERNEL_BASE + (KERNEL_SIZE - 1)) { + ka->virtual_allocated_range[last_valloc_entry].size + size
spot = ka->virt_alloc_range[last_valloc_entry].start + ka->virt_alloc_range[last_valloc_entry].size; <= KERNEL_BASE + (KERNEL_SIZE - 1)) {
ka->virt_alloc_range[last_valloc_entry].size += size; spot = ka->virtual_allocated_range[last_valloc_entry].start + ka->virtual_allocated_range[last_valloc_entry].size;
ka->virtual_allocated_range[last_valloc_entry].size += size;
goto out; goto out;
} }
// see if there's a gap before the first one // see if there's a gap before the first one
if(ka->virt_alloc_range[0].start > KERNEL_BASE) { if (ka->virtual_allocated_range[0].start > KERNEL_BASE) {
if(ka->virt_alloc_range[0].start - KERNEL_BASE >= size) { if (ka->virtual_allocated_range[0].start - KERNEL_BASE >= size) {
ka->virt_alloc_range[0].start -= size; ka->virtual_allocated_range[0].start -= size;
spot = ka->virt_alloc_range[0].start; spot = ka->virtual_allocated_range[0].start;
goto out; goto out;
} }
} }
@ -816,9 +819,10 @@ static bool is_page_in_phys_range(kernel_args *ka, addr paddr)
{ {
unsigned int i; unsigned int i;
for(i=0; i<ka->num_phys_mem_ranges; i++) { for (i = 0; i < ka->num_physical_memory_ranges; i++) {
if(paddr >= ka->phys_mem_range[i].start && if (paddr >= ka->physical_memory_range[i].start
paddr < ka->phys_mem_range[i].start + ka->phys_mem_range[i].size) { && paddr < ka->physical_memory_range[i].start
+ ka->physical_memory_range[i].size) {
return true; return true;
} }
} }
@ -829,21 +833,21 @@ static addr vm_alloc_ppage_from_kernel_struct(kernel_args *ka)
{ {
unsigned int i; unsigned int i;
for(i=0; i<ka->num_phys_alloc_ranges; i++) { for (i = 0; i < ka->num_physical_allocated_ranges; i++) {
addr next_page; addr next_page;
next_page = ka->phys_alloc_range[i].start + ka->phys_alloc_range[i].size; next_page = ka->physical_allocated_range[i].start + ka->physical_allocated_range[i].size;
// see if the page after the next allocated paddr run can be allocated // see if the page after the next allocated paddr run can be allocated
if(i + 1 < ka->num_phys_alloc_ranges && ka->phys_alloc_range[i+1].size != 0) { if (i + 1 < ka->num_physical_allocated_ranges && ka->physical_allocated_range[i+1].size != 0) {
// see if the next page will collide with the next allocated range // see if the next page will collide with the next allocated range
if(next_page >= ka->phys_alloc_range[i+1].start) if (next_page >= ka->physical_allocated_range[i+1].start)
continue; continue;
} }
// see if the next physical page fits in the memory block // see if the next physical page fits in the memory block
if(is_page_in_phys_range(ka, next_page)) { if (is_page_in_phys_range(ka, next_page)) {
// we got one! // we got one!
ka->phys_alloc_range[i].size += PAGE_SIZE; ka->physical_allocated_range[i].size += PAGE_SIZE;
return ((ka->phys_alloc_range[i].start + ka->phys_alloc_range[i].size - PAGE_SIZE) / PAGE_SIZE); return ((ka->physical_allocated_range[i].start + ka->physical_allocated_range[i].size - PAGE_SIZE) / PAGE_SIZE);
} }
} }