47c40a10a1
added vm_memcpy_from_physical() and vm_memcpy_physical_page(), and
added respective functions to the vm_translation_map operations. The
architecture specific implementation can now decide how to implement
them most efficiently. Added generic implementations that can be used,
though.
* Changed vm_{get,put}_physical_page(). The former no longer accepts
flags (the only flag PHYSICAL_PAGE_DONT_WAIT wasn't needed anymore).
Instead it returns an implementation-specific handle that has to be
passed to the latter. Added vm_{get,put}_physical_page_current_cpu()
and *_debug() variants, that work only for the current CPU,
respectively when in the kernel debugger. Also adjusted the
vm_translation_map operations accordingly.
* Made consequent use of the physical memory operations in the source
tree.
* Also adjusted the m68k and ppc implementations with respect to the
vm_translation_map operation changes, but they are probably broken,
nevertheless.
* For x86 the generic physical page mapper isn't used anymore. It is
suboptimal in any case. For systems with small memory it is too much
overhead, since one can just map the complete physical memory (that's
not done yet, though). For systems with large memory it counteracts
the VM strategy to reuse the least recently used pages. Since those
pages will most likely not be mapped by the page mapper anymore, it
will keep remapping chunks. This was also the reason why building
Haiku in Haiku was significantly faster with only 256 MB RAM (since
that much could be kept mapped all the time).
Now we're using a different strategy: We have small pools of virtual
page slots per CPU that are used for the physical page operations
(memset_physical(), memcpy_*_physical()) with CPU-pinned thread.
Furthermore we have four slots per translation map, which are used to
map page tables.
These changes speed up the Haiku image build in Haiku significantly. On
my Core2 Duo 2.2 GHz 2 GB machine about 40% to 20 min 40 s (KDEBUG
disabled, block cache debug disabled). Still more than factor 3 slower
than FreeBSD and Linux, though.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28244 a95241bf-73f2-0310-859d-f6bbb57e9c96
77 lines
2.8 KiB
C
77 lines
2.8 KiB
C
/*
|
|
* Copyright 2002-2007, Haiku. All rights reserved.
|
|
* Distributed under the terms of the MIT License.
|
|
*
|
|
* Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
|
|
* Distributed under the terms of the NewOS License.
|
|
*/
|
|
#ifndef KERNEL_VM_TRANSLATION_MAP_H
|
|
#define KERNEL_VM_TRANSLATION_MAP_H
|
|
|
|
|
|
#include <kernel.h>
|
|
#include <lock.h>
|
|
|
|
|
|
struct kernel_args;
|
|
|
|
|
|
typedef struct vm_translation_map {
|
|
struct vm_translation_map *next;
|
|
struct vm_translation_map_ops *ops;
|
|
recursive_lock lock;
|
|
int32 map_count;
|
|
struct vm_translation_map_arch_info *arch_data;
|
|
} vm_translation_map;
|
|
|
|
|
|
// table of operations the vm may want to do to this mapping
|
|
typedef struct vm_translation_map_ops {
|
|
void (*destroy)(vm_translation_map *map);
|
|
status_t (*lock)(vm_translation_map *map);
|
|
status_t (*unlock)(vm_translation_map *map);
|
|
size_t (*map_max_pages_need)(vm_translation_map *map, addr_t start, addr_t end);
|
|
status_t (*map)(vm_translation_map *map, addr_t va, addr_t pa,
|
|
uint32 attributes);
|
|
status_t (*unmap)(vm_translation_map *map, addr_t start, addr_t end);
|
|
status_t (*query)(vm_translation_map *map, addr_t va, addr_t *_outPhysical,
|
|
uint32 *_outFlags);
|
|
status_t (*query_interrupt)(vm_translation_map *map, addr_t va,
|
|
addr_t *_outPhysical, uint32 *_outFlags);
|
|
addr_t (*get_mapped_size)(vm_translation_map*);
|
|
status_t (*protect)(vm_translation_map *map, addr_t base, addr_t top,
|
|
uint32 attributes);
|
|
status_t (*clear_flags)(vm_translation_map *map, addr_t va, uint32 flags);
|
|
void (*flush)(vm_translation_map *map);
|
|
|
|
// get/put virtual address for physical page -- will be usuable on all CPUs
|
|
// (usually more expensive than the *_current_cpu() versions)
|
|
status_t (*get_physical_page)(addr_t physicalAddress,
|
|
addr_t *_virtualAddress, void **handle);
|
|
status_t (*put_physical_page)(addr_t virtualAddress, void *handle);
|
|
|
|
// get/put virtual address for physical page -- thread must be pinned the
|
|
// whole time
|
|
status_t (*get_physical_page_current_cpu)(addr_t physicalAddress,
|
|
addr_t *_virtualAddress, void **handle);
|
|
status_t (*put_physical_page_current_cpu)(addr_t virtualAddress,
|
|
void *handle);
|
|
|
|
// get/put virtual address for physical in KDL
|
|
status_t (*get_physical_page_debug)(addr_t physicalAddress,
|
|
addr_t *_virtualAddress, void **handle);
|
|
status_t (*put_physical_page_debug)(addr_t virtualAddress, void *handle);
|
|
|
|
// memory operations on pages
|
|
status_t (*memset_physical)(addr_t address, int value, size_t length);
|
|
status_t (*memcpy_from_physical)(void* to, addr_t from, size_t length,
|
|
bool user);
|
|
status_t (*memcpy_to_physical)(addr_t to, const void* from, size_t length,
|
|
bool user);
|
|
void (*memcpy_physical_page)(addr_t to, addr_t from);
|
|
} vm_translation_map_ops;
|
|
|
|
#include <arch/vm_translation_map.h>
|
|
|
|
#endif /* KERNEL_VM_TRANSLATION_MAP_H */
|