sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/servers/vm/proto.h

193 lines
8.2 KiB
C
Raw Normal View History

Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
/* Function prototypes. */
struct vmproc;
struct stat;
struct mem_map;
struct memory;
Merge of Wu's GSOC 09 branch (src.20090525.r4372.wu) Main changes: - COW optimization for safecopy. - safemap, a grant-based interface for sharing memory regions between processes. - Integration with safemap and complete rework of DS, supporting new data types natively (labels, memory ranges, memory mapped ranges). - For further information: http://wiki.minix3.org/en/SummerOfCode2009/MemoryGrants Additional changes not included in the original Wu's branch: - Fixed unhandled case in VM when using COW optimization for safecopy in case of a block that has already been shared as SMAP. - Better interface and naming scheme for sys_saferevmap and ds_retrieve_map calls. - Better input checking in syslib: check for page alignment when creating memory mapping grants. - DS notifies subscribers when an entry is deleted. - Documented the behavior of indirect grants in case of memory mapping. - Test suite in /usr/src/test/safeperf|safecopy|safemap|ds/* reworked and extended. - Minor fixes and general cleanup. - TO-DO: Grant ids should be generated and managed the way endpoints are to make sure grant slots are never misreused.
2010-01-14 16:24:16 +01:00
struct vir_region;
struct phys_region;
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
#include <minix/ipc.h>
#include <minix/endpoint.h>
#include <minix/safecopies.h>
VM information interface
2010-01-19 22:00:20 +01:00
#include <minix/vm.h>
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
#include <timers.h>
#include <stdio.h>
#include <pagetable.h>
secondary cache feature in vm. A new call to vm lets processes yield a part of their memory to vm, together with an id, getting newly allocated memory in return. vm is allowed to forget about it if it runs out of memory. processes can ask for it back using the same id. (These two operations are normally combined in a single call.) It can be used as a as-big-as-memory-will-allow block cache for filesystems, which is how mfs now uses it.
2010-05-05 13:35:04 +02:00
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
#include "vm.h"
/* alloc.c */
let vm use physically fragmented memory for allocations. map_copy_ph_block is replaced by map_clone_ph_block, which can replace a single physical block by multiple physical blocks. also, . merge map_mem.c with region.c, as they manipulate the same data structures . NOTRUNNABLE removed as sanity check . use direct functions for ALLOC_MEM and FREE_MEM again . add some checks to shared memory mapping code . fix for data structure integrity when using shared memory . fix sanity checks
2010-04-12 13:25:24 +02:00
_PROTOTYPE( phys_clicks alloc_mem, (phys_clicks clicks, u32_t flags) );
_PROTOTYPE( struct memlist *alloc_mem_in_list, (phys_bytes bytes, u32_t flags));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE( int do_adddma, (message *msg) );
_PROTOTYPE( int do_deldma, (message *msg) );
_PROTOTYPE( int do_getdma, (message *msg) );
_PROTOTYPE( void release_dma, (struct vmproc *vmp) );
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE( void memstats, (int *nodes, int *pages, int *largest) );
_PROTOTYPE( void printmemstats, (void) );
_PROTOTYPE( void usedpages_reset, (void) );
_PROTOTYPE( int usedpages_add_f, (phys_bytes phys, phys_bytes len,
char *file, int line) );
let vm use physically fragmented memory for allocations. map_copy_ph_block is replaced by map_clone_ph_block, which can replace a single physical block by multiple physical blocks. also, . merge map_mem.c with region.c, as they manipulate the same data structures . NOTRUNNABLE removed as sanity check . use direct functions for ALLOC_MEM and FREE_MEM again . add some checks to shared memory mapping code . fix for data structure integrity when using shared memory . fix sanity checks
2010-04-12 13:25:24 +02:00
_PROTOTYPE( void free_mem, (phys_clicks base, phys_clicks clicks) );
_PROTOTYPE( void free_mem_list, (struct memlist *list, int all));
_PROTOTYPE( void print_mem_list, (struct memlist *ml));
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
#define usedpages_add(a, l) usedpages_add_f(a, l, __FILE__, __LINE__)
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE( void mem_init, (struct memory *chunks) );
/* utility.c */
_PROTOTYPE( int get_mem_map, (int proc_nr, struct mem_map *mem_map) );
_PROTOTYPE( void get_mem_chunks, (struct memory *mem_chunks));
_PROTOTYPE( void reserve_proc_mem, (struct memory *mem_chunks,
struct mem_map *map_ptr));
_PROTOTYPE( int vm_isokendpt, (endpoint_t ep, int *proc) );
_PROTOTYPE( int get_stack_ptr, (int proc_nr, vir_bytes *sp) );
VM information interface
2010-01-19 22:00:20 +01:00
_PROTOTYPE( int do_info, (message *) );
Unified crash recovery and live update. RS CHANGES: - Crash recovery is now implemented like live update. Two instances are kept side by side and the dead version is live updated into the new one. The endpoint doesn't change and the failure is not exposed (by default) to other system services. - The new instance can be created reactively (when a crash is detected) or proactively. In the latter case, RS can be instructed to keep a replica of the system service to perform a hot swap when the service fails. The flag SF_USE_REPL is set in that case. - The new flag SF_USE_REPL is supported for services in the boot image and dynamically started services through the RS interface (i.e. -p option in the service utility). - Fixed a free unallocated memory bug for core system services.
2010-04-27 13:17:30 +02:00
_PROTOTYPE( int swap_proc, (endpoint_t src_e, endpoint_t dst_e) );
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
/* exit.c */
_PROTOTYPE( void clear_proc, (struct vmproc *vmp) );
_PROTOTYPE( int do_exit, (message *msg) );
_PROTOTYPE( int do_willexit, (message *msg) );
_PROTOTYPE( void free_proc, (struct vmproc *vmp) );
/* fork.c */
_PROTOTYPE( int do_fork, (message *msg) );
/* exec.c */
_PROTOTYPE( int do_exec_newmem, (message *msg) );
- code shared with exec() letting boot-time processes have their own fully fledged virtual address space and freeing their pre-allocated heap+stack area (necessary to let memory driver map in arbitrary areas of memory for /dev/mem without sys_vm_map) - small optimization preallocating memory on exec - finished VR_DIRECT physical mapping code
2008-12-08 17:43:20 +01:00
_PROTOTYPE( int proc_new, (struct vmproc *vmp, phys_bytes start,
phys_bytes text, phys_bytes data, phys_bytes stack, phys_bytes gap,
VM: fix kernel mappings for children of non-paged parents.
2010-03-18 18:17:31 +01:00
phys_bytes text_here, phys_bytes data_here, vir_bytes stacktop,
int prealloc_stack));
- code shared with exec() letting boot-time processes have their own fully fledged virtual address space and freeing their pre-allocated heap+stack area (necessary to let memory driver map in arbitrary areas of memory for /dev/mem without sys_vm_map) - small optimization preallocating memory on exec - finished VR_DIRECT physical mapping code
2008-12-08 17:43:20 +01:00
_PROTOTYPE( phys_bytes find_kernel_top, (void) );
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
/* break.c */
_PROTOTYPE( int do_brk, (message *msg) );
_PROTOTYPE( int adjust, (struct vmproc *rmp,
vir_clicks data_clicks, vir_bytes sp) );
_PROTOTYPE( int real_brk, (struct vmproc *vmp, vir_bytes v));
/* signal.c */
_PROTOTYPE( int do_push_sig, (message *msg) );
Merge of Wu's GSOC 09 branch (src.20090525.r4372.wu) Main changes: - COW optimization for safecopy. - safemap, a grant-based interface for sharing memory regions between processes. - Integration with safemap and complete rework of DS, supporting new data types natively (labels, memory ranges, memory mapped ranges). - For further information: http://wiki.minix3.org/en/SummerOfCode2009/MemoryGrants Additional changes not included in the original Wu's branch: - Fixed unhandled case in VM when using COW optimization for safecopy in case of a block that has already been shared as SMAP. - Better interface and naming scheme for sys_saferevmap and ds_retrieve_map calls. - Better input checking in syslib: check for page alignment when creating memory mapping grants. - DS notifies subscribers when an entry is deleted. - Documented the behavior of indirect grants in case of memory mapping. - Test suite in /usr/src/test/safeperf|safecopy|safemap|ds/* reworked and extended. - Minor fixes and general cleanup. - TO-DO: Grant ids should be generated and managed the way endpoints are to make sure grant slots are never misreused.
2010-01-14 16:24:16 +01:00
/* map_mem.c */
_PROTOTYPE( int map_memory, (endpoint_t sour, endpoint_t dest,
vir_bytes virt_s, vir_bytes virt_d, vir_bytes length, int flag));
_PROTOTYPE( int unmap_memory, (endpoint_t sour, endpoint_t dest,
vir_bytes virt_s, vir_bytes virt_d, vir_bytes length, int flag));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
/* mmap.c */
_PROTOTYPE(int do_mmap, (message *msg) );
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE(int do_munmap, (message *msg) );
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE(int do_map_phys, (message *msg) );
_PROTOTYPE(int do_unmap_phys, (message *msg) );
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE(int do_remap, (message *m) );
_PROTOTYPE(int do_get_phys, (message *m) );
_PROTOTYPE(int do_shared_unmap, (message *m) );
_PROTOTYPE(int do_get_refcount, (message *m) );
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
/* pagefaults.c */
Changed pagefault delivery to VM this patch changes the way pagefaults are delivered to VM. It adopts the same model as the out-of-quantum messages sent by kernel to a scheduler. - everytime a userspace pagefault occurs, kernel creates a message which is sent to VM on behalf of the faulting process - the process is blocked on delivery to VM in the standard IPC code instead of waiting in a spacial in-kernel queue (stack) and is not runnable until VM tell kernel that the pagefault is resolved and is free to clear the RTS_PAGEFAULT flag. - VM does not need call kernel and poll the pagefault information which saves many (1/2?) calls and kernel calls that return "no more data" - VM notification by kernel does not need to use signals - each entry in proc table is by 12 bytes smaller (~3k save)
2010-04-27 01:21:26 +02:00
_PROTOTYPE( void do_pagefaults, (message *m) );
mark pages whose refcount were >1 and drop to 1 and are read/write writable in the pagetable right away instead of waiting for a pagefault. minor optimization. some a sanity check of SLAB-allocated pointers. vm gets its own _exit and __exit like PM, so the stock (library) panic works.
2009-04-22 14:39:29 +02:00
_PROTOTYPE( void do_memory, (void) );
- code shared with exec() letting boot-time processes have their own fully fledged virtual address space and freeing their pre-allocated heap+stack area (necessary to let memory driver map in arbitrary areas of memory for /dev/mem without sys_vm_map) - small optimization preallocating memory on exec - finished VR_DIRECT physical mapping code
2008-12-08 17:43:20 +01:00
_PROTOTYPE( char *pf_errstr, (u32_t err));
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE( int handle_memory, (struct vmproc *vmp, vir_bytes mem,
vir_bytes len, int wrflag));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
/* $(ARCH)/pagetable.c */
- map in as much memory as is necessary in 4MB chunks to let boot processes run with segments - allow segment-only processes to fork() by copying them and giving them an identity page table
2009-12-07 13:10:44 +01:00
_PROTOTYPE( void pt_init, (phys_bytes limit) );
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE( void pt_check, (struct vmproc *vmp) );
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE( int pt_new, (pt_t *pt) );
_PROTOTYPE( void pt_free, (pt_t *pt) );
_PROTOTYPE( int pt_writemap, (pt_t *pt, vir_bytes v, phys_bytes physaddr,
size_t bytes, u32_t flags, u32_t writemapflags));
new prototypes.
2009-09-27 14:37:16 +02:00
_PROTOTYPE( int pt_checkrange, (pt_t *pt, vir_bytes v, size_t bytes, int write));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE( int pt_bind, (pt_t *pt, struct vmproc *who) );
- simplify findhole() for use for 1 page only - do WMF_FREE - added WMF_VERIFY to check page table contents - randomize address space usage in vm self
2009-09-23 15:33:01 +02:00
_PROTOTYPE( void *vm_allocpage, (phys_bytes *p, int cat));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE( void pt_cycle, (void));
_PROTOTYPE( int pt_mapkernel, (pt_t *pt));
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE( void vm_pagelock, (void *vir, int lockflag) );
let vm use physically fragmented memory for allocations. map_copy_ph_block is replaced by map_clone_ph_block, which can replace a single physical block by multiple physical blocks. also, . merge map_mem.c with region.c, as they manipulate the same data structures . NOTRUNNABLE removed as sanity check . use direct functions for ALLOC_MEM and FREE_MEM again . add some checks to shared memory mapping code . fix for data structure integrity when using shared memory . fix sanity checks
2010-04-12 13:25:24 +02:00
_PROTOTYPE( int vm_addrok, (void *vir, int write) );
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
#if SANITYCHECKS
_PROTOTYPE( void pt_sanitycheck, (pt_t *pt, char *file, int line) );
#endif
/* slaballoc.c */
_PROTOTYPE(void *slaballoc,(int bytes));
_PROTOTYPE(void slabfree,(void *mem, int bytes));
_PROTOTYPE(void slabstats,(void));
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE(void slab_sanitycheck, (char *file, int line));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
#define SLABALLOC(var) (var = slaballoc(sizeof(*var)))
let vm use physically fragmented memory for allocations. map_copy_ph_block is replaced by map_clone_ph_block, which can replace a single physical block by multiple physical blocks. also, . merge map_mem.c with region.c, as they manipulate the same data structures . NOTRUNNABLE removed as sanity check . use direct functions for ALLOC_MEM and FREE_MEM again . add some checks to shared memory mapping code . fix for data structure integrity when using shared memory . fix sanity checks
2010-04-12 13:25:24 +02:00
#define SLABFREE(ptr) do { slabfree(ptr, sizeof(*(ptr))); (ptr) = NULL; } while(0)
mark pages whose refcount were >1 and drop to 1 and are read/write writable in the pagetable right away instead of waiting for a pagefault. minor optimization. some a sanity check of SLAB-allocated pointers. vm gets its own _exit and __exit like PM, so the stock (library) panic works.
2009-04-22 14:39:29 +02:00
#if SANITYCHECKS
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE(void slabunlock,(void *mem, int bytes));
_PROTOTYPE(void slablock,(void *mem, int bytes));
_PROTOTYPE(int slabsane_f,(char *file, int line, void *mem, int bytes));
mark pages whose refcount were >1 and drop to 1 and are read/write writable in the pagetable right away instead of waiting for a pagefault. minor optimization. some a sanity check of SLAB-allocated pointers. vm gets its own _exit and __exit like PM, so the stock (library) panic works.
2009-04-22 14:39:29 +02:00
#endif
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
/* region.c */
_PROTOTYPE(struct vir_region * map_page_region,(struct vmproc *vmp, \
vir_bytes min, vir_bytes max, vir_bytes length, vir_bytes what, \
u32_t flags, int mapflags));
_PROTOTYPE(struct vir_region * map_proc_kernel,(struct vmproc *dst));
- code shared with exec() letting boot-time processes have their own fully fledged virtual address space and freeing their pre-allocated heap+stack area (necessary to let memory driver map in arbitrary areas of memory for /dev/mem without sys_vm_map) - small optimization preallocating memory on exec - finished VR_DIRECT physical mapping code
2008-12-08 17:43:20 +01:00
_PROTOTYPE(int map_region_extend,(struct vmproc *vmp, struct vir_region *vr, vir_bytes delta));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE(int map_region_shrink,(struct vir_region *vr, vir_bytes delta));
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE(int map_unmap_region,(struct vmproc *vmp, struct vir_region *vr, vir_bytes len));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE(int map_free_proc,(struct vmproc *vmp));
_PROTOTYPE(int map_proc_copy,(struct vmproc *dst, struct vmproc *src));
_PROTOTYPE(struct vir_region *map_lookup,(struct vmproc *vmp, vir_bytes addr));
mark pages whose refcount were >1 and drop to 1 and are read/write writable in the pagetable right away instead of waiting for a pagefault. minor optimization. some a sanity check of SLAB-allocated pointers. vm gets its own _exit and __exit like PM, so the stock (library) panic works.
2009-04-22 14:39:29 +02:00
_PROTOTYPE(int map_pf,(struct vmproc *vmp,
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
struct vir_region *region, vir_bytes offset, int write));
_PROTOTYPE(int map_handle_memory,(struct vmproc *vmp,
struct vir_region *region, vir_bytes offset, vir_bytes len, int write));
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE(void map_printmap, (struct vmproc *vmp));
_PROTOTYPE(int map_writept, (struct vmproc *vmp));
_PROTOTYPE(void printregionstats, (struct vmproc *vmp));
VM: fix kernel mappings for children of non-paged parents.
2010-03-18 18:17:31 +01:00
_PROTOTYPE(phys_bytes map_lookup_phys, (struct vmproc *vmp, u32_t tag));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
_PROTOTYPE(struct vir_region * map_region_lookup_tag, (struct vmproc *vmp, u32_t tag));
_PROTOTYPE(void map_region_set_tag, (struct vir_region *vr, u32_t tag));
_PROTOTYPE(u32_t map_region_get_tag, (struct vir_region *vr));
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
_PROTOTYPE(int map_remap, (struct vmproc *dvmp, vir_bytes da, size_t size,
struct vir_region *region, vir_bytes *r));
_PROTOTYPE(int map_get_phys, (struct vmproc *vmp, vir_bytes addr, phys_bytes *r));
_PROTOTYPE(int map_get_ref, (struct vmproc *vmp, vir_bytes addr, u8_t *cnt));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
Merge of Wu's GSOC 09 branch (src.20090525.r4372.wu) Main changes: - COW optimization for safecopy. - safemap, a grant-based interface for sharing memory regions between processes. - Integration with safemap and complete rework of DS, supporting new data types natively (labels, memory ranges, memory mapped ranges). - For further information: http://wiki.minix3.org/en/SummerOfCode2009/MemoryGrants Additional changes not included in the original Wu's branch: - Fixed unhandled case in VM when using COW optimization for safecopy in case of a block that has already been shared as SMAP. - Better interface and naming scheme for sys_saferevmap and ds_retrieve_map calls. - Better input checking in syslib: check for page alignment when creating memory mapping grants. - DS notifies subscribers when an entry is deleted. - Documented the behavior of indirect grants in case of memory mapping. - Test suite in /usr/src/test/safeperf|safecopy|safemap|ds/* reworked and extended. - Minor fixes and general cleanup. - TO-DO: Grant ids should be generated and managed the way endpoints are to make sure grant slots are never misreused.
2010-01-14 16:24:16 +01:00
_PROTOTYPE(void pb_unreferenced, (struct vir_region *region,
struct phys_region *pr));
VM information interface
2010-01-19 22:00:20 +01:00
_PROTOTYPE(void get_usage_info, (struct vmproc *vmp,
struct vm_usage_info *vui));
_PROTOTYPE(int get_region_info, (struct vmproc *vmp,
struct vm_region_info *vri, int count, vir_bytes *nextp));
let vm use physically fragmented memory for allocations. map_copy_ph_block is replaced by map_clone_ph_block, which can replace a single physical block by multiple physical blocks. also, . merge map_mem.c with region.c, as they manipulate the same data structures . NOTRUNNABLE removed as sanity check . use direct functions for ALLOC_MEM and FREE_MEM again . add some checks to shared memory mapping code . fix for data structure integrity when using shared memory . fix sanity checks
2010-04-12 13:25:24 +02:00
_PROTOTYPE(int copy_abs2region, (phys_bytes abs,
struct vir_region *destregion, phys_bytes offset, phys_bytes len));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
#if SANITYCHECKS
_PROTOTYPE(void map_sanitycheck,(char *file, int line));
secondary cache feature in vm. A new call to vm lets processes yield a part of their memory to vm, together with an id, getting newly allocated memory in return. vm is allowed to forget about it if it runs out of memory. processes can ask for it back using the same id. (These two operations are normally combined in a single call.) It can be used as a as-big-as-memory-will-allow block cache for filesystems, which is how mfs now uses it.
2010-05-05 13:35:04 +02:00
_PROTOTYPE(void blockstats,(void));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
#endif
secondary cache feature in vm. A new call to vm lets processes yield a part of their memory to vm, together with an id, getting newly allocated memory in return. vm is allowed to forget about it if it runs out of memory. processes can ask for it back using the same id. (These two operations are normally combined in a single call.) It can be used as a as-big-as-memory-will-allow block cache for filesystems, which is how mfs now uses it.
2010-05-05 13:35:04 +02:00
_PROTOTYPE(int do_forgetblocks, (message *m));
_PROTOTYPE(int do_forgetblock, (message *m));
_PROTOTYPE(int do_yieldblockgetblock, (message *m));
_PROTOTYPE(vir_bytes free_yielded, (vir_bytes bytes));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
/* $(ARCH)/vm.c */
VM information interface
2010-01-19 22:00:20 +01:00
_PROTOTYPE( vir_bytes arch_map2vir, (struct vmproc *vmp, vir_bytes addr));
_PROTOTYPE( char *arch_map2str, (struct vmproc *vmp, vir_bytes addr));
_PROTOTYPE( vir_bytes arch_map2info, (struct vmproc *vmp, vir_bytes addr,
int *space, int *prot));
_PROTOTYPE( vir_bytes arch_vir2map, (struct vmproc *vmp, vir_bytes addr));
_PROTOTYPE( vir_bytes arch_vir2map_text, (struct vmproc *vmp, vir_bytes addr));
_PROTOTYPE( vir_bytes arch_addrok, (struct vmproc *vmp, vir_bytes addr));
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
/* rs.c */
_PROTOTYPE(int do_rs_set_priv, (message *m));
New RS and new signal handling for system processes. UPDATING INFO: 20100317: /usr/src/etc/system.conf updated to ignore default kernel calls: copy it (or merge it) to /etc/system.conf. The hello driver (/dev/hello) added to the distribution: # cd /usr/src/commands/scripts && make clean install # cd /dev && MAKEDEV hello KERNEL CHANGES: - Generic signal handling support. The kernel no longer assumes PM as a signal manager for every process. The signal manager of a given process can now be specified in its privilege slot. When a signal has to be delivered, the kernel performs the lookup and forwards the signal to the appropriate signal manager. PM is the default signal manager for user processes, RS is the default signal manager for system processes. To enable ptrace()ing for system processes, it is sufficient to change the default signal manager to PM. This will temporarily disable crash recovery, though. - sys_exit() is now split into sys_exit() (i.e. exit() for system processes, which generates a self-termination signal), and sys_clear() (i.e. used by PM to ask the kernel to clear a process slot when a process exits). - Added a new kernel call (i.e. sys_update()) to swap two process slots and implement live update. PM CHANGES: - Posix signal handling is no longer allowed for system processes. System signals are split into two fixed categories: termination and non-termination signals. When a non-termination signaled is processed, PM transforms the signal into an IPC message and delivers the message to the system process. When a termination signal is processed, PM terminates the process. - PM no longer assumes itself as the signal manager for system processes. It now makes sure that every system signal goes through the kernel before being actually processes. The kernel will then dispatch the signal to the appropriate signal manager which may or may not be PM. SYSLIB CHANGES: - Simplified SEF init and LU callbacks. - Added additional predefined SEF callbacks to debug crash recovery and live update. - Fixed a temporary ack in the SEF init protocol. SEF init reply is now completely synchronous. - Added SEF signal event type to provide a uniform interface for system processes to deal with signals. A sef_cb_signal_handler() callback is available for system processes to handle every received signal. A sef_cb_signal_manager() callback is used by signal managers to process system signals on behalf of the kernel. - Fixed a few bugs with memory mapping and DS. VM CHANGES: - Page faults and memory requests coming from the kernel are now implemented using signals. - Added a new VM call to swap two process slots and implement live update. - The call is used by RS at update time and in turn invokes the kernel call sys_update(). RS CHANGES: - RS has been reworked with a better functional decomposition. - Better kernel call masks. com.h now defines the set of very basic kernel calls every system service is allowed to use. This makes system.conf simpler and easier to maintain. In addition, this guarantees a higher level of isolation for system libraries that use one or more kernel calls internally (e.g. printf). - RS is the default signal manager for system processes. By default, RS intercepts every signal delivered to every system process. This makes crash recovery possible before bringing PM and friends in the loop. - RS now supports fast rollback when something goes wrong while initializing the new version during a live update. - Live update is now implemented by keeping the two versions side-by-side and swapping the process slots when the old version is ready to update. - Crash recovery is now implemented by keeping the two versions side-by-side and cleaning up the old version only when the recovery process is complete. DS CHANGES: - Fixed a bug when the process doing ds_publish() or ds_delete() is not known by DS. - Fixed the completely broken support for strings. String publishing is now implemented in the system library and simply wraps publishing of memory ranges. Ideally, we should adopt a similar approach for other data types as well. - Test suite fixed. DRIVER CHANGES: - The hello driver has been added to the Minix distribution to demonstrate basic live update and crash recovery functionalities. - Other drivers have been adapted to conform the new SEF interface.
2010-03-17 02:15:29 +01:00
_PROTOTYPE(int do_rs_update, (message *m));
Basic VM and other minor improvements. Not complete, probably not fully debugged or optimized.
2008-11-19 13:26:10 +01:00
- pages that points to page directory values of all processes, shared with the kernel, mapped into kernel address space; kernel is notified of its location. kernel segment size is increased to make it fit. - map in kernel and other processes that don't have their own page table using single 4MB (global) mapping. - new sanity check facility: objects that are allocated with the slab allocator are, when running with sanity checking on, marked readonly until they are explicitly unlocked using the USE() macro. - another sanity check facility: collect all uses of memory and see if they don't overlap with (a) eachother and (b) free memory - own munmap() and munmap_text() functions. - exec() recovers from out-of-memory conditions properly now; this solves some weird exec() behaviour - chew off memory from the same side of the chunk as where we start scanning, solving some memory fragmentation issues - use avl trees for freelist and phys_ranges in regions - implement most useful part of munmap() - remap() stuff is GQ's for shared memory
2009-09-21 16:49:49 +02:00
/* queryexit.c */
_PROTOTYPE(int do_query_exit, (message *m));
_PROTOTYPE(int do_notify_sig, (message *m));
_PROTOTYPE(void init_query_exit, (void));
Reference in a new issue Copy permalink