WebSVN – HelenOS-historic – Blame – /SPARTAN/trunk/src/mm/vm.c

Rev	Author	Line No.	Line
1	jermar	1	/*
		2	* Copyright (C) 2001-2004 Jakub Jermar
		3	* All rights reserved.
		4	*
		5	* Redistribution and use in source and binary forms, with or without
		6	* modification, are permitted provided that the following conditions
		7	* are met:
		8	*
		9	* - Redistributions of source code must retain the above copyright
		10	* notice, this list of conditions and the following disclaimer.
		11	* - Redistributions in binary form must reproduce the above copyright
		12	* notice, this list of conditions and the following disclaimer in the
		13	* documentation and/or other materials provided with the distribution.
		14	* - The name of the author may not be used to endorse or promote products
		15	* derived from this software without specific prior written permission.
		16	*
		17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
		18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
		19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
		20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
		21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
		22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
		26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		27	*/
		28
		29	#include <mm/vm.h>
		30	#include <mm/page.h>
		31	#include <mm/frame.h>
5	jermar	32	#include <mm/tlb.h>
35	jermar	33	#include <mm/heap.h>
1	jermar	34	#include <arch/mm/page.h>
		35	#include <arch/types.h>
		36	#include <typedefs.h>
		37	#include <synch/spinlock.h>
		38	#include <config.h>
		39	#include <list.h>
		40	#include <panic.h>
		41
		42	vm_t *vm_create(void)
		43	{
		44	vm_t *m;
		45
		46	m = (vm_t *) malloc(sizeof(vm_t));
		47	if (m) {
		48	spinlock_initialize(&m->lock);
		49	list_initialize(&m->vm_area_head);
		50	}
		51
		52	return m;
		53	}
		54
		55	void vm_destroy(vm_t *m)
		56	{
		57	}
		58
		59	vm_area_t vm_area_create(vm_t m, vm_type_t type, int size, __address addr)
		60	{
		61	pri_t pri;
		62	vm_area_t *a;
		63
		64	if (addr % PAGE_SIZE)
		65	panic(PANIC "addr not aligned to a page boundary");
		66
		67	pri = cpu_priority_high();
		68	spinlock_lock(&m->lock);
		69
		70	/*
		71	* TODO: test vm_area which is to be created doesn't overlap with an existing one.
		72	*/
		73
		74	a = (vm_area_t *) malloc(sizeof(vm_area_t));
		75	if (a) {
		76	int i;
		77
		78	a->mapping = (__address ) malloc(size sizeof(__address));
		79	if (!a->mapping) {
		80	free(a);
		81	spinlock_unlock(&m->lock);
		82	cpu_priority_restore(pri);
		83	return NULL;
		84	}
		85
		86	for (i=0; i<size; i++)
		87	a->mapping[i] = frame_alloc(0);
		88
		89	spinlock_initialize(&a->lock);
		90
		91	link_initialize(&a->link);
		92	a->type = type;
		93	a->size = size;
		94	a->address = addr;
		95
		96	list_append(&a->link, &m->vm_area_head);
		97
		98	}
		99
		100	spinlock_unlock(&m->lock);
		101	cpu_priority_restore(pri);
		102
		103	return a;
		104	}
		105
		106	void vm_area_destroy(vm_area_t *a)
		107	{
		108	}
		109
		110	void vm_area_map(vm_area_t *a)
		111	{
		112	int i, flags;
		113	pri_t pri;
		114
		115	pri = cpu_priority_high();
		116	spinlock_lock(&a->lock);
		117
		118	switch (a->type) {
		119	case VMA_TEXT:
		120	flags = PAGE_EXEC \| PAGE_READ \| PAGE_USER \| PAGE_PRESENT \| PAGE_CACHEABLE;
		121	break;
		122	case VMA_DATA:
		123	case VMA_STACK:
		124	flags = PAGE_READ \| PAGE_WRITE \| PAGE_USER \| PAGE_PRESENT \| PAGE_CACHEABLE;
		125	break;
		126	default:
		127	panic(PANIC "unexpected vm_type_t %d", a->type);
		128	}
		129
		130	for (i=0; i<a->size; i++)
		131	map_page_to_frame(a->address + i*PAGE_SIZE, a->mapping[i], flags, 0);
		132
		133	spinlock_unlock(&a->lock);
		134	cpu_priority_restore(pri);
		135	}
		136
		137	void vm_area_unmap(vm_area_t *a)
		138	{
		139	int i;
		140	pri_t pri;
		141
		142	pri = cpu_priority_high();
		143	spinlock_lock(&a->lock);
		144
		145	for (i=0; i<a->size; i++)
		146	map_page_to_frame(a->address + i*PAGE_SIZE, 0, PAGE_NOT_PRESENT, 0);
5	jermar	147
1	jermar	148	spinlock_unlock(&a->lock);
		149	cpu_priority_restore(pri);
		150	}
		151
		152	void vm_install(vm_t *m)
		153	{
		154	link_t *l;
		155	pri_t pri;
		156
		157	pri = cpu_priority_high();
		158	spinlock_lock(&m->lock);
		159
		160	for(l = m->vm_area_head.next; l != &m->vm_area_head; l = l->next)
		161	vm_area_map(list_get_instance(l, vm_area_t, link));
		162
		163	spinlock_unlock(&m->lock);
		164	cpu_priority_restore(pri);
		165	}
		166
		167	void vm_uninstall(vm_t *m)
		168	{
		169	link_t *l;
		170	pri_t pri;
		171
		172	pri = cpu_priority_high();
5	jermar	173
6	jermar	174	tlb_shootdown_start();
5	jermar	175
1	jermar	176	spinlock_lock(&m->lock);
		177
		178	for(l = m->vm_area_head.next; l != &m->vm_area_head; l = l->next)
		179	vm_area_unmap(list_get_instance(l, vm_area_t, link));
		180
		181	spinlock_unlock(&m->lock);
5	jermar	182
6	jermar	183	tlb_shootdown_finalize();
5	jermar	184
1	jermar	185	cpu_priority_restore(pri);
		186	}

Subversion Repositories HelenOS-historic

(root)/SPARTAN/trunk/src/mm/vm.c – Rev 35