1/*
2 * Copyright 2002-2009, Axel D��rfler, axeld@pinc-software.de.
3 * Distributed under the terms of the MIT License.
4 *
5 * Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
6 * Distributed under the terms of the NewOS License.
7 */
8#ifndef _KERNEL_VM_VM_H
9#define _KERNEL_VM_VM_H
10
11#include <OS.h>
12
13#include <arch/vm.h>
14#include <vm_defs.h>
15#include <vm/vm_types.h>
16
17
18struct generic_io_vec;
19struct kernel_args;
20struct ObjectCache;
21struct system_memory_info;
22struct VMAddressSpace;
23struct VMArea;
24struct VMCache;
25struct vm_page;
26struct vnode;
27struct VMPageWiringInfo;
28
29
30// area creation flags
31#define CREATE_AREA_DONT_WAIT			0x01
32#define CREATE_AREA_UNMAP_ADDRESS_RANGE	0x02
33#define CREATE_AREA_DONT_CLEAR			0x04
34#define CREATE_AREA_PRIORITY_VIP		0x08
35#define CREATE_AREA_DONT_COMMIT_MEMORY	0x10
36
37// memory/page allocation priorities
38#define VM_PRIORITY_USER	0
39#define VM_PRIORITY_SYSTEM	1
40#define VM_PRIORITY_VIP		2
41
42// page reserves
43#define VM_PAGE_RESERVE_USER	512
44#define VM_PAGE_RESERVE_SYSTEM	128
45
46// memory reserves
47#define VM_MEMORY_RESERVE_USER		(VM_PAGE_RESERVE_USER * B_PAGE_SIZE)
48#define VM_MEMORY_RESERVE_SYSTEM	(VM_PAGE_RESERVE_SYSTEM * B_PAGE_SIZE)
49
50
51extern struct ObjectCache* gPageMappingsObjectCache;
52
53
54#ifdef __cplusplus
55extern "C" {
56#endif
57
58// startup only
59status_t vm_init(struct kernel_args *args);
60status_t vm_init_post_sem(struct kernel_args *args);
61status_t vm_init_post_thread(struct kernel_args *args);
62status_t vm_init_post_modules(struct kernel_args *args);
63void vm_free_kernel_args(struct kernel_args *args);
64void vm_free_unused_boot_loader_range(addr_t start, addr_t end);
65page_num_t vm_allocate_early_physical_page(kernel_args *args);
66addr_t vm_allocate_early(struct kernel_args *args, size_t virtualSize,
67			size_t physicalSize, uint32 attributes, addr_t alignment);
68
69void slab_init(struct kernel_args *args);
70void slab_init_post_area();
71void slab_init_post_sem();
72void slab_init_post_thread();
73
74// to protect code regions with interrupts turned on
75void permit_page_faults(void);
76void forbid_page_faults(void);
77
78// private kernel only extension (should be moved somewhere else):
79area_id create_area_etc(team_id team, const char *name, size_t size,
80			uint32 lock, uint32 protection, uint32 flags, uint32 guardSize,
81			const virtual_address_restrictions* virtualAddressRestrictions,
82			const physical_address_restrictions* physicalAddressRestrictions,
83			void **_address);
84area_id transfer_area(area_id id, void** _address, uint32 addressSpec,
85			team_id target, bool kernel);
86
87const char* vm_cache_type_to_string(int32 type);
88
89status_t vm_prepare_kernel_area_debug_protection(area_id id, void** cookie);
90status_t vm_set_kernel_area_debug_protection(void* cookie, void* _address,
91			size_t size, uint32 protection);
92
93status_t vm_block_address_range(const char* name, void* address, addr_t size);
94status_t vm_unreserve_address_range(team_id team, void *address, addr_t size);
95status_t vm_reserve_address_range(team_id team, void **_address,
96			uint32 addressSpec, addr_t size, uint32 flags);
97area_id vm_create_anonymous_area(team_id team, const char* name, addr_t size,
98			uint32 wiring, uint32 protection, uint32 flags, addr_t guardSize,
99			const virtual_address_restrictions* virtualAddressRestrictions,
100			const physical_address_restrictions* physicalAddressRestrictions,
101			bool kernel, void** _address);
102area_id vm_map_physical_memory(team_id team, const char *name, void **address,
103			uint32 addressSpec, addr_t size, uint32 protection,
104			phys_addr_t physicalAddress, bool alreadyWired);
105area_id vm_map_physical_memory_vecs(team_id team, const char* name,
106	void** _address, uint32 addressSpec, addr_t* _size, uint32 protection,
107	struct generic_io_vec* vecs, uint32 vecCount);
108area_id vm_map_file(team_id aid, const char *name, void **address,
109			uint32 addressSpec, addr_t size, uint32 protection, uint32 mapping,
110			bool unmapAddressRange, int fd, off_t offset);
111struct VMCache *vm_area_get_locked_cache(struct VMArea *area);
112void vm_area_put_locked_cache(struct VMCache *cache);
113area_id vm_create_null_area(team_id team, const char *name, void **address,
114			uint32 addressSpec, addr_t size, uint32 flags);
115area_id vm_copy_area(team_id team, const char *name, void **_address,
116			uint32 addressSpec, area_id sourceID);
117area_id vm_clone_area(team_id team, const char *name, void **address,
118			uint32 addressSpec, uint32 protection, uint32 mapping,
119			area_id sourceArea, bool kernel);
120status_t vm_delete_area(team_id teamID, area_id areaID, bool kernel);
121status_t vm_create_vnode_cache(struct vnode *vnode, struct VMCache **_cache);
122status_t vm_set_area_memory_type(area_id id, phys_addr_t physicalBase,
123			uint32 type);
124status_t vm_set_area_protection(team_id team, area_id areaID,
125			uint32 newProtection, bool kernel);
126status_t vm_get_page_mapping(team_id team, addr_t vaddr, phys_addr_t *paddr);
127bool vm_test_map_modification(struct vm_page *page);
128void vm_clear_map_flags(struct vm_page *page, uint32 flags);
129void vm_remove_all_page_mappings(struct vm_page *page);
130int32 vm_clear_page_mapping_accessed_flags(struct vm_page *page);
131int32 vm_remove_all_page_mappings_if_unaccessed(struct vm_page *page);
132status_t vm_wire_page(team_id team, addr_t address, bool writable,
133			struct VMPageWiringInfo* info);
134void vm_unwire_page(struct VMPageWiringInfo* info);
135
136status_t vm_get_physical_page(phys_addr_t paddr, addr_t* vaddr, void** _handle);
137status_t vm_put_physical_page(addr_t vaddr, void* handle);
138status_t vm_get_physical_page_current_cpu(phys_addr_t paddr, addr_t* vaddr,
139			void** _handle);
140status_t vm_put_physical_page_current_cpu(addr_t vaddr, void* handle);
141status_t vm_get_physical_page_debug(phys_addr_t paddr, addr_t* vaddr,
142			void** _handle);
143status_t vm_put_physical_page_debug(addr_t vaddr, void* handle);
144
145void vm_get_info(system_info *info);
146uint32 vm_num_page_faults(void);
147off_t vm_available_memory(void);
148off_t vm_available_not_needed_memory(void);
149off_t vm_available_not_needed_memory_debug(void);
150size_t vm_kernel_address_space_left(void);
151
152status_t vm_memset_physical(phys_addr_t address, int value, phys_size_t length);
153status_t vm_memcpy_from_physical(void* to, phys_addr_t from, size_t length,
154			bool user);
155status_t vm_memcpy_to_physical(phys_addr_t to, const void* from, size_t length,
156			bool user);
157void vm_memcpy_physical_page(phys_addr_t to, phys_addr_t from);
158
159status_t vm_debug_copy_page_memory(team_id teamID, void* unsafeMemory,
160			void* buffer, size_t size, bool copyToUnsafe);
161
162// user syscalls
163area_id _user_create_area(const char *name, void **address, uint32 addressSpec,
164			size_t size, uint32 lock, uint32 protection);
165status_t _user_delete_area(area_id area);
166
167area_id _user_map_file(const char *uname, void **uaddress, uint32 addressSpec,
168			size_t size, uint32 protection, uint32 mapping,
169			bool unmapAddressRange, int fd, off_t offset);
170status_t _user_unmap_memory(void *address, size_t size);
171status_t _user_set_memory_protection(void* address, size_t size,
172			uint32 protection);
173status_t _user_sync_memory(void *address, size_t size, uint32 flags);
174status_t _user_memory_advice(void* address, size_t size, uint32 advice);
175status_t _user_get_memory_properties(team_id teamID, const void *address,
176			uint32 *_protected, uint32 *_lock);
177
178status_t _user_mlock(const void* address, size_t size);
179status_t _user_munlock(const void* address, size_t size);
180
181area_id _user_area_for(void *address);
182area_id _user_find_area(const char *name);
183status_t _user_get_area_info(area_id area, area_info *info);
184status_t _user_get_next_area_info(team_id team, ssize_t *cookie, area_info *info);
185status_t _user_resize_area(area_id area, size_t newSize);
186area_id _user_transfer_area(area_id area, void **_address, uint32 addressSpec,
187			team_id target);
188status_t _user_set_area_protection(area_id area, uint32 newProtection);
189area_id _user_clone_area(const char *name, void **_address, uint32 addressSpec,
190			uint32 protection, area_id sourceArea);
191status_t _user_reserve_address_range(addr_t* userAddress, uint32 addressSpec,
192			addr_t size);
193status_t _user_unreserve_address_range(addr_t address, addr_t size);
194
195#ifdef __cplusplus
196}
197#endif
198
199#endif	/* _KERNEL_VM_VM_H */
200