Context Navigation

source: trunk/kernel/mm/vmm.c @ 63

Last change on this file since 63 was 50, checked in by alain, 7 years ago
bloup
File size: 42.5 KB

Rev	Line
[1]	1	/*
	2	* vmm.c - virtual memory manager related operations interface.
	3	*
	4	* Authors Ghassan Almaless (2008,2009,2010,2011, 2012)
	5	* Mohamed Lamine Karaoui (2015)
	6	* Alain Greiner (2016)
[21]	7	*
[1]	8	* Copyright (c) UPMC Sorbonne Universites
	9	*
	10	* This file is part of ALMOS-MKH.
	11	*
	12	* ALMOS-MKH is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; version 2.0 of the License.
	15	*
	16	* ALMOS-MKH is distributed in the hope that it will be useful, but
	17	* WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	19	* General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with ALMOS-MKH; if not, write to the Free Software Foundation,
	23	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	24	*/
	25
[14]	26	#include <kernel_config.h>
[1]	27	#include <hal_types.h>
	28	#include <hal_special.h>
	29	#include <hal_gpt.h>
	30	#include <printk.h>
[23]	31	#include <memcpy.h>
[1]	32	#include <rwlock.h>
	33	#include <list.h>
	34	#include <bits.h>
	35	#include <process.h>
	36	#include <thread.h>
	37	#include <vseg.h>
	38	#include <cluster.h>
	39	#include <scheduler.h>
	40	#include <vfs.h>
	41	#include <mapper.h>
	42	#include <page.h>
	43	#include <kmem.h>
	44	#include <vmm.h>
	45
	46	//////////////////////////////////////////////////////////////////////////////////
	47	// Extern global variables
	48	//////////////////////////////////////////////////////////////////////////////////
	49
	50	extern process_t process_zero; // defined in cluster.c file
	51
	52
	53	////////////////////////////////////
	54	void vmm_init( process_t * process )
[21]	55	{
[1]	56	error_t error;
	57	vseg_t * vseg_kentry;
	58	vseg_t * vseg_args;
	59	vseg_t * vseg_envs;
	60	vseg_t * vseg_heap;
	61	intptr_t base;
	62	intptr_t size;
	63
	64	// get pointer on VMM
	65	vmm_t * vmm = &process->vmm;
	66
	67	// check UTILS zone size
	68	if( (CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE ) >
	69	CONFIG_VMM_ELF_BASE )
	70	{
	71	printk("\n[PANIC] in %s : UTILS zone too small for process %x\n",
	72	__FUNCTION__ , process->pid );
	73	hal_core_sleep();
	74	}
[21]	75
[1]	76	// check max number of stacks slots
	77	if( CONFIG_THREAD_MAX_PER_CLUSTER > 32 )
	78	{
[21]	79	printk("\n[PANIC] in %s : max number of threads per cluster for a single process"
[1]	80	" cannot be larger than 32\n", __FUNCTION__ );
	81	hal_core_sleep();
	82	}
	83
	84	// check STACK zone size
[21]	85	if( (CONFIG_VMM_STACK_SIZE * CONFIG_THREAD_MAX_PER_CLUSTER) >
[1]	86	(CONFIG_VMM_VSPACE_SIZE - CONFIG_VMM_STACK_BASE) )
	87	{
	88	printk("\n[PANIC] in %s : STACK zone too small for process %x\n",
	89	__FUNCTION__ , process->pid );
	90	hal_core_sleep();
	91	}
	92
[21]	93	// initialize the rwlock protecting the vsegs list
[1]	94	rwlock_init( &vmm->vsegs_lock );
	95
	96	// initialize local list of vsegs and radix-tree
[23]	97	vmm->vsegs_nr = 0;
[1]	98	list_root_init( &vmm->vsegs_root );
	99	error = grdxt_init( &vmm->grdxt,
	100	CONFIG_VMM_GRDXT_W1,
	101	CONFIG_VMM_GRDXT_W2,
	102	CONFIG_VMM_GRDXT_W3 );
	103	if( error )
	104	{
[21]	105	printk("\n[PANIC] in %s : cannot initialize radix tree for process %x\n",
[1]	106	__FUNCTION__ , process->pid );
	107	hal_core_sleep();
	108	}
	109
	110	// register kentry vseg in VMM
	111	base = 1 << CONFIG_PPM_PAGE_SHIFT;
	112	size = CONFIG_VMM_KENTRY_SIZE << CONFIG_PPM_PAGE_SHIFT;
	113	vseg_kentry = vmm_create_vseg( process , base , size , VSEG_TYPE_CODE );
[21]	114	if( vseg_kentry == NULL )
[1]	115	{
	116	printk("\n[PANIC] in %s : cannot register kent vseg for process %x\n",
	117	__FUNCTION__ , process->pid );
	118	hal_core_sleep();
	119	}
	120	vmm->kent_vpn_base = 1;
	121
	122	// register the args vseg in VMM
	123	base = (CONFIG_VMM_KENTRY_SIZE + 1 )<<CONFIG_PPM_PAGE_SHIFT;
	124	size = CONFIG_VMM_ARGS_SIZE << CONFIG_PPM_PAGE_SHIFT;
	125	vseg_args = vmm_create_vseg( process , base , size , VSEG_TYPE_DATA );
[21]	126	if( vseg_args == NULL )
[1]	127	{
	128	printk("\n[PANIC] in %s : cannot register args vseg for process %x\n",
	129	__FUNCTION__ , process->pid );
	130	hal_core_sleep();
	131	}
	132	vmm->args_vpn_base = CONFIG_VMM_KENTRY_SIZE + 1;
	133
	134	// register the envs vseg in VMM
	135	base = (CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + 1 )<<CONFIG_PPM_PAGE_SHIFT;
	136	size = CONFIG_VMM_ENVS_SIZE << CONFIG_PPM_PAGE_SHIFT;
	137	vseg_envs = vmm_create_vseg( process , base , size , VSEG_TYPE_DATA );
[21]	138	if( vseg_envs == NULL )
[1]	139	{
	140	printk("\n[PANIC] in %s : cannot register envs vseg for process %x\n",
	141	__FUNCTION__ , process->pid );
	142	hal_core_sleep();
	143	}
	144	vmm->envs_vpn_base = CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + 1;
	145
	146	// register the heap vseg in VMM
	147	base = CONFIG_VMM_HEAP_BASE << CONFIG_PPM_PAGE_SHIFT;
	148	size = (CONFIG_VMM_MMAP_BASE-CONFIG_VMM_HEAP_BASE) << CONFIG_PPM_PAGE_SHIFT;
	149	vseg_heap = vmm_create_vseg( process , base , size , VSEG_TYPE_HEAP );
[21]	150	if( vseg_heap == NULL )
[1]	151	{
	152	printk("\n[PANIC] in %s : cannot register heap vseg in for process %x\n",
	153	__FUNCTION__ , process->pid );
	154	hal_core_sleep();
	155	}
	156	vmm->heap_vpn_base = CONFIG_VMM_HEAP_BASE;
	157
	158	// initialize generic page table
	159	error = hal_gpt_create( &vmm->gpt );
	160	if( error )
	161	{
	162	printk("PANIC in %s : cannot initialize page table\n", __FUNCTION__ );
	163	hal_core_sleep();
	164	}
	165
	166	// initialize STACK allocator
	167	vmm->stack_mgr.bitmap = 0;
	168	vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
	169
	170	// initialize MMAP allocator
	171	vmm->mmap_mgr.vpn_base = CONFIG_VMM_MMAP_BASE;
	172	vmm->mmap_mgr.vpn_size = CONFIG_VMM_STACK_BASE - CONFIG_VMM_MMAP_BASE;
	173	vmm->mmap_mgr.first_free_vpn = CONFIG_VMM_MMAP_BASE;
	174	uint32_t i;
	175	for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
	176
[21]	177	// initialize instrumentation counters
[1]	178	vmm->pgfault_nr = 0;
	179	vmm->u_err_nr = 0;
	180	vmm->m_err_nr = 0;
	181
	182	hal_wbflush();
	183
	184	} // end vmm_init()
	185
[23]	186	//////////////////////////////////////////
	187	error_t vmm_copy( process_t * dst_process,
	188	process_t * src_process )
	189	{
	190	error_t error;
	191
	192	vmm_t * src_vmm = &src_process->vmm;
	193	vmm_t * dst_vmm = &dst_process->vmm;
	194
	195	// take the src_vmm vsegs_lock
	196	rwlock_wr_lock( &src_vmm->vsegs_lock );
	197
	198	// initialise dst_vmm vsegs_lock
	199	rwlock_init( &dst_vmm->vsegs_lock );
	200
	201	// initialise the dst_vmm vsegs list and the radix tree
	202	dst_vmm->vsegs_nr = 0;
	203	list_root_init( &dst_vmm->vsegs_root );
	204	error = grdxt_init( &dst_vmm->grdxt,
	205	CONFIG_VMM_GRDXT_W1,
	206	CONFIG_VMM_GRDXT_W2,
	207	CONFIG_VMM_GRDXT_W3 );
	208	if( error )
	209	{
	210	printk("\n[ERROR] in %s : cannot initialise radix tree for process %x\n",
	211	__FUNCTION__ , dst_process->pid );
	212	return ENOMEM;
	213	}
	214
	215	// loop on src_vmm list of vsegs to create
	216	// and register vsegs copies in dst_vmm
	217	list_entry_t * iter;
	218	vseg_t * src_vseg;
	219	vseg_t * dst_vseg;
	220	LIST_FOREACH( &src_vmm->vsegs_root , iter )
	221	{
	222	// get pointer on current src_vseg
	223	src_vseg = LIST_ELEMENT( iter , vseg_t , list );
	224
	225	// allocate memory for a new dst_vseg
	226	dst_vseg = vseg_alloc();
	227
	228	if( dst_vseg == NULL )
	229	{
	230	// release all allocated vsegs
	231	LIST_FOREACH( &dst_vmm->vsegs_root , iter )
	232	{
	233	dst_vseg = LIST_ELEMENT( iter , vseg_t , list );
	234	vseg_free( dst_vseg );
	235	}
	236	return ENOMEM;
	237	}
	238
	239	// copy src_vseg to dst_vseg
	240	vseg_init_from_ref( dst_vseg , XPTR( local_cxy , src_vseg ) );
	241
	242	// register dst_vseg in dst_vmm
	243	vseg_attach( dst_vmm , dst_vseg );
	244	}
	245
	246	// release the src_vmm vsegs_lock
	247	rwlock_wr_unlock( &src_vmm->vsegs_lock );
	248
	249	// initialize generic page table
	250	error = hal_gpt_create( &dst_vmm->gpt );
	251
	252	if( error )
	253	{
	254	printk("\n[ERROR] in %s : cannot initialize page table\n", __FUNCTION__ );
	255	return ENOMEM;
	256	}
	257
	258	// initialize STACK allocator
	259	dst_vmm->stack_mgr.bitmap = 0;
	260	dst_vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
	261
	262	// initialize MMAP allocator
	263	dst_vmm->mmap_mgr.vpn_base = CONFIG_VMM_MMAP_BASE;
	264	dst_vmm->mmap_mgr.vpn_size = CONFIG_VMM_STACK_BASE - CONFIG_VMM_MMAP_BASE;
	265	dst_vmm->mmap_mgr.first_free_vpn = CONFIG_VMM_MMAP_BASE;
	266	uint32_t i;
	267	for( i = 0 ; i < 32 ; i++ ) list_root_init( &dst_vmm->mmap_mgr.zombi_list[i] );
	268
	269	// initialise instrumentation counters
	270	dst_vmm->pgfault_nr = 0;
	271	dst_vmm->u_err_nr = 0;
	272	dst_vmm->m_err_nr = 0;
	273
	274	// copy base addresses
	275	dst_vmm->kent_vpn_base = src_vmm->kent_vpn_base;
	276	dst_vmm->args_vpn_base = src_vmm->args_vpn_base;
	277	dst_vmm->envs_vpn_base = src_vmm->envs_vpn_base;
	278	dst_vmm->heap_vpn_base = src_vmm->heap_vpn_base;
	279	dst_vmm->code_vpn_base = src_vmm->code_vpn_base;
	280	dst_vmm->data_vpn_base = src_vmm->data_vpn_base;
	281
	282	dst_vmm->entry_point = src_vmm->entry_point;
	283
	284	// HEAP TODO : new heap for child ???
	285	dst_vmm->heap_vseg = src_vmm->heap_vseg;
	286
	287	// initialize generic page table
	288	error = hal_gpt_create( &dst_vmm->gpt );
	289
	290	if( error )
	291	{
	292	printk("\n[ERROR] in %s : cannot initialize page table\n", __FUNCTION__ );
	293	return ENOMEM;
	294	}
	295
	296	// copy GPT content from src_vmm to dst_vmm, activating "Copy-On-Write"
	297	// TODO register Copy-On_Write in page descriptors
	298	bool_t cow = true;
	299	hal_gpt_copy( &dst_vmm->gpt , &src_vmm->gpt , cow );
	300
	301	hal_wbflush();
	302
	303	return 0;
	304
	305	} // end vmm_copy()
	306
[1]	307	///////////////////////////////////////
	308	void vmm_destroy( process_t * process )
	309	{
	310	vseg_t * vseg;
	311
	312	// get pointer on VMM
	313	vmm_t * vmm = &process->vmm;
	314
	315	// get lock protecting vseg list
	316	rwlock_wr_lock( &vmm->vsegs_lock );
	317
	318	// remove all vsegs registered in vmm
	319	while( !list_is_empty( &vmm->vsegs_root ) )
	320	{
	321	vseg = LIST_FIRST( &vmm->vsegs_root , vseg_t , list );
	322	vseg_detach( vmm , vseg );
	323	vseg_free( vseg );
	324	}
	325
	326	// delete vsegs radix_tree
	327	grdxt_destroy( &vmm->grdxt );
	328
	329	// release lock
	330	rwlock_wr_unlock(&vmm->vsegs_lock);
	331
	332	// remove all vsegs from zombi_lists in MMAP allocator
	333	uint32_t i;
	334	for( i = 0 ; i<32 ; i++ )
	335	{
	336	while( !list_is_empty( &vmm->mmap_mgr.zombi_list[i] ) )
	337	{
	338	vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , list );
	339	vseg_detach( vmm , vseg );
	340	vseg_free( vseg );
	341	}
	342	}
	343
	344	// release memory allocated to the local page table
	345	hal_gpt_destroy( &vmm->gpt );
	346
	347	} // end vmm_destroy()
	348
	349	/////////////////////////////////////////////////
	350	vseg_t * vmm_check_conflict( process_t * process,
[21]	351	vpn_t vpn_base,
[1]	352	vpn_t vpn_size )
	353	{
	354	vmm_t * vmm = &process->vmm;
	355	vseg_t * vseg;
	356	list_entry_t * iter;
	357
	358	// scan the list of registered vsegs
	359	LIST_FOREACH( &vmm->vsegs_root , iter )
	360	{
	361	vseg = LIST_ELEMENT( iter , vseg_t , list );
[21]	362	if( ((vpn_base + vpn_size) > vseg->vpn_base) &&
	363	(vpn_base < (vseg->vpn_base + vseg->vpn_size)) ) return vseg;
[1]	364	}
	365	return NULL;
	366	} // vmm_check_conflict()
	367
	368	////////////////////////////////////////////////////////////////////////////////////////////
	369	// This static function is called by the vmm_create_vseg() function, and implements
	370	// the VMM stack_vseg specific allocator.
	371	////////////////////////////////////////////////////////////////////////////////////////////
	372	// @ vmm : pointer on VMM.
[21]	373	// @ vpn_base : (return value) first allocated page
[1]	374	// @ vpn_size : (return value) number of allocated pages
	375	////////////////////////////////////////////////////////////////////////////////////////////
	376	static error_t vmm_stack_alloc( vmm_t * vmm,
	377	vpn_t * vpn_base,
	378	vpn_t * vpn_size )
	379	{
	380	// get stack allocator pointer
	381	stack_mgr_t * mgr = &vmm->stack_mgr;
	382
	383	// get lock on stack allocator
	384	spinlock_lock( &mgr->lock );
	385
	386	// get first free slot index in bitmap
	387	int32_t index = bitmap_ffc( &mgr->bitmap , 4 );
	388	if( (index < 0) \|\| (index > 31) ) return ENOMEM;
	389
	390	// update bitmap
	391	bitmap_set( &mgr->bitmap , index );
[21]	392
[1]	393	// release lock on stack allocator
	394	spinlock_unlock( &mgr->lock );
	395
[21]	396	// returns vpn_base, vpn_size (one page non allocated)
[1]	397	vpn_base = mgr->vpn_base + index CONFIG_VMM_STACK_SIZE + 1;
	398	*vpn_size = CONFIG_VMM_STACK_SIZE - 1;
	399	return 0;
	400
	401	} // end vmm_stack_alloc()
	402
	403	////////////////////////////////////////////////////////////////////////////////////////////
	404	// This static function is called by the vmm_create_vseg() function, and implements
	405	// the VMM MMAP specific allocator.
	406	////////////////////////////////////////////////////////////////////////////////////////////
	407	// @ vmm : [in] pointer on VMM.
	408	// @ npages : [in] requested number of pages.
[21]	409	// @ vpn_base : [out] first allocated page.
[1]	410	// @ vpn_size : [out] actual number of allocated pages.
	411	////////////////////////////////////////////////////////////////////////////////////////////
	412	static error_t vmm_mmap_alloc( vmm_t * vmm,
	413	vpn_t npages,
	414	vpn_t * vpn_base,
	415	vpn_t * vpn_size )
	416	{
	417	uint32_t index;
	418	vseg_t * vseg;
	419	vpn_t base;
	420	vpn_t size;
[21]	421	vpn_t free;
[1]	422
[21]	423	// mmap vseg size must be power of 2
[1]	424	// compute actual size and index in zombi_list array
	425	size = POW2_ROUNDUP( npages );
	426	index = bits_log2( size );
	427
	428	// get mmap allocator pointer
	429	mmap_mgr_t * mgr = &vmm->mmap_mgr;
	430
	431	// get lock on mmap allocator
	432	spinlock_lock( &mgr->lock );
	433
	434	// get vseg from zombi_list or from mmap zone
	435	if( list_is_empty( &mgr->zombi_list[index] ) ) // from mmap zone
	436	{
	437	// check overflow
	438	free = mgr->first_free_vpn;
	439	if( (free + size) > mgr->vpn_size ) return ENOMEM;
	440
	441	// update STACK allocator
	442	mgr->first_free_vpn += size;
	443
	444	// compute base
	445	base = free;
	446	}
	447	else // from zombi_list
	448	{
	449	// get pointer on zombi vseg from zombi_list
	450	vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , list );
	451
	452	// remove vseg from free-list
	453	list_unlink( &vseg->list );
	454
	455	// compute base
	456	base = vseg->vpn_base;
[21]	457	}
	458
[1]	459	// release lock on mmap allocator
	460	spinlock_unlock( &mgr->lock );
	461
	462	// returns vpn_base, vpn_size
	463	*vpn_base = base;
	464	*vpn_size = size;
	465	return 0;
	466
[21]	467	} // end vmm_mmap_alloc()
[1]	468
	469	//////////////////////////////////////////////
	470	vseg_t * vmm_create_vseg( process_t * process,
[21]	471	intptr_t base,
	472	intptr_t size,
[1]	473	uint32_t type )
	474	{
	475	vseg_t * vseg; // created vseg pointer
[21]	476	vpn_t vpn_base; // vseg first page
[1]	477	vpn_t vpn_size; // number of pages
	478	error_t error;
	479
	480	// get pointer on VMM
	481	vmm_t * vmm = &process->vmm;
[21]	482
[1]	483	vmm_dmsg("\n[INFO] %s enter for process %x / base = %x / size = %x / type = %s\n",
	484	__FUNCTION__ , process->pid , base , size , vseg_type_name[type] );
[21]	485
[1]	486	// compute base, size, vpn_base, vpn_size, depending on type
	487	// we use the VMM specific allocators for STACK and MMAP vsegs
	488	if( type == VSEG_TYPE_STACK )
	489	{
	490	// get vpn_base and vpn_size from STACK allocator
	491	error = vmm_stack_alloc( vmm , &vpn_base , &vpn_size );
	492	if( error )
	493	{
	494	printk("\n[ERROR] in %s : no vspace for stack vseg / process %x in cluster %x\n",
	495	__FUNCTION__ , process->pid , local_cxy );
	496	return NULL;
	497	}
	498
	499	// compute vseg base and size from vpn_base and vpn_size
	500	base = vpn_base << CONFIG_PPM_PAGE_SHIFT;
	501	size = vpn_size << CONFIG_PPM_PAGE_SHIFT;
	502	}
[21]	503	else if( (type == VSEG_TYPE_ANON) \|\|
	504	(type == VSEG_TYPE_FILE) \|\|
[1]	505	(type == VSEG_TYPE_REMOTE) )
	506	{
	507	// get vpn_base and vpn_size from MMAP allocator
	508	vpn_t npages = size >> CONFIG_PPM_PAGE_SHIFT;
	509	error = vmm_mmap_alloc( vmm , npages , &vpn_base , &vpn_size );
	510	if( error )
	511	{
	512	printk("\n[ERROR] in %s : no vspace for mmap vseg / process %x in cluster %x\n",
	513	__FUNCTION__ , process->pid , local_cxy );
	514	return NULL;
	515	}
	516
	517	// compute vseg base and size from vpn_base and vpn_size
	518	base = vpn_base << CONFIG_PPM_PAGE_SHIFT;
	519	size = vpn_size << CONFIG_PPM_PAGE_SHIFT;
	520	}
	521	else
	522	{
	523	vpn_base = ARROUND_DOWN( base , CONFIG_PPM_PAGE_SIZE ) >> CONFIG_PPM_PAGE_SHIFT;
	524	vpn_size = ARROUND_UP( base + size , CONFIG_PPM_PAGE_SIZE ) >> CONFIG_PPM_PAGE_SHIFT;
	525	}
	526
	527	// check collisions
	528	vseg = vmm_check_conflict( process , vpn_base , vpn_size );
	529	if( vseg != NULL )
	530	{
[21]	531	printk("\n[ERROR] in %s for process %x : new vseg [vpn_base = %x / vpn_size = %x]\n"
[1]	532	" overlap existing vseg [vpn_base = %x / vpn_size = %x]\n",
[21]	533	__FUNCTION__ , process->pid, vpn_base, vpn_size,
	534	vseg->vpn_base, vseg->vpn_size );
[1]	535	return NULL;
	536	}
	537
	538	// allocate physical memory for vseg descriptor
	539	vseg = vseg_alloc();
	540	if( vseg == NULL )
	541	{
	542	printk("\n[ERROR] in %s for process %x : cannot allocate memory for vseg\n",
	543	__FUNCTION__ , process->pid );
	544	return NULL;
	545	}
	546
	547	// initialize vseg descriptor
	548	vseg_init( vseg , base, size , vpn_base , vpn_size , type , local_cxy , 0 , 0 );
	549
	550	// update "heap_vseg" in VMM
	551	process->vmm.heap_vseg = vseg;
	552
	553	// attach vseg to vmm
	554	rwlock_wr_lock( &vmm->vsegs_lock );
	555	vseg_attach( vmm , vseg );
	556	rwlock_wr_unlock( &vmm->vsegs_lock );
	557
[21]	558	vmm_dmsg("\n[INFO] : %s exit for process %x, vseg [%x, %x] has been mapped\n",
[1]	559	__FUNCTION__ , process->pid , vseg->min , vseg->max );
[21]	560
[1]	561	return vseg;
	562
	563	} // end vmm_create_vseg()
	564
	565	/////////////////////////////////////
	566	void vmm_remove_vseg( vseg_t * vseg )
	567	{
	568	// get pointers on calling process and VMM
	569	thread_t * this = CURRENT_THREAD;
	570	process_t * process = this->process;
	571	vmm_t * vmm = &this->process->vmm;
	572	uint32_t type = vseg->type;
	573
	574	// detach vseg from VMM
	575	rwlock_wr_lock( &vmm->vsegs_lock );
	576	vseg_detach( &process->vmm , vseg );
	577	rwlock_wr_unlock( &vmm->vsegs_lock );
	578
	579	// release the stack slot to VMM stack allocator if STACK type
	580	if( type == VSEG_TYPE_STACK )
	581	{
	582	// get pointer on stack allocator
	583	stack_mgr_t * mgr = &vmm->stack_mgr;
	584
	585	// compute slot index
	586	uint32_t index = ((vseg->vpn_base - mgr->vpn_base - 1) / CONFIG_VMM_STACK_SIZE);
	587
	588	// update stacks_bitmap
	589	spinlock_lock( &mgr->lock );
	590	bitmap_clear( &mgr->bitmap , index );
	591	spinlock_unlock( &mgr->lock );
	592	}
	593
	594	// release the vseg to VMM mmap allocator if MMAP type
	595	if( (type == VSEG_TYPE_ANON) \|\| (type == VSEG_TYPE_FILE) \|\| (type == VSEG_TYPE_REMOTE) )
	596	{
	597	// get pointer on mmap allocator
	598	mmap_mgr_t * mgr = &vmm->mmap_mgr;
	599
	600	// compute zombi_list index
	601	uint32_t index = bits_log2( vseg->vpn_size );
	602
	603	// update zombi_list
	604	spinlock_lock( &mgr->lock );
	605	list_add_first( &mgr->zombi_list[index] , &vseg->list );
	606	spinlock_unlock( &mgr->lock );
	607	}
	608
	609	// release physical memory allocated for vseg descriptor if no MMAP type
	610	if( (type != VSEG_TYPE_ANON) && (type != VSEG_TYPE_FILE) && (type != VSEG_TYPE_REMOTE) )
	611	{
	612	vseg_free( vseg );
	613	}
	614
	615	} // end vmm_remove_vseg()
	616
	617
	618	//////////////////////////////////////////
	619	error_t vmm_map_vseg( vseg_t * vseg,
	620	uint32_t attr )
	621	{
	622	vpn_t vpn; // VPN of PTE to be set
	623	vpn_t vpn_min; // VPN of first PTE to be set
	624	vpn_t vpn_max; // VPN of last PTE to be set (excluded)
	625	ppn_t ppn; // PPN of allocated physical page
	626	uint32_t order; // ln( number of small pages for one single PTE )
	627	page_t * page;
	628	error_t error;
	629
	630	// check vseg type
	631	uint32_t type = vseg->type;
	632	if( (type != VSEG_TYPE_KCODE) && (type != VSEG_TYPE_KDATA) && (type != VSEG_TYPE_KDEV) )
	633	{
	634	printk("\n[PANIC] in %s : not a kernel vseg\n", __FUNCTION__ );
	635	hal_core_sleep();
	636	}
	637
	638	// get pointer on page table
	639	gpt_t * gpt = &process_zero.vmm.gpt;
	640
[21]	641	// define number of small pages per PTE
[1]	642	if( attr & GPT_SMALL ) order = 0; // 1 small page
	643	else order = 9; // 512 small pages
	644
	645	// loop on pages in vseg
	646	vpn_min = vseg->vpn_base;
	647	vpn_max = vpn_min + vseg->vpn_size;
	648	for( vpn = vpn_min ; vpn < vpn_max ; vpn++ )
	649	{
	650	kmem_req_t req;
	651	req.type = KMEM_PAGE;
	652	req.size = order;
	653	req.flags = AF_KERNEL \| AF_ZERO;
	654	page = (page_t *)kmem_alloc( &req );
[21]	655	if( page == NULL )
[1]	656	{
	657	printk("\n[ERROR] in %s : cannot allocate physical memory\n", __FUNCTION__ );
	658	return ENOMEM;
	659	}
	660
	661	// set page table entry
	662	ppn = ppm_page2ppn( page );
	663	error = hal_gpt_set_pte( gpt , vpn , ppn , attr );
[21]	664	if( error )
[1]	665	{
	666	printk("\n[ERROR] in %s : cannot register PPE\n", __FUNCTION__ );
	667	return ENOMEM;
	668	}
	669	}
[21]	670
[1]	671	return 0;
	672	} // end vmm_map_vseg()
	673
	674	/////////////////////////////////////////
	675	void vmm_unmap_vseg( process_t * process,
	676	vseg_t * vseg )
	677	{
[21]	678	vpn_t vpn; // VPN of current PTE
	679	vpn_t vpn_min; // VPN of first PTE
[1]	680	vpn_t vpn_max; // VPN of last PTE (excluded)
	681
	682	// get pointer on process page table
	683	gpt_t * gpt = &process->vmm.gpt;
	684
	685	// loop on pages in vseg
	686	vpn_min = vseg->vpn_base;
	687	vpn_max = vpn_min + vseg->vpn_size;
	688	for( vpn = vpn_min ; vpn < vpn_max ; vpn++ )
	689	{
	690	hal_gpt_reset_pte( gpt , vpn );
	691	}
	692	} // end vmm_unmap_vseg()
	693
	694
	695	/////////////////////////////////////////////
	696	error_t vmm_resize_vseg( process_t * process,
	697	intptr_t base,
	698	intptr_t size )
	699	{
	700	error_t error;
	701
	702	// get pointer on process VMM
	703	vmm_t * vmm = &process->vmm;
	704
	705	intptr_t addr_min = base;
	706	intptr_t addr_max = base + size;
[21]	707	uint32_t shift = CONFIG_PPM_PAGE_SHIFT;
[1]	708
	709	// get pointer on vseg
	710	vseg_t * vseg = grdxt_lookup( &vmm->grdxt , (uint32_t)(base >> shift) );
	711
	712	if( vseg == NULL) return EINVAL;
[21]	713
[1]	714	// get VMM lock protecting vsegs list
	715	rwlock_wr_lock( &vmm->vsegs_lock );
[21]	716
[1]	717	if( (vseg->min > addr_min) \|\| (vseg->max < addr_max) ) // region not included in vseg
	718	{
	719	error = EINVAL;
	720	}
	721	else if( (vseg->min == addr_min) && (vseg->max == addr_max) ) // vseg must be removed
	722	{
	723	vmm_remove_vseg( vseg );
	724	error = 0;
	725	}
	726	else if( vseg->min == addr_min ) // vseg must be resized
	727	{
	728	printk("\n[PANIC] in %s : resize not implemented yet\n", __FUNCTION__ );
	729	hal_core_sleep();
	730	error = 0;
	731	}
	732	else if( vseg->max == addr_max ) // vseg must be resized
	733	{
	734	printk("\n[PANIC] in %s : resize not implemented yet\n", __FUNCTION__ );
	735	hal_core_sleep();
	736	error = 0;
	737	}
	738	else // vseg cut in three regions => vseg must be resized & new vseg created
	739	{
	740	printk("\n[PANIC] in %s : resize not implemented yet\n", __FUNCTION__ );
	741	hal_core_sleep();
	742	error = 0;
	743	}
	744
	745	// release VMM lock
	746	rwlock_wr_unlock( &vmm->vsegs_lock );
	747
	748	return error;
	749	} // end vmm_resize_vseg()
	750
	751	///////////////////////////////////////////
	752	vseg_t * vmm_get_vseg( process_t * process,
	753	intptr_t vaddr )
	754	{
	755
	756	// get pointer on process VMM
	757	vmm_t * vmm = &process->vmm;
	758
	759	// get lock protecting the vseg list
	760	rwlock_rd_lock( &vmm->vsegs_lock );
	761
	762	// get pointer on vseg from radix tree
	763	vseg_t * vseg = grdxt_lookup( &vmm->grdxt, (uint32_t)(vaddr >> CONFIG_PPM_PAGE_SHIFT) );
	764
	765	// release the lock
	766	rwlock_rd_unlock( &vmm->vsegs_lock );
	767
	768	return vseg;
	769
	770	} // end vmm_get_vseg()
	771
	772	/////////////////////////////////////////
	773	error_t vmm_get_pte( process_t * process,
	774	vpn_t vpn,
	775	uint32_t * ret_attr,
	776	ppn_t * ret_ppn )
	777	{
	778	vseg_t * vseg; // pointer on vseg containing VPN
	779	ppn_t ppn; // PPN from GPT entry
	780	uint32_t attr; // attributes from GPT entry
	781	error_t error;
	782
[23]	783	// this function must be called by a thread running in the reference cluster
	784	if( GET_CXY( process->ref_xp ) != local_cxy );
[1]	785	{
	786	printk("\n[PANIC] in %s : not called in the reference cluster\n", __FUNCTION__ );
	787	hal_core_sleep();
	788	}
	789
	790	// get VMM pointer
	791	vmm_t * vmm = &process->vmm;
	792
	793	// access GPT to get PTE attributes and PPN
	794	hal_gpt_get_pte( &vmm->gpt , vpn , &attr , &ppn );
	795
	796	// if PTE unmapped => allocate one small physical page to map it
[21]	797	if( (attr & GPT_MAPPED) == 0 )
[1]	798	{
	799	// get vseg pointer
	800	vseg = vmm_get_vseg( process , vpn<<CONFIG_PPM_PAGE_SHIFT );
	801
	802	if( vseg == NULL );
	803	{
	804	printk("\n[ERROR] in %s : out of segment / process = %x / vpn = %x\n",
	805	__FUNCTION__ , process->pid , vpn );
	806	return EINVAL;
	807	}
	808
	809	// select the target cluster for physical mapping
	810	uint32_t target_cxy;
	811	if( vseg->flags & VSEG_DISTRIB ) // depends on VPN LSB
	812	{
	813	uint32_t x_width = LOCAL_CLUSTER->x_width;
	814	uint32_t y_width = LOCAL_CLUSTER->y_width;
	815	target_cxy = vpn & ((1<<(x_width + y_width)) - 1);
	816	}
	817	else // defined in vseg descriptor
	818	{
	819	target_cxy = vseg->cxy;
	820	}
	821
	822	// allocate memory for page fault
	823	kmem_req_t req;
	824	page_t * page;
	825	if( target_cxy == local_cxy ) // target cluster is the local cluster
[21]	826	{
[1]	827	req.type = KMEM_PAGE;
	828	req.size = 0;
	829	req.flags = AF_NONE;
	830	page = (page_t *)kmem_alloc( &req );
	831
	832	error = ( page == NULL ) ? 1 : 0;
	833	ppn = ppm_page2ppn( page );
	834	}
	835	else // target cluster is not the local cluster
	836	{
	837	rpc_pmem_get_pages_client( target_cxy , 0 , &error , &ppn );
	838	}
	839
	840	if( error )
	841	{
	842	printk("\n[ERROR] in %s : cannot allocate memory / process = %x / vpn = %x\n",
	843	__FUNCTION__ , process->pid , vpn );
	844	return ENOMEM;
	845	}
	846
[21]	847	// define GPT attributes from vseg flags
[1]	848	attr = GPT_MAPPED \| GPT_SMALL;
	849	if( vseg->flags & VSEG_USER ) attr \|= GPT_USER;
	850	if( vseg->flags & VSEG_WRITE ) attr \|= GPT_WRITABLE;
	851	if( vseg->flags & VSEG_EXEC ) attr \|= GPT_EXECUTABLE;
	852	if( vseg->flags & VSEG_CACHE ) attr \|= GPT_CACHABLE;
	853
	854	// set the missing PTE in local VMM
	855	error = hal_gpt_set_pte( &vmm->gpt , vpn , ppn , attr );
	856	if( error )
	857	{
	858	printk("\n[ERROR] in %s : cannot register PTE / process = %x / vpn = %x\n",
	859	__FUNCTION__ , process->pid , vpn );
	860	return ENOMEM;
	861	}
	862	}
	863
	864	*ret_ppn = ppn;
[21]	865	*ret_attr = attr;
[1]	866	return 0;
	867	} // end vmm_get_pte()
	868
	869	///////////////////////////////////////////////////
	870	error_t vmm_handle_page_fault( process_t * process,
	871	vseg_t * vseg,
	872	vpn_t vpn )
	873	{
	874	uint32_t attr; // missing page attributes
[21]	875	ppn_t ppn; // missing page PPN
[1]	876	error_t error; // return value
	877
	878	// get local VMM pointer
	879	vmm_t * vmm = &process->vmm;
	880
	881	// get reference process cluster and local pointer
	882	cxy_t ref_cxy = GET_CXY( process->ref_xp );
	883	process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
	884
	885	// get missing PTE attributes and PPN
	886	if( local_cxy != ref_cxy ) // local cluster is not the reference cluster
	887	{
	888	rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , &attr , &ppn , &error );
	889	}
[21]	890	else // local cluster is the reference cluster
[1]	891	{
	892	error = vmm_get_pte( process , vpn , &attr , &ppn );
	893	}
	894
	895	// check page allocation error
	896	if( error )
	897	{
	898	printk("\n[ERROR] in %s : cannot allocate memory / process = %x / vpn = %x\n",
[21]	899	__FUNCTION__ , process->pid , vpn );
[1]	900	return ENOMEM;
	901	}
	902
	903	// set the missing PTE in local VMM
	904	error = hal_gpt_set_pte( &vmm->gpt , vpn , attr , ppn );
	905	if( error )
	906	{
	907	printk("\n[ERROR] in %s : cannot register PTE / process = %x / vpn = %x\n",
[21]	908	__FUNCTION__ , process->pid , vpn );
[1]	909	return ENOMEM;
	910	}
[21]	911
[1]	912	return 0;
	913	} // end vmm_handle_page_fault()
	914
	915	///////////////////////////////////////////
	916	error_t vmm_v2p_translate( bool_t ident,
	917	void * ptr,
	918	paddr_t * paddr )
	919	{
[23]	920	process_t * process = CURRENT_THREAD->process;
[1]	921
	922	if( ident ) // identity mapping
	923	{
[23]	924	*paddr = (paddr_t)PADDR( local_cxy , (lpa_t)ptr );
[1]	925	return 0;
	926	}
	927
[21]	928	// access page table
[1]	929	error_t error;
	930	vpn_t vpn;
	931	uint32_t attr;
	932	ppn_t ppn;
	933	uint32_t offset;
	934
[23]	935	vpn = (vpn_t)( (intptr_t)ptr >> CONFIG_PPM_PAGE_SHIFT );
	936	offset = (uint32_t)( ((intptr_t)ptr) & CONFIG_PPM_PAGE_MASK );
[1]	937
[50]	938	if( local_cxy == GET_CXY( process->ref_xp) ) // calling process is reference process
[1]	939	{
	940	error = vmm_get_pte( process, vpn , &attr , &ppn );
	941	}
[50]	942	else // calling process is not reference process
[1]	943	{
	944	cxy_t ref_cxy = GET_CXY( process->ref_xp );
	945	process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
	946	rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , &attr , &ppn , &error );
	947	}
	948
[23]	949	// set paddr
[1]	950	*paddr = (((paddr_t)ppn) << CONFIG_PPM_PAGE_SHIFT) \| offset;
[21]	951
[23]	952	return error;
	953
[1]	954	} // end vmm_v2p_translate()
	955
[23]	956	//////////////////////////////////////////////
[1]	957
	958
	959
[23]	960
[1]	961	/*
	962
	963	///////////////////////////////////////////////////////////////////
	964	///////////////////////////////////////////////////////////////////
	965	error_t vmm_inval_shared_page( vseg_t *vseg, vma_t vaddr, ppn_t ppn)
	966	{
	967	pmm_page_info_t current;
	968	error_t err;
	969
	970	error= pmm_get_page(&vseg->vmm->pmm, vaddr, &current);
	971
	972	if((err) \|\| (current.ppn != ppn))
	973	goto ended;
	974
	975	current.ppn = 0;
	976	current.attr = 0;
	977	current.cluster = NULL;
	978
	979	error= pmm_set_page(&vseg->vmm->pmm, vaddr, &current);
	980
	981	ended:
	982	return err;
	983	}
	984
	985	error_t vmm_update_shared_page( vseg_t *vseg, vma_t vaddr, ppn_t ppn)
	986	{
	987	pmm_page_info_t current;
	988	error_t err;
	989
	990	error= pmm_get_page(&vseg->vmm->pmm, vaddr, &current);
	991
	992	if((err) \|\| (current.attr != 0))
	993	goto ended;
	994
	995	current.ppn = ppn;
	996	current.attr = vseg->vm_pgprot;
	997	current.cluster = NULL; // this function is called after invalidate one
	998
	999	error= pmm_set_page(&vseg->vmm->pmm, vaddr , &current);
	1000
	1001	ended:
	1002	return err;
	1003	}
	1004
	1005	// Hypothesis: the vseg is shared-anon, mapper list is rdlocked, page is locked
	1006	error_t vmm_migrate_shared_page_seq( vseg_t vseg, struct page_s page, struct page_s **new)
	1007	{
	1008	register vseg_t *reg;
	1009	register struct process_s *process;
	1010	register struct process_s *this_process;
	1011	struct page_s *new_pg;
	1012	struct list_entry *iter;
	1013	kmem_req_t req;
	1014	vma_t vaddr;
	1015	ppn_t ppn;
	1016	error_t err;
	1017
	1018	vaddr = (page->index << PMM_PAGE_SHIFT) + vseg->vm_start + vseg->vm_offset;
	1019	ppn = ppm_page2ppn(page);
	1020	this_process = (new == NULL) ? NULL : current_process;
	1021	iter = &vseg->vm_shared_list;
	1022	error = ECANCELED;
	1023
	1024	// Invalidate All
	1025	do
	1026	{
	1027	reg = list_element(iter, vseg_t, vm_shared_list);
	1028
	1029	process = vmm_get_process(reg->vmm);
	1030
	1031	if(process != this_process)
	1032	{
	1033	error= vmm_inval_shared_page(reg, vaddr, ppn);
	1034
	1035	if(err) goto fail_inval;
	1036	}
	1037
	1038	assert(vseg->vm_mapper.m_home_cid == current_cid);
	1039	iter = list_next(&vseg->vm_mapper.m_reg_root, iter);
	1040
	1041	}while(iter != NULL);
	1042
	1043	req.type = KMEM_PAGE;
	1044	req.size = 0;
	1045	req.excep_code = AF_USER;
	1046
	1047	new_pg = kmem_alloc(&req);
	1048	*new = new_pg;
	1049
	1050	if(new_pg == NULL)
	1051	{
	1052	error= ENOMEM;
	1053	goto fail_alloc;
	1054	}
	1055
	1056	page_copy(new_pg, page);
	1057
	1058	page_lock(new_pg);
	1059
	1060	new_pg->mapper = page->mapper;
	1061	new_pg->index = page->index;
	1062
	1063	// TODO: do the complet job regading dirty page
	1064	if(PAGE_IS(page, PG_DIRTY))
	1065	PAGE_SET(new_pg, PG_DIRTY);
	1066
	1067	ppn = ppm_page2ppn(new_pg);
	1068	iter = &vseg->vm_shared_list;
	1069
	1070	// Update All
	1071	do
	1072	{
	1073	reg = list_element(iter, vseg_t, vm_shared_list);
	1074
	1075	process = vmm_get_process(reg->vmm);
	1076
	1077	if(process != this_process)
	1078	(void) vmm_update_shared_page(reg, vaddr, ppn);
	1079
	1080	assert(vseg->vm_mapper.m_home_cid == current_cid);
	1081	iter = list_next(&vseg->vm_mapper.m_reg_root, iter);
	1082
	1083
	1084	}while(iter != NULL);
	1085
	1086	page_unlock(new_pg);
	1087
	1088	fail_alloc:
	1089	fail_inval:
	1090	return err;
	1091	}
	1092
	1093	//TODO: revisit all manipulation of the page->refcount
	1094	///////////////////////////////////////////////////////////////
	1095	static inline error_t vmm_do_migrate( vseg_t * vseg,
	1096	pmm_page_info_t * pinfo,
	1097	uint32_t vaddr )
	1098	{
	1099	kmem_req_t req;
	1100	pmm_page_info_t current;
	1101	page_t * newpage;
	1102	cluster_t * cluster;
	1103	thread_t * this;
	1104	error_t err;
	1105	ppn_t ppn;
	1106
	1107	assert( pinfo->ppn != 0 );
	1108
	1109	ppn = pinfo->ppn;
	1110	this = current_thread;
	1111	newpage = NULL;
	1112	cluster = current_cluster;
	1113
	1114	current.attr = 0;
	1115	current.ppn = 0;
	1116
	1117	error= pmm_lock_page(&vseg->vmm->pmm, vaddr, &current);
	1118
	1119	if(error\|\| (current.isAtomic == false) \|\|
	1120	(current.ppn != ppn) \|\| !(current.attr & PMM_MIGRATE))
	1121	{
	1122	#if CONFIG_SHOW_SPURIOUS_PGFAULT
	1123	printk(INFO, "%s: pid %d, tid %d, cpu %d, nothing to do for vaddr %x\n",
	1124	__FUNCTION__,
	1125	this->process->pid,
	1126	this->info.order,
	1127	cpu_get_id(),
	1128	vaddr);
	1129	#endif
	1130	this->info.spurious_pgfault_cntr ++;
	1131	pmm_unlock_page(&vseg->vmm->pmm, vaddr, &current);
	1132	pmm_tlb_flush_vaddr(vaddr, PMM_DATA);
	1133	return 0;
	1134	}
	1135
	1136	if(!ppn_is_local(ppn))
	1137	{
	1138	req.type = KMEM_PAGE;
	1139	req.size = 0;
	1140	req.excep_code = AF_PGFAULT;
	1141
	1142	newpage = kmem_alloc(&req);
	1143
	1144	if(newpage)
	1145	{
	1146	newpage->mapper = NULL;//?
	1147	ppn_copy(ppm_page2ppn(newpage), ppn);
	1148
	1149	if(current.attr & PMM_COW)
	1150	{
	1151	current.attr \|= PMM_WRITE;
	1152	current.attr &= ~(PMM_COW);
	1153	}
	1154
	1155	current.ppn = ppm_page2ppn(newpage);
	1156	}
	1157	}
	1158
	1159	current.attr \|= PMM_PRESENT;
	1160	current.attr &= ~(PMM_MIGRATE);
	1161	current.attr &= ~(PMM_LOCKED);
	1162	current.cluster = NULL;
	1163
	1164	//also unlock the table entry
	1165	error= pmm_set_page(&vseg->vmm->pmm, vaddr, &current);
	1166
	1167	if(err)
	1168	{
	1169	// TODO: we should differ the kmem_free call
	1170	//page_unlock(page);
	1171	(void)pmm_unlock_page(&vseg->vmm->pmm, vaddr, &current);
	1172	req.ptr = newpage;
	1173	kmem_free(&req);
	1174	return err;
	1175	}
	1176
	1177
	1178	if(newpage)
	1179	{
	1180	ppn_refcount_down(ppn);
	1181	current_thread->info.remote_pages_cntr ++;
	1182	#if CONFIG_SHOW_REMOTE_PGALLOC
	1183	printk(INFO, "%s: pid %d, tid %x, cpu %d, cid %d: got new remote page from cluster %d (vaddr %x)\n",
	1184	__FUNCTION__,
	1185	current_process->pid,
	1186	current_thread,
	1187	cpu_get_id(),
	1188	cluster->id,
	1189	newpage->cid,
	1190	vaddr);
	1191	#endif
	1192	}
	1193
	1194	#if CONFIG_SHOW_VMMMGRT_MSG
	1195	printk(INFO, "%s: pid %d, tid %d, cpu %d: Asked to migrate page (vaddr %x) from cluster %d to cluster %d, error%d\n",
	1196	__FUNCTION__,
	1197	current_process->pid,
	1198	current_thread->info.order,
	1199	cpu_get_id(),
	1200	vaddr,
	1201	ppn_ppn2cid(ppn),
	1202	cluster->id,
	1203	err);
	1204	#endif
	1205
	1206	return err;
	1207	}
	1208
	1209	error_t vmm_do_cow( vseg_t vseg, pmm_page_info_t pinfo, uint32_t vaddr)
	1210	{
	1211	register struct page_s *newpage;
	1212	register struct page_s *page;
	1213	register struct thread_s *this;
	1214	register error_t err;
	1215	register uint32_t count;
	1216	register bool_t isCountDown;
	1217	pmm_page_info_t old;
	1218	pmm_page_info_t new;
	1219	kmem_req_t req;
	1220
	1221	this = current_thread;
	1222	old.attr = 0;
	1223	newpage = NULL;
	1224	isCountDown = true;
	1225
	1226	vmm_dmsg(2,"%s: pid %d, tid %d, cpu %d, vaddr %x\n",
	1227	__FUNCTION__,
	1228	this->process->pid,
	1229	this->info.order,
	1230	cpu_get_id(),
	1231	vaddr);
	1232
	1233
	1234	error= pmm_lock_page(&vseg->vmm->pmm, vaddr, &old);
	1235
	1236	//TODO: check this condition
	1237	if(error\|\| (old.isAtomic == false) \|\| !(old.attr & PMM_COW))
	1238	{
	1239	#if CONFIG_SHOW_SPURIOUS_PGFAULT
	1240	printk(INFO, "%s: pid %d, tid %d, cpu %d, nothing to do for vaddr %x\n",
	1241	__FUNCTION__,
	1242	this->process->pid,
	1243	this->info.order,
	1244	cpu_get_id(),
	1245	vaddr);
	1246	#endif
	1247	this->info.spurious_pgfault_cntr ++;
	1248	pmm_tlb_flush_vaddr(vaddr, PMM_DATA);
	1249	pmm_unlock_page(&vseg->vmm->pmm, vaddr, &old);
	1250	return err;
	1251	//goto VMM_COW_END;
	1252	}
	1253
	1254	//if the ppn is local and the others (processus with wich we share the page)
	1255	//has done cow, then use the old.ppn directly
	1256	if(ppn_is_local(old.ppn))
	1257	{
	1258	page = ppm_ppn2page(&current_cluster->ppm, old.ppn);
	1259
	1260	if(page->mapper == NULL)
	1261	{
	1262	count = page_refcount_get(page);
	1263	if(count == 1)
	1264	{
	1265	newpage = page;//don't copy the page. use it directly.
	1266	isCountDown = false;
	1267	vmm_dmsg(2, "%s: pid %d, tid %d, cpu %d, reuse same page for vaddr %x, pg_addr %x\n",
	1268	__FUNCTION__,
	1269	this->process->pid,
	1270	this->info.order,
	1271	cpu_get_id(),
	1272	vaddr,
	1273	ppm_page2addr(page));
	1274	}
	1275	}
	1276	//else: we need to do the cow even if it's local!
	1277
	1278	}
	1279
	1280	//else: alocate newpage and copy the data from the remote node
	1281	//also defcount down the ppn
	1282	if(newpage == NULL)
	1283	{
	1284	req.type = KMEM_PAGE;
	1285	req.size = 0;
	1286	req.excep_code = AF_PGFAULT;
	1287
	1288	if((newpage = kmem_alloc(&req)) == NULL)
	1289	{
	1290	(void)pmm_unlock_page(&vseg->vmm->pmm, vaddr, &old);
	1291	return ENOMEM;
	1292	}
	1293
	1294	newpage->mapper = NULL;
	1295
	1296	ppn_copy(ppm_page2ppn(newpage), old.ppn);
	1297	assert(isCountDown);
	1298
	1299	vmm_dmsg(2,
	1300	"%s: pid %d, tid %d, cpu %d, newpage for vaddr %x, pg_addr %x\n",
	1301	__FUNCTION__,
	1302	this->process->pid,
	1303	this->info.order,
	1304	cpu_get_id(),
	1305	vaddr,
	1306	ppm_page2addr(newpage));
	1307
	1308	if(newpage->cid != current_cid)
	1309	this->info.remote_pages_cntr ++;
	1310	}
	1311
	1312	new.attr = vseg->vm_pgprot \| PMM_WRITE;
	1313	new.attr &= ~(PMM_COW \| PMM_MIGRATE);
	1314	new.ppn = ppm_page2ppn(newpage);
	1315	new.cluster = NULL;
	1316
	1317	//this also unlock the table entry (if no error)
	1318	error= pmm_set_page(&vseg->vmm->pmm, vaddr, &new);
	1319
	1320	if(err)
	1321	{
	1322	(void)pmm_unlock_page(&vseg->vmm->pmm, vaddr, &old);
	1323	req.ptr = newpage;
	1324	kmem_free(&req);
	1325	vmm_dmsg(3, "%s: ended [ error%d ]\n", __FUNCTION__, err);
	1326	return err;
	1327	}
	1328
	1329	if(isCountDown) ppn_refcount_down(old.ppn);
	1330
	1331	vmm_dmsg(2, "%s, pid %d, tid %d, cpu %d, COW ended [vaddr %x]\n",
	1332	__FUNCTION__,
	1333	this->process->pid,
	1334	this->info.order,
	1335	cpu_get_id(),
	1336	vaddr);
	1337
	1338	return 0;
	1339	}
	1340
	1341
	1342	//refcount is taken on the file at mmap
	1343	static inline error_t vmm_do_mapped( vseg_t *vseg, uint32_t vaddr, uint32_t excep_code)
	1344	{
	1345	ppn_t ppn;
	1346	error_t err;
	1347	uint32_t index;
	1348	bool_t isDone;
	1349	pmm_page_info_t info;
	1350	pmm_page_info_t current;
	1351	struct thread_s *this;
	1352
	1353	this = current_thread;
	1354
	1355	current.attr = 1;
	1356	current.ppn = 1;
	1357	isDone = false;
	1358
	1359	error= pmm_lock_page(&vseg->vmm->pmm, vaddr, &current);
	1360
	1361	if(err) return err;
	1362
	1363	if((current.isAtomic == false) \|\| (current.attr != 0))
	1364	{
	1365	#if CONFIG_SHOW_SPURIOUS_PGFAULT
	1366	printk(INFO, "%s: pid %d, tid %d, cpu %d, nothing to do for vaddr %x\n",
	1367	__FUNCTION__,
	1368	this->process->pid,
	1369	this->info.order,
	1370	cpu_get_id(),
	1371	vaddr);
	1372	#endif
	1373	this->info.spurious_pgfault_cntr ++;
	1374	pmm_tlb_flush_vaddr(vaddr, PMM_DATA);
	1375	return 0;
	1376	}
	1377
	1378	index = ((vaddr - vseg->vm_start) + vseg->vm_offset) >> PMM_PAGE_SHIFT;
	1379
	1380	//also hold a refcount!
	1381	ppn = mapper_get_ppn(&vseg->vm_mapper,
	1382	index,
	1383	MAPPER_SYNC_OP);
	1384
	1385	if(!ppn)
	1386	{
	1387	error= pmm_unlock_page(&vseg->vmm->pmm, vaddr, &current);
	1388	assert(!err); //FIXME: liberate the ppn ...
	1389	return (VFS_FILE_IS_NULL(vseg->vm_file)) ? EIO : ENOMEM;
	1390	}
	1391
	1392	info.attr = vseg->vm_pgprot;
	1393	info.ppn = ppn;
	1394	info.cluster = NULL;
	1395
	1396	//also unlock the page
	1397	error= pmm_set_page(&vseg->vmm->pmm, vaddr, &info);
	1398
	1399	assert(!err);//FIXME: liberate the ppn and unlock the table entry ...
	1400	//error= pmm_unlock_page(&vseg->vmm->pmm, vaddr, &current);
	1401
	1402	return err;
	1403	}
	1404
	1405	/////////////////////////////////////////////////////
	1406	static inline error_t vmm_do_aod( vseg_t *vseg, uint32_t vaddr)
	1407	{
	1408	register error_t err;
	1409	register struct page_s *page;
	1410	register struct cluster_s *cluster;
	1411	struct thread_s *this;
	1412	pmm_page_info_t old;
	1413	pmm_page_info_t new;
	1414	kmem_req_t req;
	1415
	1416	page = NULL;
	1417	old.attr = 0;
	1418	this = current_thread;
	1419
	1420	error= pmm_lock_page(&vseg->vmm->pmm, vaddr, &old);
	1421
	1422	if(err) return err;
	1423
	1424	if(old.isAtomic == false)
	1425	{
	1426	this->info.spurious_pgfault_cntr ++;
	1427	pmm_tlb_flush_vaddr(vaddr, PMM_DATA);
	1428	return 0;
	1429	}
	1430
	1431	req.type = KMEM_PAGE;
	1432	req.size = 0;
	1433	req.excep_code = AF_PGFAULT \| AF_ZERO;
	1434
	1435	if((page = kmem_alloc(&req)) == NULL)
	1436	{
	1437	(void)pmm_unlock_page(&vseg->vmm->pmm, vaddr, &old);
	1438	return ENOMEM;
	1439	}
	1440
	1441	page->mapper = NULL;
	1442
	1443	new.attr = vseg->vm_pgprot;
	1444	new.ppn = ppm_page2ppn(page);
	1445	new.cluster = NULL;
	1446
	1447	error= pmm_set_page(&vseg->vmm->pmm, vaddr, &new);
	1448
	1449	if(err) goto fail_set_pg;
	1450
	1451	cluster = current_cluster;
	1452
	1453	if(page->cid != cluster->id)
	1454	this->info.remote_pages_cntr ++;
	1455
	1456	return 0;
	1457
	1458	fail_set_pg:
	1459	(void)pmm_unlock_page(&vseg->vmm->pmm, vaddr, &old);
	1460	req.ptr = page;
	1461	kmem_free(&req);
	1462
	1463	vmm_dmsg(3, "%s: ended [ error%d ]\n", __FUNCTION__, err);
	1464	return err;
	1465	}
	1466
	1467	VSEGION_PAGE_FAULT(vmm_default_pagefault)
	1468	{
	1469	register struct thread_s *this;
	1470	register error_t err;
	1471	pmm_page_info_t info;
	1472
	1473	if((error= pmm_get_page(&vseg->vmm->pmm, vaddr, &info)))
	1474	return err;
	1475
	1476	if((info.attr != 0) && (info.ppn != 0))
	1477	{
	1478	if((info.attr & PMM_COW) && pmm_except_isWrite(excep_code))
	1479	{
	1480	error= vmm_do_cow(vseg, &info, vaddr);
	1481	return err;
	1482	}
	1483
	1484	if(info.attr & PMM_MIGRATE)
	1485	return vmm_do_migrate(vseg, &info, vaddr);
	1486
	1487	if(info.attr & PMM_PRESENT)
	1488	{
	1489	this = current_thread;
	1490
	1491	#if CONFIG_SHOW_SPURIOUS_PGFAULT
	1492	printk(WARNING, "WARNING: %s: pid %d, tid %d, cpu %d, excep_code %x but vaddr is valid %x, attr %x, ppn %x\n",
	1493	__FUNCTION__,
	1494	this->process->pid,
	1495	this->info.order,
	1496	cpu_get_id(),
	1497	excep_code,
	1498	vaddr,
	1499	info.attr,
	1500	info.ppn);
	1501	#endif
	1502
	1503	current_thread->info.spurious_pgfault_cntr ++;
	1504	pmm_tlb_flush_vaddr(vaddr, PMM_UNKNOWN);
	1505	return 0;
	1506	}
	1507
	1508	current_thread->info.spurious_pgfault_cntr ++;
	1509	pmm_tlb_flush_vaddr(vaddr, PMM_UNKNOWN);
	1510	return 0;
	1511	#if 0
	1512	#if CONFIG_SHOW_VMM_ERROR_MSG
	1513	printk(ERROR,
	1514	"ERROR: %s: pid %d, cpu %d, Unexpected page attributes configuration for vaddr %x, found: ppn %x, attr %x\n",
	1515	__FUNCTION__,
	1516	current_process->pid,
	1517	cpu_get_id(),
	1518	vaddr,
	1519	info.ppn,
	1520	info.attr);
	1521	#endif
	1522
	1523	return EPERM;
	1524	#endif
	1525	}
	1526
	1527	if(!MAPPER_IS_NULL(vseg->vm_mapper))
	1528	return vmm_do_mapped(vseg, vaddr, excep_code);
	1529
	1530	return vmm_do_aod(vseg, vaddr);
	1531	}
	1532
	1533	*/
	1534
	1535

Note: See TracBrowser for help on using the repository browser.

Download in other formats: