Context Navigation

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

Last change on this file since 414 was 409, checked in by alain, 7 years ago
Fix bugs in exec
File size: 58.7 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>
[409]	30	#include <hal_vmm.h>
[1]	31	#include <printk.h>
[23]	32	#include <memcpy.h>
[1]	33	#include <rwlock.h>
	34	#include <list.h>
[408]	35	#include <xlist.h>
[1]	36	#include <bits.h>
	37	#include <process.h>
	38	#include <thread.h>
	39	#include <vseg.h>
	40	#include <cluster.h>
	41	#include <scheduler.h>
	42	#include <vfs.h>
	43	#include <mapper.h>
	44	#include <page.h>
	45	#include <kmem.h>
	46	#include <vmm.h>
	47
	48	//////////////////////////////////////////////////////////////////////////////////
	49	// Extern global variables
	50	//////////////////////////////////////////////////////////////////////////////////
	51
	52	extern process_t process_zero; // defined in cluster.c file
	53
	54
	55	////////////////////////////////////
	56	void vmm_init( process_t * process )
[21]	57	{
[1]	58	error_t error;
	59	vseg_t * vseg_kentry;
	60	vseg_t * vseg_args;
	61	vseg_t * vseg_envs;
	62	intptr_t base;
	63	intptr_t size;
	64
[407]	65	vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n",
	66	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
[204]	67
[1]	68	// get pointer on VMM
	69	vmm_t * vmm = &process->vmm;
	70
[407]	71	// initialize local list of vsegs
	72	vmm->vsegs_nr = 0;
[408]	73	xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
	74	remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) );
[407]	75
[204]	76	assert( ((CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE)
	77	<= CONFIG_VMM_ELF_BASE) , __FUNCTION__ , "UTILS zone too small\n" );
[21]	78
[204]	79	assert( (CONFIG_THREAD_MAX_PER_CLUSTER <= 32) , __FUNCTION__ ,
	80	"no more than 32 threads per cluster for a single process\n");
[1]	81
[204]	82	assert( ((CONFIG_VMM_STACK_SIZE * CONFIG_THREAD_MAX_PER_CLUSTER) <=
	83	(CONFIG_VMM_VSPACE_SIZE - CONFIG_VMM_STACK_BASE)) , __FUNCTION__ ,
	84	"STACK zone too small\n");
[1]	85
[409]	86	// register kentry vseg in VSL
[406]	87	base = CONFIG_VMM_KENTRY_BASE << CONFIG_PPM_PAGE_SHIFT;
[1]	88	size = CONFIG_VMM_KENTRY_SIZE << CONFIG_PPM_PAGE_SHIFT;
[406]	89
[407]	90	vseg_kentry = vmm_create_vseg( process,
	91	VSEG_TYPE_CODE,
	92	base,
	93	size,
	94	0, // file_offset unused
	95	0, // file_size unused
	96	XPTR_NULL, // mapper_xp unused
	97	local_cxy );
[204]	98
	99	assert( (vseg_kentry != NULL) , __FUNCTION__ , "cannot register kentry vseg\n" );
	100
[406]	101	vmm->kent_vpn_base = base;
[1]	102
[409]	103	// register args vseg in VSL
[406]	104	base = (CONFIG_VMM_KENTRY_BASE +
	105	CONFIG_VMM_KENTRY_SIZE ) << CONFIG_PPM_PAGE_SHIFT;
[1]	106	size = CONFIG_VMM_ARGS_SIZE << CONFIG_PPM_PAGE_SHIFT;
[406]	107
[407]	108	vseg_args = vmm_create_vseg( process,
	109	VSEG_TYPE_DATA,
	110	base,
	111	size,
	112	0, // file_offset unused
	113	0, // file_size unused
	114	XPTR_NULL, // mapper_xp unused
	115	local_cxy );
[204]	116
[407]	117	assert( (vseg_args != NULL) , __FUNCTION__ , "cannot create args vseg\n" );
[204]	118
[406]	119	vmm->args_vpn_base = base;
[1]	120
[409]	121	// register the envs vseg in VSL
[406]	122	base = (CONFIG_VMM_KENTRY_BASE +
	123	CONFIG_VMM_KENTRY_SIZE +
	124	CONFIG_VMM_ARGS_SIZE ) << CONFIG_PPM_PAGE_SHIFT;
[1]	125	size = CONFIG_VMM_ENVS_SIZE << CONFIG_PPM_PAGE_SHIFT;
[406]	126
[407]	127	vseg_envs = vmm_create_vseg( process,
	128	VSEG_TYPE_DATA,
	129	base,
	130	size,
	131	0, // file_offset unused
	132	0, // file_size unused
	133	XPTR_NULL, // mapper_xp unused
	134	local_cxy );
[204]	135
[407]	136	assert( (vseg_envs != NULL) , __FUNCTION__ , "cannot create envs vseg\n" );
[204]	137
[406]	138	vmm->envs_vpn_base = base;
[1]	139
[409]	140	// create GPT (empty)
[1]	141	error = hal_gpt_create( &vmm->gpt );
	142
[409]	143	assert( (error == 0) , __FUNCTION__ , "cannot create GPT\n");
[204]	144
[409]	145	// architecture specific GPT initialization
	146	// (For TSAR, identity map the kentry_vseg)
	147	error = hal_vmm_init( vmm );
	148
	149	assert( (error == 0) , __FUNCTION__ , "cannot initialize GPT\n");
	150
[1]	151	// initialize STACK allocator
	152	vmm->stack_mgr.bitmap = 0;
	153	vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
	154
	155	// initialize MMAP allocator
[407]	156	vmm->mmap_mgr.vpn_base = CONFIG_VMM_HEAP_BASE;
	157	vmm->mmap_mgr.vpn_size = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
	158	vmm->mmap_mgr.first_free_vpn = CONFIG_VMM_HEAP_BASE;
[1]	159	uint32_t i;
	160	for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
	161
[21]	162	// initialize instrumentation counters
[409]	163	vmm->pgfault_nr = 0;
[1]	164
[124]	165	hal_fence();
[1]	166
[407]	167	vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x / entry_point = %x\n",
	168	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
	169	process->pid , process->vmm.entry_point );
[204]	170
	171	} // end vmm_init()
	172
[407]	173	//////////////////////////////////////
	174	void vmm_display( process_t * process,
	175	bool_t mapping )
	176	{
	177	vmm_t * vmm = &process->vmm;
	178	gpt_t * gpt = &vmm->gpt;
	179
	180	printk("\n***** VSL and GPT for process %x\n\n",
	181	process->pid );
	182
	183	// get lock protecting the vseg list
[408]	184	remote_rwlock_rd_lock( XPTR( local_cxy , &vmm->vsegs_lock ) );
[407]	185
	186	// scan the list of vsegs
[408]	187	xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
	188	xptr_t iter_xp;
	189	xptr_t vseg_xp;
[407]	190	vseg_t * vseg;
[408]	191	XLIST_FOREACH( root_xp , iter_xp )
[407]	192	{
[408]	193	vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
	194	vseg = (vseg_t *)GET_PTR( vseg_xp );
	195
[407]	196	printk(" - %s : base = %X / size = %X / npages = %d\n",
	197	vseg_type_str( vseg->type ) , vseg->min , vseg->max - vseg->min , vseg->vpn_size );
	198
	199	if( mapping )
	200	{
	201	vpn_t vpn;
	202	ppn_t ppn;
	203	uint32_t attr;
	204	vpn_t base = vseg->vpn_base;
	205	vpn_t size = vseg->vpn_size;
	206	for( vpn = base ; vpn < (base+size) ; vpn++ )
	207	{
	208	hal_gpt_get_pte( gpt , vpn , &attr , &ppn );
	209	if( attr & GPT_MAPPED )
	210	{
	211	printk(" . vpn = %X / attr = %X / ppn = %X\n", vpn , attr , ppn );
	212	}
	213	}
	214	}
	215	}
	216
	217	// release the lock
[408]	218	remote_rwlock_rd_unlock( XPTR( local_cxy , &vmm->vsegs_lock ) );
[407]	219
[408]	220	} // vmm_display()
	221
	222	/////////////////////i////////////////////
	223	void vmm_update_pte( process_t * process,
	224	vpn_t vpn,
	225	uint32_t attr,
	226	ppn_t ppn )
[23]	227	{
	228
[408]	229	xlist_entry_t * process_root_ptr;
	230	xptr_t process_root_xp;
	231	xptr_t process_iter_xp;
[23]	232
[408]	233	xptr_t remote_process_xp;
	234	cxy_t remote_process_cxy;
	235	process_t * remote_process_ptr;
	236	xptr_t remote_gpt_xp;
[23]	237
[408]	238	pid_t pid;
	239	cxy_t owner_cxy;
	240	lpid_t owner_lpid;
[23]	241
[408]	242	// get extended pointer on root of process copies xlist in owner cluster
	243	pid = process->pid;
	244	owner_cxy = CXY_FROM_PID( pid );
	245	owner_lpid = LPID_FROM_PID( pid );
	246	process_root_ptr = &LOCAL_CLUSTER->pmgr.copies_root[owner_lpid];
	247	process_root_xp = XPTR( owner_cxy , process_root_ptr );
[23]	248
[408]	249	// loop on destination process copies
	250	XLIST_FOREACH( process_root_xp , process_iter_xp )
	251	{
	252	// get cluster and local pointer on remote process
	253	remote_process_xp = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
	254	remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
	255	remote_process_cxy = GET_CXY( remote_process_xp );
[407]	256
[408]	257	// get extended pointer on remote gpt
	258	remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
	259
	260	hal_gpt_update_pte( remote_gpt_xp,
	261	vpn,
	262	attr,
	263	ppn );
	264	}
	265	} // end vmm_update_pte()
	266
	267	///////////////////////////////////////
	268	void vmm_set_cow( process_t * process )
	269	{
	270	vmm_t * vmm;
	271
	272	xlist_entry_t * process_root_ptr;
	273	xptr_t process_root_xp;
	274	xptr_t process_iter_xp;
	275
	276	xptr_t remote_process_xp;
	277	cxy_t remote_process_cxy;
	278	process_t * remote_process_ptr;
	279	xptr_t remote_gpt_xp;
	280
	281	xptr_t vseg_root_xp;
	282	xptr_t vseg_iter_xp;
	283
	284	xptr_t vseg_xp;
	285	vseg_t * vseg;
	286
	287	pid_t pid;
	288	cxy_t owner_cxy;
	289	lpid_t owner_lpid;
	290
	291	vmm_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n",
	292	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
	293
	294	// check cluster is reference
	295	assert( (GET_CXY( process->ref_xp ) == local_cxy) , __FUNCTION__,
	296	"local cluster is not process reference cluster\n");
	297
	298	// get pointer on reference VMM
	299	vmm = &process->vmm;
	300
	301	// get extended pointer on root of process copies xlist in owner cluster
	302	pid = process->pid;
	303	owner_cxy = CXY_FROM_PID( pid );
	304	owner_lpid = LPID_FROM_PID( pid );
	305	process_root_ptr = &LOCAL_CLUSTER->pmgr.copies_root[owner_lpid];
	306	process_root_xp = XPTR( owner_cxy , process_root_ptr );
	307
	308	// get extended pointer on root of vsegs xlist from reference VMM
	309	vseg_root_xp = XPTR( local_cxy , &vmm->vsegs_root );
	310
	311	// loop on destination process copies
	312	XLIST_FOREACH( process_root_xp , process_iter_xp )
	313	{
	314	// get cluster and local pointer on remote process
	315	remote_process_xp = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
	316	remote_process_ptr = (process_t *)GET_PTR( remote_process_xp );
	317	remote_process_cxy = GET_CXY( remote_process_xp );
	318
	319	vmm_dmsg("\n[DBG] %s : core[%x,%d] handling process %x in cluster %x\n",
	320	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid , remote_process_cxy );
	321
	322	// get extended pointer on remote gpt
	323	remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
	324
	325	// loop on vsegs in (local) reference process VSL
	326	XLIST_FOREACH( vseg_root_xp , vseg_iter_xp )
	327	{
	328	// get pointer on vseg
	329	vseg_xp = XLIST_ELEMENT( vseg_iter_xp , vseg_t , xlist );
	330	vseg = (vseg_t *)GET_PTR( vseg_xp );
	331
	332	assert( (GET_CXY( vseg_xp ) == local_cxy) , __FUNCTION__,
	333	"all vsegs in reference VSL must be local\n" );
	334
	335	// get vseg type, base and size
	336	uint32_t type = vseg->type;
	337	vpn_t vpn_base = vseg->vpn_base;
	338	vpn_t vpn_size = vseg->vpn_size;
	339
	340	vmm_dmsg("\n[DBG] %s : core[%x,%d] handling vseg %s / vpn_base = %x / vpn_size = %x\n",
	341	__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vseg_type_str(type), vpn_base, vpn_size );
	342
	343	// set COW flag on the remote GPT depending on vseg type
	344	if( (type == VSEG_TYPE_DATA) \|\|
	345	(type == VSEG_TYPE_ANON) \|\|
	346	(type == VSEG_TYPE_REMOTE) )
	347	{
	348	hal_gpt_flip_cow( true, // set_cow
	349	remote_gpt_xp,
	350	vpn_base,
	351	vpn_size );
	352	}
	353	} // en loop on vsegs
	354	} // end loop on process copies
	355
	356	vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
	357	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
	358
	359	} // end vmm_set-cow()
	360
	361	/////////////////////////////////////////////////
	362	error_t vmm_fork_copy( process_t * child_process,
	363	xptr_t parent_process_xp )
	364	{
	365	error_t error;
	366	cxy_t parent_cxy;
	367	process_t * parent_process;
	368	vmm_t * parent_vmm;
	369	xptr_t parent_lock_xp;
	370	vmm_t * child_vmm;
	371	xptr_t iter_xp;
	372	xptr_t parent_vseg_xp;
	373	vseg_t * parent_vseg;
	374	vseg_t * child_vseg;
	375	uint32_t type;
	376	bool_t cow;
	377	vpn_t vpn;
	378	vpn_t vpn_base;
	379	vpn_t vpn_size;
	380	xptr_t page_xp;
	381	page_t * page_ptr;
	382	cxy_t page_cxy;
	383	xptr_t parent_root_xp;
	384	bool_t mapped;
	385	ppn_t ppn;
	386
	387	vmm_dmsg("\n[DBG] %s : core[%x,%d] enter\n",
	388	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
	389
	390	// get parent process cluster and local pointer
	391	parent_cxy = GET_CXY( parent_process_xp );
	392	parent_process = (process_t *)GET_PTR( parent_process_xp );
	393
	394	// get local pointers on parent and child VMM
	395	parent_vmm = &parent_process->vmm;
	396	child_vmm = &child_process->vmm;
	397
	398	// get extended pointer on lock protecting the parent VSL
	399	parent_lock_xp = XPTR( parent_cxy , &parent_vmm->vsegs_lock );
	400
	401	// take the lock protecting the parent VSL
	402	remote_rwlock_rd_lock( parent_lock_xp );
	403
	404	// initialize the lock protecting the child VSL
	405	remote_rwlock_init( XPTR( local_cxy , &child_vmm->vsegs_lock ) );
	406
	407	// initialize the child VSL as empty
	408	xlist_root_init( XPTR( local_cxy, &child_vmm->vsegs_root ) );
	409	child_vmm->vsegs_nr = 0;
	410
	411	// create & initialize the child GPT as empty
	412	error = hal_gpt_create( &child_vmm->gpt );
[407]	413	if( error )
	414	{
[408]	415	printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
	416	return -1;
[407]	417	}
	418
[408]	419	// build extended pointer on parent VSL
	420	parent_root_xp = XPTR( parent_cxy , &parent_vmm->vsegs_root );
	421
	422	// loop on parent VSL xlist
	423	XLIST_FOREACH( parent_root_xp , iter_xp )
[23]	424	{
[408]	425	// get local and extended pointers on current parent vseg
	426	parent_vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
	427	parent_vseg = (vseg_t *)GET_PTR( parent_vseg_xp );
[23]	428
[408]	429	// get vseg type
	430	type = hal_remote_lw( XPTR( parent_cxy , &parent_vseg->type ) );
	431
[23]	432
[408]	433	vmm_dmsg("\n[DBG] %s : core[%x,%d] found parent vseg %s / vpn_base = %x\n",
	434	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
	435	hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
	436
	437	// all parent vsegs - but STACK - must be copied in child VSL
	438	if( type != VSEG_TYPE_STACK )
[23]	439	{
[408]	440	// allocate memory for a new child vseg
	441	child_vseg = vseg_alloc();
	442	if( child_vseg == NULL ) // release all allocated vsegs
[23]	443	{
[408]	444	vmm_destroy( child_process );
	445	printk("\n[ERROR] in %s : cannot create vseg for child\n", __FUNCTION__ );
	446	return -1;
[23]	447	}
	448
[408]	449	// copy parent vseg to child vseg
	450	vseg_init_from_ref( child_vseg , parent_vseg_xp );
[23]	451
[408]	452	// register child vseg in child VSL
	453	vseg_attach( child_vmm , child_vseg );
[407]	454
[408]	455	vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child VSL : vseg %s / vpn_base = %x\n",
	456	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vseg_type_str(type),
	457	hal_remote_lw( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) );
[23]	458
[408]	459	// copy DATA, MMAP, REMOTE, FILE parent GPT entries to child GPT
	460	if( type != VSEG_TYPE_CODE )
	461	{
	462	// activate the COW for DATA, MMAP, REMOTE vsegs only
	463	cow = ( type != VSEG_TYPE_FILE );
[23]	464
[408]	465	vpn_base = child_vseg->vpn_base;
	466	vpn_size = child_vseg->vpn_size;
[23]	467
[408]	468	// scan pages in parent vseg
	469	for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
	470	{
	471	error = hal_gpt_pte_copy( &child_vmm->gpt,
	472	XPTR( parent_cxy , &parent_vmm->gpt ),
	473	vpn,
	474	cow,
	475	&ppn,
	476	&mapped );
	477	if( error )
	478	{
	479	vmm_destroy( child_process );
	480	printk("\n[ERROR] in %s : cannot copy GPT\n", __FUNCTION__ );
	481	return -1;
	482	}
	483
	484	// increment page descriptor fork_nr for the referenced page if mapped
	485	if( mapped )
	486	{
	487	page_xp = ppm_ppn2page( ppn );
	488	page_cxy = GET_CXY( page_xp );
	489	page_ptr = (page_t *)GET_PTR( page_xp );
	490	hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , 1 );
	491
	492	vmm_dmsg("\n[DBG] %s : core[%x,%d] copied to child GPT : vpn %x\n",
	493	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
	494
	495	}
	496	}
	497	} // end if no code & no stack
	498	} // end if no stack
	499	} // end loop on vsegs
	500
	501	// release the parent vsegs lock
	502	remote_rwlock_rd_unlock( parent_lock_xp );
	503
	504	// initialize the child VMM STACK allocator
	505	child_vmm->stack_mgr.bitmap = 0;
	506	child_vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
	507
	508	// initialize the child VMM MMAP allocator
[23]	509	uint32_t i;
[408]	510	child_vmm->mmap_mgr.vpn_base = CONFIG_VMM_HEAP_BASE;
	511	child_vmm->mmap_mgr.vpn_size = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
	512	child_vmm->mmap_mgr.first_free_vpn = CONFIG_VMM_HEAP_BASE;
	513	for( i = 0 ; i < 32 ; i++ ) list_root_init( &child_vmm->mmap_mgr.zombi_list[i] );
[23]	514
[178]	515	// initialize instrumentation counters
[408]	516	child_vmm->pgfault_nr = 0;
[23]	517
[408]	518	// copy base addresses from parent VMM to child VMM
	519	child_vmm->kent_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->kent_vpn_base));
	520	child_vmm->args_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->args_vpn_base));
	521	child_vmm->envs_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->envs_vpn_base));
	522	child_vmm->heap_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->heap_vpn_base));
	523	child_vmm->code_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->code_vpn_base));
	524	child_vmm->data_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->data_vpn_base));
[23]	525
[408]	526	child_vmm->entry_point = (intptr_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->entry_point));
[23]	527
[124]	528	hal_fence();
[23]	529
	530	return 0;
	531
[408]	532	} // vmm_fork_copy()
[204]	533
[1]	534	///////////////////////////////////////
	535	void vmm_destroy( process_t * process )
	536	{
[408]	537	xptr_t vseg_xp;
[1]	538	vseg_t * vseg;
	539
	540	// get pointer on VMM
	541	vmm_t * vmm = &process->vmm;
	542
[409]	543	// @@@
	544	vmm_display( process , true );
	545	// @@@
	546
[408]	547	// get extended pointer on VSL root and VSL lock
	548	xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
	549	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
	550
[1]	551	// get lock protecting vseg list
[408]	552	remote_rwlock_wr_lock( lock_xp );
[1]	553
[409]	554	// remove all user vsegs registered in VSL
[408]	555	while( !xlist_is_empty( root_xp ) )
[1]	556	{
[409]	557	// get pointer on first vseg in VSL
[408]	558	vseg_xp = XLIST_FIRST_ELEMENT( root_xp , vseg_t , xlist );
	559	vseg = (vseg_t *)GET_PTR( vseg_xp );
[409]	560
	561	printk("\n@@@ %s : vseg %s\n", __FUNCTION__ , vseg_type_str( vseg->type ) );
	562
	563	// unmap and release all pages
	564	vmm_unmap_vseg( process , vseg );
	565
	566	// remove vseg from VSL
[1]	567	vseg_detach( vmm , vseg );
[409]	568
	569	// release memory allocated to vseg descriptor
[1]	570	vseg_free( vseg );
	571	}
	572
	573	// release lock
[408]	574	remote_rwlock_wr_unlock( lock_xp );
[1]	575
	576	// remove all vsegs from zombi_lists in MMAP allocator
	577	uint32_t i;
	578	for( i = 0 ; i<32 ; i++ )
	579	{
	580	while( !list_is_empty( &vmm->mmap_mgr.zombi_list[i] ) )
	581	{
[408]	582	vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , zlist );
[1]	583	vseg_detach( vmm , vseg );
	584	vseg_free( vseg );
	585	}
	586	}
	587
[409]	588	// release memory allocated to the GPT itself
[1]	589	hal_gpt_destroy( &vmm->gpt );
	590
[204]	591	} // end vmm_destroy()
	592
[1]	593	/////////////////////////////////////////////////
	594	vseg_t * vmm_check_conflict( process_t * process,
[21]	595	vpn_t vpn_base,
[1]	596	vpn_t vpn_size )
	597	{
	598	vmm_t * vmm = &process->vmm;
[408]	599
	600	// scan the VSL
[1]	601	vseg_t * vseg;
[408]	602	xptr_t iter_xp;
	603	xptr_t vseg_xp;
	604	xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
[1]	605
[408]	606	XLIST_FOREACH( root_xp , iter_xp )
[1]	607	{
[408]	608	vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
	609	vseg = (vseg_t *)GET_PTR( vseg_xp );
[204]	610
[21]	611	if( ((vpn_base + vpn_size) > vseg->vpn_base) &&
	612	(vpn_base < (vseg->vpn_base + vseg->vpn_size)) ) return vseg;
[1]	613	}
	614	return NULL;
	615
[204]	616	} // end vmm_check_conflict()
	617
[1]	618	////////////////////////////////////////////////////////////////////////////////////////////
	619	// This static function is called by the vmm_create_vseg() function, and implements
	620	// the VMM stack_vseg specific allocator.
	621	////////////////////////////////////////////////////////////////////////////////////////////
	622	// @ vmm : pointer on VMM.
[21]	623	// @ vpn_base : (return value) first allocated page
[1]	624	// @ vpn_size : (return value) number of allocated pages
	625	////////////////////////////////////////////////////////////////////////////////////////////
	626	static error_t vmm_stack_alloc( vmm_t * vmm,
	627	vpn_t * vpn_base,
	628	vpn_t * vpn_size )
	629	{
	630	// get stack allocator pointer
	631	stack_mgr_t * mgr = &vmm->stack_mgr;
	632
	633	// get lock on stack allocator
	634	spinlock_lock( &mgr->lock );
	635
	636	// get first free slot index in bitmap
	637	int32_t index = bitmap_ffc( &mgr->bitmap , 4 );
[179]	638	if( (index < 0) \|\| (index > 31) )
	639	{
	640	spinlock_unlock( &mgr->lock );
	641	return ENOMEM;
	642	}
[1]	643
	644	// update bitmap
	645	bitmap_set( &mgr->bitmap , index );
[21]	646
[1]	647	// release lock on stack allocator
	648	spinlock_unlock( &mgr->lock );
	649
[21]	650	// returns vpn_base, vpn_size (one page non allocated)
[1]	651	vpn_base = mgr->vpn_base + index CONFIG_VMM_STACK_SIZE + 1;
	652	*vpn_size = CONFIG_VMM_STACK_SIZE - 1;
	653	return 0;
	654
[204]	655	} // end vmm_stack_alloc()
	656
[1]	657	////////////////////////////////////////////////////////////////////////////////////////////
	658	// This static function is called by the vmm_create_vseg() function, and implements
	659	// the VMM MMAP specific allocator.
	660	////////////////////////////////////////////////////////////////////////////////////////////
	661	// @ vmm : [in] pointer on VMM.
	662	// @ npages : [in] requested number of pages.
[21]	663	// @ vpn_base : [out] first allocated page.
[1]	664	// @ vpn_size : [out] actual number of allocated pages.
	665	////////////////////////////////////////////////////////////////////////////////////////////
	666	static error_t vmm_mmap_alloc( vmm_t * vmm,
	667	vpn_t npages,
	668	vpn_t * vpn_base,
	669	vpn_t * vpn_size )
	670	{
	671	uint32_t index;
	672	vseg_t * vseg;
	673	vpn_t base;
	674	vpn_t size;
[21]	675	vpn_t free;
[1]	676
[21]	677	// mmap vseg size must be power of 2
[1]	678	// compute actual size and index in zombi_list array
	679	size = POW2_ROUNDUP( npages );
	680	index = bits_log2( size );
	681
	682	// get mmap allocator pointer
	683	mmap_mgr_t * mgr = &vmm->mmap_mgr;
	684
	685	// get lock on mmap allocator
	686	spinlock_lock( &mgr->lock );
	687
	688	// get vseg from zombi_list or from mmap zone
	689	if( list_is_empty( &mgr->zombi_list[index] ) ) // from mmap zone
	690	{
	691	// check overflow
	692	free = mgr->first_free_vpn;
	693	if( (free + size) > mgr->vpn_size ) return ENOMEM;
	694
	695	// update STACK allocator
	696	mgr->first_free_vpn += size;
	697
	698	// compute base
	699	base = free;
	700	}
	701	else // from zombi_list
	702	{
	703	// get pointer on zombi vseg from zombi_list
[408]	704	vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , zlist );
[1]	705
	706	// remove vseg from free-list
[408]	707	list_unlink( &vseg->zlist );
[1]	708
	709	// compute base
	710	base = vseg->vpn_base;
[21]	711	}
	712
[1]	713	// release lock on mmap allocator
	714	spinlock_unlock( &mgr->lock );
	715
	716	// returns vpn_base, vpn_size
	717	*vpn_base = base;
	718	*vpn_size = size;
	719	return 0;
	720
[204]	721	} // end vmm_mmap_alloc()
	722
[407]	723	////////////////////////////////////////////////
	724	vseg_t * vmm_create_vseg( process_t * process,
	725	vseg_type_t type,
	726	intptr_t base,
	727	uint32_t size,
	728	uint32_t file_offset,
	729	uint32_t file_size,
	730	xptr_t mapper_xp,
	731	cxy_t cxy )
[1]	732	{
	733	vseg_t * vseg; // created vseg pointer
[204]	734	vpn_t vpn_base; // first page index
[1]	735	vpn_t vpn_size; // number of pages
	736	error_t error;
	737
[407]	738	vmm_dmsg("\n[DBG] %s : core[%x,%d] enters / process %x / base %x / size %x / %s / cxy = %x\n",
	739	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
	740	process->pid , base , size , vseg_type_str(type) , cxy );
[21]	741
[407]	742	// get pointer on VMM
	743	vmm_t * vmm = &process->vmm;
[21]	744
[204]	745	// compute base, size, vpn_base, vpn_size, depending on vseg type
[407]	746	// we use the VMM specific allocators for "stack", "file", "anon", & "remote" vsegs
[1]	747	if( type == VSEG_TYPE_STACK )
	748	{
	749	// get vpn_base and vpn_size from STACK allocator
	750	error = vmm_stack_alloc( vmm , &vpn_base , &vpn_size );
	751	if( error )
	752	{
[407]	753	printk("\n[ERROR] in %s : no space for stack vseg / process %x in cluster %x\n",
	754	__FUNCTION__ , process->pid , local_cxy );
[1]	755	return NULL;
	756	}
	757
	758	// compute vseg base and size from vpn_base and vpn_size
	759	base = vpn_base << CONFIG_PPM_PAGE_SHIFT;
	760	size = vpn_size << CONFIG_PPM_PAGE_SHIFT;
	761	}
[21]	762	else if( (type == VSEG_TYPE_ANON) \|\|
	763	(type == VSEG_TYPE_FILE) \|\|
[1]	764	(type == VSEG_TYPE_REMOTE) )
	765	{
	766	// get vpn_base and vpn_size from MMAP allocator
	767	vpn_t npages = size >> CONFIG_PPM_PAGE_SHIFT;
	768	error = vmm_mmap_alloc( vmm , npages , &vpn_base , &vpn_size );
	769	if( error )
	770	{
	771	printk("\n[ERROR] in %s : no vspace for mmap vseg / process %x in cluster %x\n",
	772	__FUNCTION__ , process->pid , local_cxy );
	773	return NULL;
	774	}
	775
	776	// compute vseg base and size from vpn_base and vpn_size
	777	base = vpn_base << CONFIG_PPM_PAGE_SHIFT;
	778	size = vpn_size << CONFIG_PPM_PAGE_SHIFT;
	779	}
	780	else
	781	{
[204]	782	uint32_t vpn_min = base >> CONFIG_PPM_PAGE_SHIFT;
	783	uint32_t vpn_max = (base + size - 1) >> CONFIG_PPM_PAGE_SHIFT;
	784
	785	vpn_base = vpn_min;
	786	vpn_size = vpn_max - vpn_min + 1;
[1]	787	}
	788
	789	// check collisions
	790	vseg = vmm_check_conflict( process , vpn_base , vpn_size );
	791	if( vseg != NULL )
	792	{
[21]	793	printk("\n[ERROR] in %s for process %x : new vseg [vpn_base = %x / vpn_size = %x]\n"
[1]	794	" overlap existing vseg [vpn_base = %x / vpn_size = %x]\n",
[407]	795	__FUNCTION__ , process->pid, vpn_base, vpn_size, vseg->vpn_base, vseg->vpn_size );
[1]	796	return NULL;
	797	}
	798
	799	// allocate physical memory for vseg descriptor
	800	vseg = vseg_alloc();
	801	if( vseg == NULL )
	802	{
	803	printk("\n[ERROR] in %s for process %x : cannot allocate memory for vseg\n",
[407]	804	__FUNCTION__ , process->pid );
[1]	805	return NULL;
	806	}
	807
	808	// initialize vseg descriptor
[407]	809	vseg_init( vseg,
	810	type,
	811	base,
	812	size,
	813	vpn_base,
	814	vpn_size,
	815	file_offset,
	816	file_size,
	817	mapper_xp,
	818	cxy );
[1]	819
[408]	820	// attach vseg to VSL
	821	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
	822	remote_rwlock_wr_lock( lock_xp );
[1]	823	vseg_attach( vmm , vseg );
[408]	824	remote_rwlock_wr_unlock( lock_xp );
[1]	825
[407]	826	vmm_dmsg("\n[DBG] %s : core[%x,%d] exit / process %x / base %x / size %x / type %s\n",
	827	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
	828	process->pid , base , size , vseg_type_str(type) );
[21]	829
[1]	830	return vseg;
	831
[406]	832	} // vmm_create_vseg()
	833
[1]	834	/////////////////////////////////////
	835	void vmm_remove_vseg( vseg_t * vseg )
	836	{
	837	// get pointers on calling process and VMM
	838	thread_t * this = CURRENT_THREAD;
	839	process_t * process = this->process;
	840	vmm_t * vmm = &this->process->vmm;
	841	uint32_t type = vseg->type;
	842
[408]	843	// detach vseg from VSL
	844	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
	845	remote_rwlock_wr_lock( lock_xp );
	846	vseg_detach( &process->vmm , vseg );
	847	remote_rwlock_wr_unlock( lock_xp );
[1]	848
	849	// release the stack slot to VMM stack allocator if STACK type
	850	if( type == VSEG_TYPE_STACK )
	851	{
	852	// get pointer on stack allocator
	853	stack_mgr_t * mgr = &vmm->stack_mgr;
	854
	855	// compute slot index
	856	uint32_t index = ((vseg->vpn_base - mgr->vpn_base - 1) / CONFIG_VMM_STACK_SIZE);
	857
	858	// update stacks_bitmap
	859	spinlock_lock( &mgr->lock );
	860	bitmap_clear( &mgr->bitmap , index );
	861	spinlock_unlock( &mgr->lock );
	862	}
	863
	864	// release the vseg to VMM mmap allocator if MMAP type
	865	if( (type == VSEG_TYPE_ANON) \|\| (type == VSEG_TYPE_FILE) \|\| (type == VSEG_TYPE_REMOTE) )
	866	{
	867	// get pointer on mmap allocator
	868	mmap_mgr_t * mgr = &vmm->mmap_mgr;
	869
	870	// compute zombi_list index
	871	uint32_t index = bits_log2( vseg->vpn_size );
	872
	873	// update zombi_list
	874	spinlock_lock( &mgr->lock );
[408]	875	list_add_first( &mgr->zombi_list[index] , &vseg->zlist );
[1]	876	spinlock_unlock( &mgr->lock );
	877	}
	878
	879	// release physical memory allocated for vseg descriptor if no MMAP type
	880	if( (type != VSEG_TYPE_ANON) && (type != VSEG_TYPE_FILE) && (type != VSEG_TYPE_REMOTE) )
	881	{
	882	vseg_free( vseg );
	883	}
[407]	884	} // end vmm_remove_vseg()
[1]	885
[68]	886	//////////////////////////////////////////////
	887	error_t vmm_map_kernel_vseg( vseg_t * vseg,
	888	uint32_t attr )
[1]	889	{
	890	vpn_t vpn; // VPN of PTE to be set
	891	vpn_t vpn_min; // VPN of first PTE to be set
	892	vpn_t vpn_max; // VPN of last PTE to be set (excluded)
	893	ppn_t ppn; // PPN of allocated physical page
	894	uint32_t order; // ln( number of small pages for one single PTE )
	895	page_t * page;
	896	error_t error;
	897
[68]	898	// check vseg type : must be a kernel vseg
[1]	899	uint32_t type = vseg->type;
[68]	900	assert( ((type==VSEG_TYPE_KCODE) \|\| (type==VSEG_TYPE_KDATA) \|\| (type==VSEG_TYPE_KDEV)),
	901	__FUNCTION__ , "not a kernel vseg\n" );
[1]	902
	903	// get pointer on page table
	904	gpt_t * gpt = &process_zero.vmm.gpt;
	905
[21]	906	// define number of small pages per PTE
[1]	907	if( attr & GPT_SMALL ) order = 0; // 1 small page
	908	else order = 9; // 512 small pages
	909
	910	// loop on pages in vseg
	911	vpn_min = vseg->vpn_base;
	912	vpn_max = vpn_min + vseg->vpn_size;
	913	for( vpn = vpn_min ; vpn < vpn_max ; vpn++ )
	914	{
[68]	915	// allocate a physical page from local PPM
[1]	916	kmem_req_t req;
	917	req.type = KMEM_PAGE;
	918	req.size = order;
	919	req.flags = AF_KERNEL \| AF_ZERO;
	920	page = (page_t *)kmem_alloc( &req );
[21]	921	if( page == NULL )
[1]	922	{
	923	printk("\n[ERROR] in %s : cannot allocate physical memory\n", __FUNCTION__ );
	924	return ENOMEM;
	925	}
	926
	927	// set page table entry
[315]	928	ppn = ppm_page2ppn( XPTR( local_cxy , page ) );
[408]	929	error = hal_gpt_set_pte( gpt,
	930	vpn,
	931	attr,
	932	ppn );
[21]	933	if( error )
[1]	934	{
	935	printk("\n[ERROR] in %s : cannot register PPE\n", __FUNCTION__ );
	936	return ENOMEM;
	937	}
	938	}
[21]	939
[1]	940	return 0;
	941
[408]	942	} // end vmm_map_kernel_vseg()
	943
[1]	944	/////////////////////////////////////////
	945	void vmm_unmap_vseg( process_t * process,
	946	vseg_t * vseg )
	947	{
[21]	948	vpn_t vpn; // VPN of current PTE
	949	vpn_t vpn_min; // VPN of first PTE
[1]	950	vpn_t vpn_max; // VPN of last PTE (excluded)
[409]	951	ppn_t ppn; // current PTE ppn value
	952	uint32_t attr; // current PTE attributes
	953	kmem_req_t req; // request to release memory
	954	xptr_t page_xp; // extended pointer on page descriptor
	955	cxy_t page_cxy; // page descriptor cluster
	956	page_t * page_ptr; // page descriptor pointer
[1]	957
[409]	958	vmm_dmsg("\n[DBG] %s : core[%x, %d] enter / process %x / vseg %s / base %x / cycle %d\n",
	959	__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, process->pid ,
	960	vseg_type_str( vseg->type ), vseg->vpn_base, (uint32_t)hal_get_cycles() );
	961
	962	// get pointer on process GPT
[1]	963	gpt_t * gpt = &process->vmm.gpt;
	964
	965	// loop on pages in vseg
	966	vpn_min = vseg->vpn_base;
	967	vpn_max = vpn_min + vseg->vpn_size;
	968	for( vpn = vpn_min ; vpn < vpn_max ; vpn++ )
	969	{
[409]	970	// get GPT entry
	971	hal_gpt_get_pte( gpt , vpn , &attr , &ppn );
	972
	973	if( attr & GPT_MAPPED ) // entry is mapped
	974	{
	975	// check small page
	976	assert( (attr & GPT_SMALL) , __FUNCTION__ ,
	977	"an user vseg must use small pages" );
	978
	979	// unmap GPT entry
	980	hal_gpt_reset_pte( gpt , vpn );
	981
	982	// release memory if not identity mapped
	983	if( (vseg->flags & VSEG_IDENT) == 0 )
	984	{
	985	// get extended pointer on page descriptor
	986	page_xp = ppm_ppn2page( ppn );
	987	page_cxy = GET_CXY( page_xp );
	988	page_ptr = (page_t *)GET_PTR( page_xp );
	989
	990	// release physical page to relevant cluster
	991	if( page_cxy == local_cxy ) // local cluster
	992	{
	993	req.type = KMEM_PAGE;
	994	req.ptr = page_ptr;
	995	kmem_free( &req );
	996	}
	997	else // remote cluster
	998	{
	999	rpc_pmem_release_pages_client( page_cxy , page_ptr );
	1000	}
	1001	}
	1002	}
[1]	1003	}
[409]	1004	} // end vmm_unmap_vseg()
[1]	1005
[407]	1006	//////////////////////////////////////////////////////////////////////////////////////////
[406]	1007	// This low-level static function is called by the vmm_get_vseg() and vmm_resize_vseg()
	1008	// functions. It scan the list of registered vsegs to find the unique vseg containing
	1009	// a given virtual address.
[407]	1010	//////////////////////////////////////////////////////////////////////////////////////////
[406]	1011	// @ vmm : pointer on the process VMM.
	1012	// @ vaddr : virtual address.
	1013	// @ return vseg pointer if success / return NULL if not found.
[407]	1014	//////////////////////////////////////////////////////////////////////////////////////////
[406]	1015	static vseg_t * vseg_from_vaddr( vmm_t * vmm,
	1016	intptr_t vaddr )
	1017	{
[408]	1018	xptr_t iter_xp;
	1019	xptr_t vseg_xp;
	1020	vseg_t * vseg;
[406]	1021
[408]	1022	// get extended pointers on VSL lock and root
	1023	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
	1024	xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
[406]	1025
[408]	1026	// get lock protecting the VSL
	1027	remote_rwlock_rd_lock( lock_xp );
	1028
	1029	// scan the list of vsegs in VSL
	1030	XLIST_FOREACH( root_xp , iter_xp )
[406]	1031	{
[408]	1032	vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
	1033	vseg = (vseg_t *)GET_PTR( vseg_xp );
	1034	if( (vaddr >= vseg->min) && (vaddr < vseg->max) )
	1035	{
	1036	// return success
	1037	remote_rwlock_rd_unlock( lock_xp );
	1038	return vseg;
	1039	}
[406]	1040	}
	1041
[408]	1042	// return failure
	1043	remote_rwlock_rd_unlock( lock_xp );
	1044	return NULL;
[406]	1045
[408]	1046	} // end vseg_from_vaddr()
[406]	1047
[1]	1048	/////////////////////////////////////////////
	1049	error_t vmm_resize_vseg( process_t * process,
	1050	intptr_t base,
	1051	intptr_t size )
	1052	{
[406]	1053	error_t error;
	1054	vseg_t * new;
	1055	vpn_t vpn_min;
	1056	vpn_t vpn_max;
[1]	1057
	1058	// get pointer on process VMM
	1059	vmm_t * vmm = &process->vmm;
	1060
	1061	intptr_t addr_min = base;
	1062	intptr_t addr_max = base + size;
	1063
	1064	// get pointer on vseg
[406]	1065	vseg_t * vseg = vseg_from_vaddr( vmm , base );
[1]	1066
	1067	if( vseg == NULL) return EINVAL;
[21]	1068
[408]	1069	// get extended pointer on VSL lock
	1070	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
[21]	1071
[408]	1072	// get lock protecting VSL
	1073	remote_rwlock_wr_lock( lock_xp );
	1074
[1]	1075	if( (vseg->min > addr_min) \|\| (vseg->max < addr_max) ) // region not included in vseg
	1076	{
	1077	error = EINVAL;
	1078	}
	1079	else if( (vseg->min == addr_min) && (vseg->max == addr_max) ) // vseg must be removed
	1080	{
	1081	vmm_remove_vseg( vseg );
	1082	error = 0;
	1083	}
[406]	1084	else if( vseg->min == addr_min ) // vseg must be resized
[1]	1085	{
[406]	1086	// update vseg base address
	1087	vseg->min = addr_max;
	1088
	1089	// update vpn_base and vpn_size
	1090	vpn_min = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
	1091	vpn_max = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
	1092	vseg->vpn_base = vpn_min;
	1093	vseg->vpn_size = vpn_max - vpn_min + 1;
	1094	error = 0;
[1]	1095	}
[406]	1096	else if( vseg->max == addr_max ) // vseg must be resized
[1]	1097	{
[406]	1098	// update vseg max address
	1099	vseg->max = addr_min;
	1100
	1101	// update vpn_base and vpn_size
	1102	vpn_min = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
	1103	vpn_max = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
	1104	vseg->vpn_base = vpn_min;
	1105	vseg->vpn_size = vpn_max - vpn_min + 1;
	1106	error = 0;
[1]	1107	}
[406]	1108	else // vseg cut in three regions
[1]	1109	{
[406]	1110	// resize existing vseg
	1111	vseg->max = addr_min;
	1112
	1113	// update vpn_base and vpn_size
	1114	vpn_min = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
	1115	vpn_max = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
	1116	vseg->vpn_base = vpn_min;
	1117	vseg->vpn_size = vpn_max - vpn_min + 1;
	1118
	1119	// create new vseg
[407]	1120	new = vmm_create_vseg( process,
	1121	vseg->type,
	1122	addr_min,
	1123	(vseg->max - addr_max),
	1124	vseg->file_offset,
	1125	vseg->file_size,
	1126	vseg->mapper_xp,
	1127	vseg->cxy );
	1128
[406]	1129	if( new == NULL ) error = EINVAL;
	1130	else error = 0;
[1]	1131	}
	1132
	1133	// release VMM lock
[408]	1134	remote_rwlock_wr_unlock( lock_xp );
[1]	1135
	1136	return error;
	1137
[406]	1138	} // vmm_resize_vseg()
	1139
[1]	1140	///////////////////////////////////////////
[388]	1141	error_t vmm_get_vseg( process_t * process,
[394]	1142	intptr_t vaddr,
[388]	1143	vseg_t ** found_vseg )
[1]	1144	{
[406]	1145	vmm_t * vmm = &process->vmm;
[1]	1146
[406]	1147	// get vseg from vaddr
	1148	vseg_t * vseg = vseg_from_vaddr( vmm , vaddr );
[1]	1149
[388]	1150	if( vseg == NULL ) // vseg not found in local cluster => try to get it from ref
	1151	{
	1152	// get extended pointer on reference process
	1153	xptr_t ref_xp = process->ref_xp;
[1]	1154
[388]	1155	// get cluster and local pointer on reference process
	1156	cxy_t ref_cxy = GET_CXY( ref_xp );
	1157	process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
	1158
	1159	if( local_cxy == ref_cxy ) return -1; // local cluster is the reference
	1160
	1161	// get extended pointer on reference vseg
	1162	xptr_t vseg_xp;
	1163	error_t error;
[406]	1164
[394]	1165	rpc_vmm_get_vseg_client( ref_cxy , ref_ptr , vaddr , &vseg_xp , &error );
[388]	1166
	1167	if( error ) return -1; // vseg not found => illegal user vaddr
	1168
	1169	// allocate a vseg in local cluster
	1170	vseg = vseg_alloc();
	1171
[406]	1172	if( vseg == NULL ) return -1;
[388]	1173
	1174	// initialise local vseg from reference
	1175	vseg_init_from_ref( vseg , vseg_xp );
	1176
	1177	// register local vseg in local VMM
[406]	1178	vseg_attach( &process->vmm , vseg );
[388]	1179	}
	1180
	1181	// success
	1182	*found_vseg = vseg;
[394]	1183	return 0;
[388]	1184
	1185	} // end vmm_get_vseg()
	1186
[407]	1187	//////////////////////////////////////////////////////////////////////////////////////
	1188	// This static function compute the target cluster to allocate a physical page
	1189	// for a given <vpn> in a given <vseg>, allocates the page (with an RPC if required)
	1190	// and returns an extended pointer on the allocated page descriptor.
	1191	// The vseg cannot have the FILE type.
	1192	//////////////////////////////////////////////////////////////////////////////////////
	1193	static xptr_t vmm_page_allocate( vseg_t * vseg,
	1194	vpn_t vpn )
	1195	{
	1196	// compute target cluster
	1197	page_t * page_ptr;
	1198	cxy_t page_cxy;
	1199	kmem_req_t req;
	1200
	1201	uint32_t type = vseg->type;
	1202	uint32_t flags = vseg->flags;
	1203
	1204	assert( ( type != VSEG_TYPE_FILE ) , __FUNCTION__ , "illegal vseg type\n" );
	1205
	1206	if( flags & VSEG_DISTRIB ) // distributed => cxy depends on vpn LSB
	1207	{
	1208	uint32_t x_size = LOCAL_CLUSTER->x_size;
	1209	uint32_t y_size = LOCAL_CLUSTER->y_size;
	1210	uint32_t y_width = LOCAL_CLUSTER->y_width;
	1211	uint32_t index = vpn & ((x_size * y_size) - 1);
	1212	uint32_t x = index / y_size;
	1213	uint32_t y = index % y_size;
	1214	page_cxy = (x<<y_width) + y;
	1215	}
	1216	else // other cases => cxy specified in vseg
	1217	{
	1218	page_cxy = vseg->cxy;
	1219	}
	1220
	1221	// allocate a physical page from target cluster
	1222	if( page_cxy == local_cxy ) // target cluster is the local cluster
	1223	{
	1224	req.type = KMEM_PAGE;
	1225	req.size = 0;
	1226	req.flags = AF_NONE;
	1227	page_ptr = (page_t *)kmem_alloc( &req );
	1228	}
	1229	else // target cluster is not the local cluster
	1230	{
	1231	rpc_pmem_get_pages_client( page_cxy , 0 , &page_ptr );
	1232	}
	1233
	1234	if( page_ptr == NULL ) return XPTR_NULL;
	1235	else return XPTR( page_cxy , page_ptr );
	1236
	1237	} // end vmm_page_allocate()
	1238
[313]	1239	////////////////////////////////////////
	1240	error_t vmm_get_one_ppn( vseg_t * vseg,
	1241	vpn_t vpn,
	1242	ppn_t * ppn )
	1243	{
	1244	error_t error;
[407]	1245	xptr_t page_xp; // extended pointer on physical page descriptor
[313]	1246	page_t * page_ptr; // local pointer on physical page descriptor
[406]	1247	uint32_t index; // missing page index in vseg mapper
	1248	uint32_t type; // vseg type;
[313]	1249
[406]	1250	type = vseg->type;
	1251	index = vpn - vseg->vpn_base;
[313]	1252
[407]	1253	vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x / type = %s / index = %d\n",
	1254	__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, vseg_type_str(type), index );
[313]	1255
[406]	1256	// FILE type : get the physical page from the file mapper
[313]	1257	if( type == VSEG_TYPE_FILE )
	1258	{
[406]	1259	// get extended pointer on mapper
[407]	1260	xptr_t mapper_xp = vseg->mapper_xp;
[313]	1261
[406]	1262	assert( (mapper_xp != XPTR_NULL), __FUNCTION__,
	1263	"mapper not defined for a FILE vseg\n" );
	1264
	1265	// get mapper cluster and local pointer
	1266	cxy_t mapper_cxy = GET_CXY( mapper_xp );
	1267	mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
	1268
[313]	1269	// get page descriptor from mapper
	1270	if( mapper_cxy == local_cxy ) // mapper is local
	1271	{
	1272	page_ptr = mapper_get_page( mapper_ptr , index );
	1273	}
	1274	else // mapper is remote
	1275	{
	1276	rpc_mapper_get_page_client( mapper_cxy , mapper_ptr , index , &page_ptr );
	1277	}
	1278
	1279	if ( page_ptr == NULL ) return EINVAL;
	1280
[407]	1281	page_xp = XPTR( mapper_cxy , page_ptr );
[313]	1282	}
	1283
[406]	1284	// Other types : allocate a physical page from target cluster,
[407]	1285	// as defined by vseg type and vpn value
[313]	1286	else
	1287	{
[407]	1288	// allocate physical page
	1289	page_xp = vmm_page_allocate( vseg , vpn );
[406]	1290
[407]	1291	if( page_xp == XPTR_NULL ) return ENOMEM;
[313]	1292
[406]	1293	// initialise missing page from .elf file mapper for DATA and CODE types
	1294	// => the mapper_xp field is an extended pointer on the .elf file mapper
[313]	1295	if( (type == VSEG_TYPE_CODE) \|\| (type == VSEG_TYPE_DATA) )
	1296	{
[406]	1297	// get extended pointer on mapper
	1298	xptr_t mapper_xp = vseg->mapper_xp;
[313]	1299
[406]	1300	assert( (mapper_xp != XPTR_NULL), __FUNCTION__,
	1301	"mapper not defined for a CODE or DATA vseg\n" );
	1302
	1303	// get mapper cluster and local pointer
	1304	cxy_t mapper_cxy = GET_CXY( mapper_xp );
	1305	mapper_t * mapper_ptr = (mapper_t *)GET_PTR( mapper_xp );
	1306
	1307	// compute missing page offset in vseg
	1308	uint32_t offset = index << CONFIG_PPM_PAGE_SHIFT;
	1309
[313]	1310	// compute missing page offset in .elf file
[406]	1311	uint32_t elf_offset = vseg->file_offset + offset;
[313]	1312
[407]	1313	vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / elf_offset = %x\n",
	1314	__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn, elf_offset );
[313]	1315
[406]	1316	// compute extended pointer on page base
[407]	1317	xptr_t base_xp = ppm_page2base( page_xp );
[313]	1318
[406]	1319	// file_size (in .elf mapper) can be smaller than vseg_size (BSS)
	1320	uint32_t file_size = vseg->file_size;
	1321
	1322	if( file_size < offset ) // missing page fully in BSS
[313]	1323	{
[407]	1324	vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / fully in BSS\n",
	1325	__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
[406]	1326
[407]	1327	if( GET_CXY( page_xp ) == local_cxy )
[313]	1328	{
[315]	1329	memset( GET_PTR( base_xp ) , 0 , CONFIG_PPM_PAGE_SIZE );
[313]	1330	}
	1331	else
	1332	{
[315]	1333	hal_remote_memset( base_xp , 0 , CONFIG_PPM_PAGE_SIZE );
[313]	1334	}
	1335	}
[406]	1336	else if( file_size >= (offset + CONFIG_PPM_PAGE_SIZE) ) // fully in mapper
[315]	1337	{
[406]	1338
[407]	1339	vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / fully in mapper\n",
	1340	__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn );
	1341
[313]	1342	if( mapper_cxy == local_cxy )
	1343	{
	1344	error = mapper_move_kernel( mapper_ptr,
	1345	true, // to_buffer
[406]	1346	elf_offset,
[313]	1347	base_xp,
[315]	1348	CONFIG_PPM_PAGE_SIZE );
[313]	1349	}
	1350	else
	1351	{
	1352	rpc_mapper_move_buffer_client( mapper_cxy,
	1353	mapper_ptr,
	1354	true, // to buffer
	1355	false, // kernel buffer
[406]	1356	elf_offset,
	1357	base_xp,
[315]	1358	CONFIG_PPM_PAGE_SIZE,
[313]	1359	&error );
	1360	}
	1361	if( error ) return EINVAL;
	1362	}
[406]	1363	else // both in mapper and in BSS :
	1364	// - (file_size - offset) bytes from mapper
	1365	// - (page_size + offset - file_size) bytes from BSS
[313]	1366	{
[406]	1367
[407]	1368	vmm_dmsg("\n[DBG] %s : core[%x,%d] for vpn = %x / both mapper & BSS\n"
	1369	" %d bytes from mapper / %d bytes from BSS\n",
	1370	__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, vpn,
	1371	file_size - offset , offset + CONFIG_PPM_PAGE_SIZE - file_size );
	1372
[313]	1373	// initialize mapper part
[315]	1374	if( mapper_cxy == local_cxy )
[313]	1375	{
	1376	error = mapper_move_kernel( mapper_ptr,
[315]	1377	true, // to buffer
[406]	1378	elf_offset,
[313]	1379	base_xp,
[406]	1380	file_size - offset );
[313]	1381	}
[315]	1382	else
[313]	1383	{
	1384	rpc_mapper_move_buffer_client( mapper_cxy,
	1385	mapper_ptr,
[315]	1386	true, // to buffer
[313]	1387	false, // kernel buffer
[406]	1388	elf_offset,
	1389	base_xp,
	1390	file_size - offset,
[313]	1391	&error );
	1392	}
	1393	if( error ) return EINVAL;
	1394
	1395	// initialize BSS part
[407]	1396	if( GET_CXY( page_xp ) == local_cxy )
[313]	1397	{
[406]	1398	memset( GET_PTR( base_xp ) + file_size - offset , 0 ,
	1399	offset + CONFIG_PPM_PAGE_SIZE - file_size );
[313]	1400	}
	1401	else
	1402	{
[406]	1403	hal_remote_memset( base_xp + file_size - offset , 0 ,
	1404	offset + CONFIG_PPM_PAGE_SIZE - file_size );
[313]	1405	}
	1406	}
	1407	} // end initialisation for CODE or DATA types
	1408	}
	1409
	1410	// return ppn
[407]	1411	*ppn = ppm_page2ppn( page_xp );
[406]	1412
[407]	1413	vmm_dmsg("\n[DBG] %s : core[%x,%d] exit for vpn = %x / ppn = %x\n",
	1414	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , *ppn );
[406]	1415
[313]	1416	return 0;
	1417
	1418	} // end vmm_get_one_ppn()
	1419
[1]	1420	/////////////////////////////////////////
	1421	error_t vmm_get_pte( process_t * process,
	1422	vpn_t vpn,
[407]	1423	bool_t cow,
	1424	uint32_t * attr,
	1425	ppn_t * ppn )
[1]	1426	{
[407]	1427	vseg_t * vseg; // pointer on vseg containing VPN
	1428	ppn_t old_ppn; // current PTE_PPN
	1429	uint32_t old_attr; // current PTE_ATTR
	1430	ppn_t new_ppn; // new PTE_PPN
	1431	uint32_t new_attr; // new PTE_ATTR
[1]	1432	error_t error;
	1433
[178]	1434	// this function must be called by a thread running in the reference cluster
[68]	1435	assert( (GET_CXY( process->ref_xp ) == local_cxy ) , __FUNCTION__ ,
[406]	1436	"not called in the reference cluster\n" );
[1]	1437
[407]	1438	vmm_dmsg("\n[DBG] %s : core[%x,%d] enter for vpn = %x in process %x / cow = %d\n",
[408]	1439	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , process->pid , cow );
[406]	1440
[1]	1441	// get VMM pointer
	1442	vmm_t * vmm = &process->vmm;
	1443
[407]	1444	// get vseg pointer from ref VSL
	1445	error = vmm_get_vseg( process , vpn<<CONFIG_PPM_PAGE_SHIFT , &vseg );
[1]	1446
[407]	1447	if( error )
[1]	1448	{
[407]	1449	printk("\n[ERROR] in %s : out of segment / process = %x / vpn = %x\n",
	1450	__FUNCTION__ , process->pid , vpn );
	1451	return error;
	1452	}
[406]	1453
[407]	1454	vmm_dmsg("\n[DBG] %s : core[%x,%d] found vseg %s / vpn_base = %x / vpn_size = %x\n",
	1455	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
	1456	vseg_type_str(vseg->type) , vseg->vpn_base , vseg->vpn_size );
[1]	1457
[407]	1458	// access GPT to get current PTE attributes and PPN
	1459	hal_gpt_get_pte( &vmm->gpt , vpn , &old_attr , &old_ppn );
	1460
[408]	1461	// for both "copy_on_write" and "page_fault" events, allocate a physical page,
	1462	// initialize it, register it in the reference GPT, update GPT copies in all
	1463	// clusters containing a copy, and return the new_ppn and new_attr
[407]	1464
	1465	if( cow ) ////////////// copy_on_write request ///////////
	1466	{
[408]	1467	assert( (old_attr & GPT_MAPPED) , __FUNCTION__ ,
	1468	"PTE must be mapped for a copy-on-write exception\n" );
[407]	1469
[408]	1470	excp_dmsg("\n[DBG] %s : core[%x,%d] handling COW for vpn %x\n",
[407]	1471	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
	1472
[408]	1473	// get extended pointer, cluster and local pointer on page descriptor
	1474	xptr_t page_xp = ppm_ppn2page( old_ppn );
	1475	cxy_t page_cxy = GET_CXY( page_xp );
	1476	page_t * page_ptr = (page_t *)GET_PTR( page_xp );
[407]	1477
[408]	1478	// get number of pending forks in page descriptor
	1479	uint32_t count = hal_remote_lw( XPTR( page_cxy , &page_ptr->fork_nr ) );
	1480
	1481	if( count ) // pending fork => allocate a new page, copy it, reset COW
[1]	1482	{
[408]	1483	// allocate a new physical page
	1484	page_xp = vmm_page_allocate( vseg , vpn );
	1485	if( page_xp == XPTR_NULL )
	1486	{
	1487	printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
	1488	__FUNCTION__ , process->pid , vpn );
	1489	return -1;
	1490	}
[1]	1491
[408]	1492	// compute allocated page PPN
	1493	new_ppn = ppm_page2ppn( page_xp );
[406]	1494
[408]	1495	// copy old page content to new page
	1496	xptr_t old_base_xp = ppm_ppn2base( old_ppn );
	1497	xptr_t new_base_xp = ppm_ppn2base( new_ppn );
	1498	memcpy( GET_PTR( new_base_xp ),
	1499	GET_PTR( old_base_xp ),
	1500	CONFIG_PPM_PAGE_SIZE );
	1501	}
	1502	else // no pending fork => keep the existing page, reset COW
	1503	{
	1504	new_ppn = old_ppn;
	1505	}
[1]	1506
[408]	1507	// build new_attr : reset COW and set WRITABLE,
	1508	new_attr = (old_attr \| GPT_WRITABLE) & (~GPT_COW);
[407]	1509
[408]	1510	// update GPT[vpn] for all GPT copies
	1511	// to maintain coherence of copies
	1512	vmm_update_pte( process,
	1513	vpn,
	1514	new_attr,
	1515	new_ppn );
[407]	1516
[408]	1517	// decrement fork_nr in page descriptor
	1518	hal_remote_atomic_add( XPTR( page_cxy , &page_ptr->fork_nr ) , -1 );
[407]	1519	}
[408]	1520	else /////////////// page_fault request ///////////
[407]	1521	{
[408]	1522	if( (old_attr & GPT_MAPPED) == 0 ) // true page_fault => map it
[407]	1523	{
[1]	1524
[408]	1525	excp_dmsg("\n[DBG] %s : core[%x,%d] handling page fault for vpn %x\n",
[407]	1526	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn );
[1]	1527
[408]	1528	// allocate new_ppn, depending on vseg type
[407]	1529	error = vmm_get_one_ppn( vseg , vpn , &new_ppn );
	1530	if( error )
	1531	{
	1532	printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
	1533	__FUNCTION__ , process->pid , vpn );
[408]	1534	return -1;
[407]	1535	}
	1536
[408]	1537	// define new_attr from vseg flags
[407]	1538	new_attr = GPT_MAPPED \| GPT_SMALL;
	1539	if( vseg->flags & VSEG_USER ) new_attr \|= GPT_USER;
	1540	if( vseg->flags & VSEG_WRITE ) new_attr \|= GPT_WRITABLE;
	1541	if( vseg->flags & VSEG_EXEC ) new_attr \|= GPT_EXECUTABLE;
	1542	if( vseg->flags & VSEG_CACHE ) new_attr \|= GPT_CACHABLE;
	1543
[408]	1544	// register new PTE in reference GPT
	1545	// on demand policy => no update of GPT copies
	1546	error = hal_gpt_set_pte( &vmm->gpt,
	1547	vpn,
	1548	new_attr,
	1549	new_ppn );
[407]	1550	if( error )
	1551	{
	1552	printk("\n[ERROR] in %s : cannot update GPT / process = %x / vpn = %x\n",
	1553	__FUNCTION__ , process->pid , vpn );
[408]	1554	return -1;
[407]	1555	}
	1556	}
[408]	1557	else // mapped in reference GPT => get it
[1]	1558	{
[408]	1559	new_ppn = old_ppn;
[407]	1560	new_attr = old_attr;
[1]	1561	}
[407]	1562	}
[1]	1563
[408]	1564	excp_dmsg("\n[DBG] %s : core[%x,%d] update GPT for vpn %x / ppn = %x / attr = %x\n",
[407]	1565	__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , vpn , new_ppn , new_attr );
[406]	1566
[408]	1567	// retur success
[407]	1568	*ppn = new_ppn;
	1569	*attr = new_attr;
[1]	1570	return 0;
	1571
[313]	1572	} // end vmm_get_pte()
	1573
[1]	1574	///////////////////////////////////////////////////
	1575	error_t vmm_handle_page_fault( process_t * process,
	1576	vpn_t vpn )
	1577	{
	1578	uint32_t attr; // missing page attributes
[21]	1579	ppn_t ppn; // missing page PPN
[407]	1580	error_t error;
[1]	1581
	1582	// get reference process cluster and local pointer
	1583	cxy_t ref_cxy = GET_CXY( process->ref_xp );
	1584	process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
	1585
[313]	1586	// get missing PTE attributes and PPN from reference cluster
[407]	1587	if( local_cxy != ref_cxy )
[1]	1588	{
[407]	1589	rpc_vmm_get_pte_client( ref_cxy,
	1590	ref_ptr,
	1591	vpn,
	1592	false, // page_fault
	1593	&attr,
	1594	&ppn,
	1595	&error );
	1596
	1597	// get local VMM pointer
	1598	vmm_t * vmm = &process->vmm;
	1599
	1600	// update local GPT
[408]	1601	error \|= hal_gpt_set_pte( &vmm->gpt,
	1602	vpn,
	1603	attr,
	1604	ppn );
[1]	1605	}
[407]	1606	else // local cluster is the reference cluster
[1]	1607	{
[407]	1608	error = vmm_get_pte( process,
	1609	vpn,
	1610	false, // page-fault
	1611	&attr,
	1612	&ppn );
[1]	1613	}
	1614
[388]	1615	return error;
[1]	1616
[313]	1617	} // end vmm_handle_page_fault()
	1618
[408]	1619	////////////////////////////////////////////
	1620	error_t vmm_handle_cow( process_t * process,
	1621	vpn_t vpn )
[407]	1622	{
	1623	uint32_t attr; // missing page attributes
	1624	ppn_t ppn; // missing page PPN
	1625	error_t error;
[313]	1626
[407]	1627	// get reference process cluster and local pointer
	1628	cxy_t ref_cxy = GET_CXY( process->ref_xp );
	1629	process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
	1630
	1631	// get new PTE attributes and PPN from reference cluster
	1632	if( local_cxy != ref_cxy )
	1633	{
	1634	rpc_vmm_get_pte_client( ref_cxy,
	1635	ref_ptr,
	1636	vpn,
	1637	true, // copy-on-write
	1638	&attr,
	1639	&ppn,
	1640	&error );
	1641
	1642	// get local VMM pointer
	1643	vmm_t * vmm = &process->vmm;
	1644
	1645	// update local GPT
[408]	1646	error \|= hal_gpt_set_pte( &vmm->gpt,
	1647	vpn,
	1648	attr,
	1649	ppn );
[407]	1650	}
	1651	else // local cluster is the reference cluster
	1652	{
	1653	error = vmm_get_pte( process,
	1654	vpn,
	1655	true, // copy-on-write
	1656	&attr,
	1657	&ppn );
	1658	}
	1659
	1660	return error;
	1661
[408]	1662	} // end vmm_handle_cow()
[407]	1663
[1]	1664	///////////////////////////////////////////
	1665	error_t vmm_v2p_translate( bool_t ident,
	1666	void * ptr,
	1667	paddr_t * paddr )
	1668	{
[23]	1669	process_t * process = CURRENT_THREAD->process;
[1]	1670
	1671	if( ident ) // identity mapping
	1672	{
[23]	1673	*paddr = (paddr_t)PADDR( local_cxy , (lpa_t)ptr );
[1]	1674	return 0;
	1675	}
	1676
[21]	1677	// access page table
[1]	1678	error_t error;
	1679	vpn_t vpn;
	1680	uint32_t attr;
	1681	ppn_t ppn;
	1682	uint32_t offset;
	1683
[23]	1684	vpn = (vpn_t)( (intptr_t)ptr >> CONFIG_PPM_PAGE_SHIFT );
	1685	offset = (uint32_t)( ((intptr_t)ptr) & CONFIG_PPM_PAGE_MASK );
[1]	1686
[50]	1687	if( local_cxy == GET_CXY( process->ref_xp) ) // calling process is reference process
[1]	1688	{
[407]	1689	error = vmm_get_pte( process, vpn , false , &attr , &ppn );
[1]	1690	}
[50]	1691	else // calling process is not reference process
[1]	1692	{
	1693	cxy_t ref_cxy = GET_CXY( process->ref_xp );
	1694	process_t * ref_ptr = (process_t *)GET_PTR( process->ref_xp );
[407]	1695	rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , false , &attr , &ppn , &error );
[1]	1696	}
	1697
[23]	1698	// set paddr
[1]	1699	*paddr = (((paddr_t)ppn) << CONFIG_PPM_PAGE_SHIFT) \| offset;
[21]	1700
[23]	1701	return error;
[313]	1702
[315]	1703	} // end vmm_v2p_translate()
[1]	1704
[315]	1705

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

Download in other formats: