Context Navigation

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

Last change on this file since 620 was 619, checked in by alain, 6 years ago

1) Fix a bug in KSH : after the "load" command,

the [ksh] prompt is now printed after completion
of the loaded application.

2) Fix a bug in vmm_handle_cow() : the copy-on-write

use now a hal_remote_memcpy() to replicate the page content.

File size: 74.2 KB

Rev	Line
[1]	1	/*
[611]	2	* vmm.c - virtual memory manager related operations definition.
[1]	3	*
	4	* Authors Ghassan Almaless (2008,2009,2010,2011, 2012)
	5	* Mohamed Lamine Karaoui (2015)
[595]	6	* Alain Greiner (2016,2017,2018)
[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>
[457]	27	#include <hal_kernel_types.h>
[1]	28	#include <hal_special.h>
	29	#include <hal_gpt.h>
[409]	30	#include <hal_vmm.h>
[577]	31	#include <hal_macros.h>
[1]	32	#include <printk.h>
[23]	33	#include <memcpy.h>
[567]	34	#include <remote_rwlock.h>
	35	#include <remote_queuelock.h>
[1]	36	#include <list.h>
[408]	37	#include <xlist.h>
[1]	38	#include <bits.h>
	39	#include <process.h>
	40	#include <thread.h>
	41	#include <vseg.h>
	42	#include <cluster.h>
	43	#include <scheduler.h>
	44	#include <vfs.h>
	45	#include <mapper.h>
	46	#include <page.h>
	47	#include <kmem.h>
	48	#include <vmm.h>
[585]	49	#include <hal_exception.h>
[1]	50
	51	//////////////////////////////////////////////////////////////////////////////////
	52	// Extern global variables
	53	//////////////////////////////////////////////////////////////////////////////////
	54
[567]	55	extern process_t process_zero; // allocated in cluster.c
[1]	56
[415]	57	///////////////////////////////////////
	58	error_t vmm_init( process_t * process )
[21]	59	{
[1]	60	error_t error;
	61	vseg_t * vseg_kentry;
	62	vseg_t * vseg_args;
	63	vseg_t * vseg_envs;
	64	intptr_t base;
	65	intptr_t size;
[614]	66	uint32_t i;
[1]	67
[438]	68	#if DEBUG_VMM_INIT
[567]	69	thread_t * this = CURRENT_THREAD;
[433]	70	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	71	if( DEBUG_VMM_INIT )
[614]	72	printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
	73	__FUNCTION__ , this->process->pid, this->trdid, process->pid, local_cxy, cycle );
[433]	74	#endif
[204]	75
[1]	76	// get pointer on VMM
	77	vmm_t * vmm = &process->vmm;
	78
[407]	79	// initialize local list of vsegs
	80	vmm->vsegs_nr = 0;
[408]	81	xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
[580]	82	remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) , LOCK_VMM_VSL );
[407]	83
[567]	84	assert( ((CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE)
	85	<= CONFIG_VMM_ELF_BASE) , "UTILS zone too small\n" );
[21]	86
[567]	87	assert( (CONFIG_THREADS_MAX_PER_CLUSTER <= 32) ,
	88	"no more than 32 threads per cluster for a single process\n");
[1]	89
[567]	90	assert( ((CONFIG_VMM_STACK_SIZE * CONFIG_THREADS_MAX_PER_CLUSTER) <=
	91	(CONFIG_VMM_VSPACE_SIZE - CONFIG_VMM_STACK_BASE)) ,
	92	"STACK zone too small\n");
[1]	93
[409]	94	// register kentry vseg in VSL
[406]	95	base = CONFIG_VMM_KENTRY_BASE << CONFIG_PPM_PAGE_SHIFT;
[1]	96	size = CONFIG_VMM_KENTRY_SIZE << CONFIG_PPM_PAGE_SHIFT;
[406]	97
[407]	98	vseg_kentry = vmm_create_vseg( process,
	99	VSEG_TYPE_CODE,
	100	base,
	101	size,
	102	0, // file_offset unused
	103	0, // file_size unused
	104	XPTR_NULL, // mapper_xp unused
	105	local_cxy );
[204]	106
[415]	107	if( vseg_kentry == NULL )
	108	{
	109	printk("\n[ERROR] in %s : cannot register kentry vseg\n", __FUNCTION__ );
	110	return -1;
	111	}
[204]	112
[406]	113	vmm->kent_vpn_base = base;
[1]	114
[409]	115	// register args vseg in VSL
[406]	116	base = (CONFIG_VMM_KENTRY_BASE +
	117	CONFIG_VMM_KENTRY_SIZE ) << CONFIG_PPM_PAGE_SHIFT;
[1]	118	size = CONFIG_VMM_ARGS_SIZE << CONFIG_PPM_PAGE_SHIFT;
[406]	119
[407]	120	vseg_args = vmm_create_vseg( process,
	121	VSEG_TYPE_DATA,
	122	base,
	123	size,
	124	0, // file_offset unused
	125	0, // file_size unused
	126	XPTR_NULL, // mapper_xp unused
	127	local_cxy );
[204]	128
[415]	129	if( vseg_args == NULL )
	130	{
	131	printk("\n[ERROR] in %s : cannot register args vseg\n", __FUNCTION__ );
	132	return -1;
	133	}
[204]	134
[406]	135	vmm->args_vpn_base = base;
[1]	136
[409]	137	// register the envs vseg in VSL
[406]	138	base = (CONFIG_VMM_KENTRY_BASE +
	139	CONFIG_VMM_KENTRY_SIZE +
	140	CONFIG_VMM_ARGS_SIZE ) << CONFIG_PPM_PAGE_SHIFT;
[1]	141	size = CONFIG_VMM_ENVS_SIZE << CONFIG_PPM_PAGE_SHIFT;
[406]	142
[407]	143	vseg_envs = vmm_create_vseg( process,
	144	VSEG_TYPE_DATA,
	145	base,
	146	size,
	147	0, // file_offset unused
	148	0, // file_size unused
	149	XPTR_NULL, // mapper_xp unused
	150	local_cxy );
[204]	151
[415]	152	if( vseg_envs == NULL )
	153	{
	154	printk("\n[ERROR] in %s : cannot register envs vseg\n", __FUNCTION__ );
	155	return -1;
	156	}
[204]	157
[406]	158	vmm->envs_vpn_base = base;
[1]	159
[409]	160	// create GPT (empty)
[1]	161	error = hal_gpt_create( &vmm->gpt );
	162
[415]	163	if( error )
	164	printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
[204]	165
[585]	166	// initialize GPT lock
	167	remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
	168
	169	// architecture specic GPT initialisation
[409]	170	// (For TSAR, identity map the kentry_vseg)
	171	error = hal_vmm_init( vmm );
	172
[415]	173	if( error )
	174	printk("\n[ERROR] in %s : cannot initialize GPT\n", __FUNCTION__ );
[409]	175
[1]	176	// initialize STACK allocator
	177	vmm->stack_mgr.bitmap = 0;
	178	vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
[567]	179	busylock_init( &vmm->stack_mgr.lock , LOCK_VMM_STACK );
[1]	180
	181	// initialize MMAP allocator
[407]	182	vmm->mmap_mgr.vpn_base = CONFIG_VMM_HEAP_BASE;
	183	vmm->mmap_mgr.vpn_size = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
	184	vmm->mmap_mgr.first_free_vpn = CONFIG_VMM_HEAP_BASE;
[567]	185	busylock_init( &vmm->mmap_mgr.lock , LOCK_VMM_MMAP );
[1]	186	for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
	187
[21]	188	// initialize instrumentation counters
[409]	189	vmm->pgfault_nr = 0;
[1]	190
[124]	191	hal_fence();
[1]	192
[438]	193	#if DEBUG_VMM_INIT
[433]	194	cycle = (uint32_t)hal_get_cycles();
[438]	195	if( DEBUG_VMM_INIT )
[614]	196	printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
	197	__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy, cycle );
[433]	198	#endif
[204]	199
[415]	200	return 0;
	201
[204]	202	} // end vmm_init()
	203
[407]	204	//////////////////////////////////////
	205	void vmm_display( process_t * process,
	206	bool_t mapping )
	207	{
	208	vmm_t * vmm = &process->vmm;
	209	gpt_t * gpt = &vmm->gpt;
	210
[457]	211	printk("\n***** VSL and GPT(%x) for process %x in cluster %x\n\n",
	212	process->vmm.gpt.ptr , process->pid , local_cxy );
[407]	213
[585]	214	// get lock protecting the VSL and the GPT
[567]	215	remote_rwlock_rd_acquire( XPTR( local_cxy , &vmm->vsegs_lock ) );
[585]	216	remote_rwlock_rd_acquire( XPTR( local_cxy , &vmm->gpt_lock ) );
[407]	217
	218	// scan the list of vsegs
[408]	219	xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
	220	xptr_t iter_xp;
	221	xptr_t vseg_xp;
[407]	222	vseg_t * vseg;
[408]	223	XLIST_FOREACH( root_xp , iter_xp )
[407]	224	{
[408]	225	vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
[433]	226	vseg = GET_PTR( vseg_xp );
[408]	227
[407]	228	printk(" - %s : base = %X / size = %X / npages = %d\n",
	229	vseg_type_str( vseg->type ) , vseg->min , vseg->max - vseg->min , vseg->vpn_size );
	230
	231	if( mapping )
	232	{
	233	vpn_t vpn;
	234	ppn_t ppn;
	235	uint32_t attr;
	236	vpn_t base = vseg->vpn_base;
	237	vpn_t size = vseg->vpn_size;
	238	for( vpn = base ; vpn < (base+size) ; vpn++ )
	239	{
[585]	240	hal_gpt_get_pte( XPTR( local_cxy , gpt ) , vpn , &attr , &ppn );
[407]	241	if( attr & GPT_MAPPED )
	242	{
	243	printk(" . vpn = %X / attr = %X / ppn = %X\n", vpn , attr , ppn );
	244	}
	245	}
	246	}
	247	}
	248
[585]	249	// release the locks
[567]	250	remote_rwlock_rd_release( XPTR( local_cxy , &vmm->vsegs_lock ) );
[585]	251	remote_rwlock_rd_release( XPTR( local_cxy , &vmm->gpt_lock ) );
[407]	252
[408]	253	} // vmm_display()
	254
[611]	255	//////////////////////////////////////////
	256	void vmm_attach_vseg_to_vsl( vmm_t * vmm,
	257	vseg_t * vseg )
[567]	258	{
	259	// build extended pointer on rwlock protecting VSL
	260	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
	261
	262	// get rwlock in write mode
	263	remote_rwlock_wr_acquire( lock_xp );
	264
	265	// update vseg descriptor
	266	vseg->vmm = vmm;
	267
	268	// add vseg in vmm list
	269	xlist_add_last( XPTR( local_cxy , &vmm->vsegs_root ),
	270	XPTR( local_cxy , &vseg->xlist ) );
	271
	272	// release rwlock in write mode
	273	remote_rwlock_wr_release( lock_xp );
	274	}
	275
[611]	276	////////////////////////////////////////////
	277	void vmm_detach_vseg_from_vsl( vmm_t * vmm,
	278	vseg_t * vseg )
[567]	279	{
[611]	280	// get vseg type
	281	uint32_t type = vseg->type;
	282
[567]	283	// build extended pointer on rwlock protecting VSL
	284	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
	285
	286	// get rwlock in write mode
	287	remote_rwlock_wr_acquire( lock_xp );
	288
	289	// update vseg descriptor
	290	vseg->vmm = NULL;
	291
[611]	292	// remove vseg from VSL
[567]	293	xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
	294
	295	// release rwlock in write mode
	296	remote_rwlock_wr_release( lock_xp );
	297
[611]	298	// release the stack slot to VMM stack allocator if STACK type
	299	if( type == VSEG_TYPE_STACK )
	300	{
	301	// get pointer on stack allocator
	302	stack_mgr_t * mgr = &vmm->stack_mgr;
	303
	304	// compute slot index
	305	uint32_t index = ((vseg->vpn_base - mgr->vpn_base - 1) / CONFIG_VMM_STACK_SIZE);
	306
	307	// update stacks_bitmap
	308	busylock_acquire( &mgr->lock );
	309	bitmap_clear( &mgr->bitmap , index );
	310	busylock_release( &mgr->lock );
	311	}
	312
	313	// release the vseg to VMM mmap allocator if MMAP type
	314	if( (type == VSEG_TYPE_ANON) \|\| (type == VSEG_TYPE_FILE) \|\| (type == VSEG_TYPE_REMOTE) )
	315	{
	316	// get pointer on mmap allocator
	317	mmap_mgr_t * mgr = &vmm->mmap_mgr;
	318
	319	// compute zombi_list index
	320	uint32_t index = bits_log2( vseg->vpn_size );
	321
	322	// update zombi_list
	323	busylock_acquire( &mgr->lock );
	324	list_add_first( &mgr->zombi_list[index] , &vseg->zlist );
	325	busylock_release( &mgr->lock );
	326	}
	327
	328	// release physical memory allocated for vseg descriptor if no MMAP type
	329	if( (type != VSEG_TYPE_ANON) && (type != VSEG_TYPE_FILE) && (type != VSEG_TYPE_REMOTE) )
	330	{
	331	vseg_free( vseg );
	332	}
	333
	334	} // end vmm_remove_vseg_from_vsl()
	335
[595]	336	////////////////////////////////////////////////
[433]	337	void vmm_global_update_pte( process_t * process,
	338	vpn_t vpn,
	339	uint32_t attr,
	340	ppn_t ppn )
[23]	341	{
[408]	342	xlist_entry_t * process_root_ptr;
	343	xptr_t process_root_xp;
	344	xptr_t process_iter_xp;
[23]	345
[408]	346	xptr_t remote_process_xp;
	347	cxy_t remote_process_cxy;
	348	process_t * remote_process_ptr;
	349	xptr_t remote_gpt_xp;
[23]	350
[408]	351	pid_t pid;
	352	cxy_t owner_cxy;
	353	lpid_t owner_lpid;
[23]	354
[438]	355	#if DEBUG_VMM_UPDATE_PTE
[433]	356	uint32_t cycle = (uint32_t)hal_get_cycles();
[595]	357	thread_t * this = CURRENT_THREAD;
[438]	358	if( DEBUG_VMM_UPDATE_PTE < cycle )
[595]	359	printk("\n[%s] thread[%x,%x] enter for process %x / vpn %x / cycle %d\n",
	360	__FUNCTION__, this->process->pid, this->trdid, process->pid , vpn , cycle );
[433]	361	#endif
	362
[567]	363	// check cluster is reference
[585]	364	assert( (GET_CXY( process->ref_xp ) == local_cxy) , "not called in reference cluster\n");
[433]	365
[408]	366	// get extended pointer on root of process copies xlist in owner cluster
	367	pid = process->pid;
	368	owner_cxy = CXY_FROM_PID( pid );
	369	owner_lpid = LPID_FROM_PID( pid );
	370	process_root_ptr = &LOCAL_CLUSTER->pmgr.copies_root[owner_lpid];
	371	process_root_xp = XPTR( owner_cxy , process_root_ptr );
[23]	372
[408]	373	// loop on destination process copies
	374	XLIST_FOREACH( process_root_xp , process_iter_xp )
	375	{
	376	// get cluster and local pointer on remote process
	377	remote_process_xp = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
[433]	378	remote_process_ptr = GET_PTR( remote_process_xp );
[408]	379	remote_process_cxy = GET_CXY( remote_process_xp );
[407]	380
[438]	381	#if (DEBUG_VMM_UPDATE_PTE & 0x1)
	382	if( DEBUG_VMM_UPDATE_PTE < cycle )
[595]	383	printk("\n[%s] threadr[%x,%x] handling vpn %x for process %x in cluster %x\n",
	384	__FUNCTION__, this->process->pid, this->trdid, vpn, process->pid, remote_process_cxy );
[433]	385	#endif
	386
[408]	387	// get extended pointer on remote gpt
	388	remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
	389
[433]	390	// update remote GPT
	391	hal_gpt_update_pte( remote_gpt_xp, vpn, attr, ppn );
[408]	392	}
	393
[438]	394	#if DEBUG_VMM_UPDATE_PTE
[433]	395	cycle = (uint32_t)hal_get_cycles();
[438]	396	if( DEBUG_VMM_UPDATE_PTE < cycle )
[595]	397	printk("\n[%s] thread[%x,%x] exit for process %x / vpn %x / cycle %d\n",
	398	__FUNCTION__, this->process->pid, this->trdid, process->pid , vpn , cycle );
[433]	399	#endif
	400
	401	} // end vmm_global_update_pte()
	402
[408]	403	///////////////////////////////////////
	404	void vmm_set_cow( process_t * process )
	405	{
	406	vmm_t * vmm;
	407
	408	xlist_entry_t * process_root_ptr;
	409	xptr_t process_root_xp;
	410	xptr_t process_iter_xp;
	411
	412	xptr_t remote_process_xp;
	413	cxy_t remote_process_cxy;
	414	process_t * remote_process_ptr;
	415	xptr_t remote_gpt_xp;
	416
	417	xptr_t vseg_root_xp;
	418	xptr_t vseg_iter_xp;
	419
	420	xptr_t vseg_xp;
	421	vseg_t * vseg;
	422
	423	pid_t pid;
	424	cxy_t owner_cxy;
	425	lpid_t owner_lpid;
	426
[438]	427	#if DEBUG_VMM_SET_COW
[595]	428	uint32_t cycle = (uint32_t)hal_get_cycles();
	429	thread_t * this = CURRENT_THREAD;
[438]	430	if( DEBUG_VMM_SET_COW < cycle )
[595]	431	printk("\n[%s] thread[%x,%x] enter for process %x / cycle %d\n",
	432	__FUNCTION__, this->process->pid, this->trdid, process->pid , cycle );
[433]	433	#endif
[408]	434
[567]	435	// check cluster is reference
	436	assert( (GET_CXY( process->ref_xp ) == local_cxy) ,
	437	"local cluster is not process reference cluster\n");
[408]	438
	439	// get pointer on reference VMM
	440	vmm = &process->vmm;
	441
	442	// get extended pointer on root of process copies xlist in owner cluster
	443	pid = process->pid;
	444	owner_cxy = CXY_FROM_PID( pid );
	445	owner_lpid = LPID_FROM_PID( pid );
	446	process_root_ptr = &LOCAL_CLUSTER->pmgr.copies_root[owner_lpid];
	447	process_root_xp = XPTR( owner_cxy , process_root_ptr );
	448
	449	// get extended pointer on root of vsegs xlist from reference VMM
	450	vseg_root_xp = XPTR( local_cxy , &vmm->vsegs_root );
	451
	452	// loop on destination process copies
	453	XLIST_FOREACH( process_root_xp , process_iter_xp )
	454	{
	455	// get cluster and local pointer on remote process
	456	remote_process_xp = XLIST_ELEMENT( process_iter_xp , process_t , copies_list );
[433]	457	remote_process_ptr = GET_PTR( remote_process_xp );
[408]	458	remote_process_cxy = GET_CXY( remote_process_xp );
	459
[595]	460	#if (DEBUG_VMM_SET_COW & 1)
[438]	461	if( DEBUG_VMM_SET_COW < cycle )
[595]	462	printk("\n[%s] thread[%x,%x] handling process %x in cluster %x\n",
	463	__FUNCTION__, this->process->pid, this->trdid, process->pid , remote_process_cxy );
[433]	464	#endif
[408]	465
	466	// get extended pointer on remote gpt
	467	remote_gpt_xp = XPTR( remote_process_cxy , &remote_process_ptr->vmm.gpt );
	468
	469	// loop on vsegs in (local) reference process VSL
	470	XLIST_FOREACH( vseg_root_xp , vseg_iter_xp )
	471	{
	472	// get pointer on vseg
	473	vseg_xp = XLIST_ELEMENT( vseg_iter_xp , vseg_t , xlist );
[433]	474	vseg = GET_PTR( vseg_xp );
[408]	475
[567]	476	assert( (GET_CXY( vseg_xp ) == local_cxy) ,
	477	"all vsegs in reference VSL must be local\n" );
[408]	478
	479	// get vseg type, base and size
	480	uint32_t type = vseg->type;
	481	vpn_t vpn_base = vseg->vpn_base;
	482	vpn_t vpn_size = vseg->vpn_size;
	483
[595]	484	#if (DEBUG_VMM_SET_COW & 1)
[438]	485	if( DEBUG_VMM_SET_COW < cycle )
[595]	486	printk("\n[%s] thread[%x,%x] handling vseg %s / vpn_base = %x / vpn_size = %x\n",
	487	__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(type), vpn_base, vpn_size );
[433]	488	#endif
	489	// only DATA, ANON and REMOTE vsegs
[408]	490	if( (type == VSEG_TYPE_DATA) \|\|
	491	(type == VSEG_TYPE_ANON) \|\|
	492	(type == VSEG_TYPE_REMOTE) )
	493	{
[433]	494	vpn_t vpn;
	495	uint32_t attr;
	496	ppn_t ppn;
	497	xptr_t page_xp;
	498	cxy_t page_cxy;
	499	page_t * page_ptr;
	500	xptr_t forks_xp;
[469]	501	xptr_t lock_xp;
[433]	502
	503	// update flags in remote GPT
	504	hal_gpt_set_cow( remote_gpt_xp,
	505	vpn_base,
	506	vpn_size );
	507
	508	// atomically increment pending forks counter in physical pages,
	509	// for all vseg pages that are mapped in reference cluster
	510	if( remote_process_cxy == local_cxy )
	511	{
	512	// scan all pages in vseg
	513	for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
	514	{
	515	// get page attributes and PPN from reference GPT
[585]	516	hal_gpt_get_pte( remote_gpt_xp , vpn , &attr , &ppn );
[433]	517
	518	// atomically update pending forks counter if page is mapped
	519	if( attr & GPT_MAPPED )
	520	{
[469]	521	// get pointers and cluster on page descriptor
[433]	522	page_xp = ppm_ppn2page( ppn );
	523	page_cxy = GET_CXY( page_xp );
	524	page_ptr = GET_PTR( page_xp );
[469]	525
	526	// get extended pointers on "forks" and "lock"
[433]	527	forks_xp = XPTR( page_cxy , &page_ptr->forks );
[469]	528	lock_xp = XPTR( page_cxy , &page_ptr->lock );
	529
[567]	530	// take lock protecting "forks" counter
	531	remote_busylock_acquire( lock_xp );
	532
[469]	533	// increment "forks"
[433]	534	hal_remote_atomic_add( forks_xp , 1 );
[567]	535
	536	// release lock protecting "forks" counter
	537	remote_busylock_release( lock_xp );
[433]	538	}
	539	} // end loop on vpn
	540	} // end if local
	541	} // end if vseg type
	542	} // end loop on vsegs
[408]	543	} // end loop on process copies
	544
[438]	545	#if DEBUG_VMM_SET_COW
[433]	546	cycle = (uint32_t)hal_get_cycles();
[438]	547	if( DEBUG_VMM_SET_COW < cycle )
[595]	548	printk("\n[%s] thread[%x,%x] exit for process %x / cycle %d\n",
	549	__FUNCTION__, this->process->pid, this->trdid, process->pid , cycle );
[433]	550	#endif
[408]	551
	552	} // end vmm_set-cow()
	553
	554	/////////////////////////////////////////////////
	555	error_t vmm_fork_copy( process_t * child_process,
	556	xptr_t parent_process_xp )
	557	{
	558	error_t error;
	559	cxy_t parent_cxy;
	560	process_t * parent_process;
	561	vmm_t * parent_vmm;
	562	xptr_t parent_lock_xp;
	563	vmm_t * child_vmm;
	564	xptr_t iter_xp;
	565	xptr_t parent_vseg_xp;
	566	vseg_t * parent_vseg;
	567	vseg_t * child_vseg;
	568	uint32_t type;
	569	bool_t cow;
	570	vpn_t vpn;
	571	vpn_t vpn_base;
	572	vpn_t vpn_size;
[469]	573	xptr_t page_xp; // extended pointer on page descriptor
[408]	574	page_t * page_ptr;
	575	cxy_t page_cxy;
[469]	576	xptr_t forks_xp; // extended pointer on forks counter in page descriptor
	577	xptr_t lock_xp; // extended pointer on lock protecting the forks counter
[408]	578	xptr_t parent_root_xp;
	579	bool_t mapped;
	580	ppn_t ppn;
	581
[438]	582	#if DEBUG_VMM_FORK_COPY
[433]	583	uint32_t cycle = (uint32_t)hal_get_cycles();
[595]	584	thread_t * this = CURRENT_THREAD;
[438]	585	if( DEBUG_VMM_FORK_COPY < cycle )
[595]	586	printk("\n[%s] thread %x enter / cycle %d\n",
	587	__FUNCTION__ , this->process->pid, this->trdid, cycle );
[433]	588	#endif
[408]	589
	590	// get parent process cluster and local pointer
	591	parent_cxy = GET_CXY( parent_process_xp );
[433]	592	parent_process = GET_PTR( parent_process_xp );
[408]	593
	594	// get local pointers on parent and child VMM
	595	parent_vmm = &parent_process->vmm;
	596	child_vmm = &child_process->vmm;
	597
	598	// get extended pointer on lock protecting the parent VSL
	599	parent_lock_xp = XPTR( parent_cxy , &parent_vmm->vsegs_lock );
	600
	601	// initialize the lock protecting the child VSL
[567]	602	remote_rwlock_init( XPTR( local_cxy , &child_vmm->vsegs_lock ), LOCK_VMM_STACK );
[408]	603
	604	// initialize the child VSL as empty
	605	xlist_root_init( XPTR( local_cxy, &child_vmm->vsegs_root ) );
	606	child_vmm->vsegs_nr = 0;
	607
[415]	608	// create child GPT
[408]	609	error = hal_gpt_create( &child_vmm->gpt );
[415]	610
[407]	611	if( error )
	612	{
[408]	613	printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
	614	return -1;
[407]	615	}
	616
[408]	617	// build extended pointer on parent VSL
	618	parent_root_xp = XPTR( parent_cxy , &parent_vmm->vsegs_root );
	619
[567]	620	// take the lock protecting the parent VSL in read mode
	621	remote_rwlock_rd_acquire( parent_lock_xp );
[415]	622
[408]	623	// loop on parent VSL xlist
	624	XLIST_FOREACH( parent_root_xp , iter_xp )
[23]	625	{
[408]	626	// get local and extended pointers on current parent vseg
	627	parent_vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
[433]	628	parent_vseg = GET_PTR( parent_vseg_xp );
[23]	629
[408]	630	// get vseg type
[567]	631	type = hal_remote_l32( XPTR( parent_cxy , &parent_vseg->type ) );
[408]	632
[438]	633	#if DEBUG_VMM_FORK_COPY
[433]	634	cycle = (uint32_t)hal_get_cycles();
[438]	635	if( DEBUG_VMM_FORK_COPY < cycle )
[595]	636	printk("\n[%s] thread[%x,%x] found parent vseg %s / vpn_base = %x / cycle %d\n",
	637	__FUNCTION__ , this->process->pid, this->trdid, vseg_type_str(type),
[567]	638	hal_remote_l32( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) , cycle );
[433]	639	#endif
[23]	640
[408]	641	// all parent vsegs - but STACK - must be copied in child VSL
	642	if( type != VSEG_TYPE_STACK )
[23]	643	{
[408]	644	// allocate memory for a new child vseg
	645	child_vseg = vseg_alloc();
	646	if( child_vseg == NULL ) // release all allocated vsegs
[23]	647	{
[408]	648	vmm_destroy( child_process );
	649	printk("\n[ERROR] in %s : cannot create vseg for child\n", __FUNCTION__ );
	650	return -1;
[23]	651	}
	652
[408]	653	// copy parent vseg to child vseg
	654	vseg_init_from_ref( child_vseg , parent_vseg_xp );
[23]	655
[408]	656	// register child vseg in child VSL
[611]	657	vmm_attach_vseg_to_vsl( child_vmm , child_vseg );
[407]	658
[438]	659	#if DEBUG_VMM_FORK_COPY
[433]	660	cycle = (uint32_t)hal_get_cycles();
[438]	661	if( DEBUG_VMM_FORK_COPY < cycle )
[595]	662	printk("\n[%s] thread[%x,%x] copied vseg %s / vpn_base = %x to child VSL / cycle %d\n",
	663	__FUNCTION__ , this->process->pid, this->trdid, vseg_type_str(type),
[567]	664	hal_remote_l32( XPTR( parent_cxy , &parent_vseg->vpn_base ) ) , cycle );
[433]	665	#endif
[23]	666
[408]	667	// copy DATA, MMAP, REMOTE, FILE parent GPT entries to child GPT
	668	if( type != VSEG_TYPE_CODE )
	669	{
	670	// activate the COW for DATA, MMAP, REMOTE vsegs only
	671	cow = ( type != VSEG_TYPE_FILE );
[23]	672
[408]	673	vpn_base = child_vseg->vpn_base;
	674	vpn_size = child_vseg->vpn_size;
[23]	675
[408]	676	// scan pages in parent vseg
	677	for( vpn = vpn_base ; vpn < (vpn_base + vpn_size) ; vpn++ )
	678	{
	679	error = hal_gpt_pte_copy( &child_vmm->gpt,
	680	XPTR( parent_cxy , &parent_vmm->gpt ),
	681	vpn,
	682	cow,
	683	&ppn,
	684	&mapped );
	685	if( error )
	686	{
	687	vmm_destroy( child_process );
	688	printk("\n[ERROR] in %s : cannot copy GPT\n", __FUNCTION__ );
	689	return -1;
	690	}
	691
[433]	692	// increment pending forks counter in page if mapped
[408]	693	if( mapped )
	694	{
[469]	695	// get pointers and cluster on page descriptor
	696	page_xp = ppm_ppn2page( ppn );
[408]	697	page_cxy = GET_CXY( page_xp );
[433]	698	page_ptr = GET_PTR( page_xp );
[408]	699
[469]	700	// get extended pointers on "forks" and "lock"
	701	forks_xp = XPTR( page_cxy , &page_ptr->forks );
	702	lock_xp = XPTR( page_cxy , &page_ptr->lock );
	703
[567]	704	// get lock protecting "forks" counter
	705	remote_busylock_acquire( lock_xp );
	706
[469]	707	// increment "forks"
	708	hal_remote_atomic_add( forks_xp , 1 );
	709
[567]	710	// release lock protecting "forks" counter
	711	remote_busylock_release( lock_xp );
	712
[438]	713	#if DEBUG_VMM_FORK_COPY
[433]	714	cycle = (uint32_t)hal_get_cycles();
[438]	715	if( DEBUG_VMM_FORK_COPY < cycle )
[595]	716	printk("\n[%s] thread[%x,%x] copied vpn %x to child GPT / cycle %d\n",
	717	__FUNCTION__ , this->process->pid, this->trdid , vpn , cycle );
[433]	718	#endif
[408]	719	}
	720	}
	721	} // end if no code & no stack
	722	} // end if no stack
	723	} // end loop on vsegs
	724
[567]	725	// release the parent VSL lock in read mode
	726	remote_rwlock_rd_release( parent_lock_xp );
[408]	727
[415]	728	// initialize child GPT (architecture specic)
	729	// => For TSAR, identity map the kentry_vseg
	730	error = hal_vmm_init( child_vmm );
	731
	732	if( error )
	733	{
	734	printk("\n[ERROR] in %s : cannot create GPT\n", __FUNCTION__ );
	735	return -1;
	736	}
	737
[408]	738	// initialize the child VMM STACK allocator
	739	child_vmm->stack_mgr.bitmap = 0;
	740	child_vmm->stack_mgr.vpn_base = CONFIG_VMM_STACK_BASE;
	741
	742	// initialize the child VMM MMAP allocator
[23]	743	uint32_t i;
[408]	744	child_vmm->mmap_mgr.vpn_base = CONFIG_VMM_HEAP_BASE;
	745	child_vmm->mmap_mgr.vpn_size = CONFIG_VMM_STACK_BASE - CONFIG_VMM_HEAP_BASE;
	746	child_vmm->mmap_mgr.first_free_vpn = CONFIG_VMM_HEAP_BASE;
	747	for( i = 0 ; i < 32 ; i++ ) list_root_init( &child_vmm->mmap_mgr.zombi_list[i] );
[23]	748
[178]	749	// initialize instrumentation counters
[408]	750	child_vmm->pgfault_nr = 0;
[23]	751
[408]	752	// copy base addresses from parent VMM to child VMM
	753	child_vmm->kent_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->kent_vpn_base));
	754	child_vmm->args_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->args_vpn_base));
	755	child_vmm->envs_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->envs_vpn_base));
	756	child_vmm->heap_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->heap_vpn_base));
	757	child_vmm->code_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->code_vpn_base));
	758	child_vmm->data_vpn_base = (vpn_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->data_vpn_base));
[23]	759
[408]	760	child_vmm->entry_point = (intptr_t)hal_remote_lpt(XPTR(parent_cxy, &parent_vmm->entry_point));
[23]	761
[124]	762	hal_fence();
[23]	763
[438]	764	#if DEBUG_VMM_FORK_COPY
[433]	765	cycle = (uint32_t)hal_get_cycles();
[438]	766	if( DEBUG_VMM_FORK_COPY < cycle )
[595]	767	printk("\n[%s] thread[%x,%x] exit successfully / cycle %d\n",
	768	__FUNCTION__ , this->process->pid, this->trdid , cycle );
[433]	769	#endif
	770
[23]	771	return 0;
	772
[408]	773	} // vmm_fork_copy()
[204]	774
[1]	775	///////////////////////////////////////
	776	void vmm_destroy( process_t * process )
	777	{
[408]	778	xptr_t vseg_xp;
[1]	779	vseg_t * vseg;
	780
[438]	781	#if DEBUG_VMM_DESTROY
[433]	782	uint32_t cycle = (uint32_t)hal_get_cycles();
[595]	783	thread_t * this = CURRENT_THREAD;
[438]	784	if( DEBUG_VMM_DESTROY < cycle )
[595]	785	printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
	786	__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy, cycle );
[433]	787	#endif
[416]	788
[438]	789	#if (DEBUG_VMM_DESTROY & 1 )
[443]	790	if( DEBUG_VMM_DESTROY < cycle )
[437]	791	vmm_display( process , true );
	792	#endif
	793
[433]	794	// get pointer on local VMM
[1]	795	vmm_t * vmm = &process->vmm;
	796
[408]	797	// get extended pointer on VSL root and VSL lock
	798	xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
	799
[611]	800	// scan the VSL to delete all registered vsegs
	801	// (don't use a FOREACH for item deletion in xlist)
[619]	802
	803	uint32_t count = 0;
	804
	805	while( !xlist_is_empty( root_xp ) && (count < 10 ) )
[1]	806	{
[409]	807	// get pointer on first vseg in VSL
[567]	808	vseg_xp = XLIST_FIRST( root_xp , vseg_t , xlist );
[433]	809	vseg = GET_PTR( vseg_xp );
[409]	810
[611]	811	// delete vseg and release physical pages
	812	vmm_delete_vseg( process->pid , vseg->min );
[409]	813
[443]	814	#if( DEBUG_VMM_DESTROY & 1 )
	815	if( DEBUG_VMM_DESTROY < cycle )
[611]	816	printk("\n[%s] %s vseg deleted / vpn_base %x / vpn_size %d\n",
[443]	817	__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
	818	#endif
	819
[619]	820	count++;
	821
[1]	822	}
	823
	824	// remove all vsegs from zombi_lists in MMAP allocator
	825	uint32_t i;
	826	for( i = 0 ; i<32 ; i++ )
	827	{
	828	while( !list_is_empty( &vmm->mmap_mgr.zombi_list[i] ) )
	829	{
[408]	830	vseg = LIST_FIRST( &vmm->mmap_mgr.zombi_list[i] , vseg_t , zlist );
[443]	831
	832	#if( DEBUG_VMM_DESTROY & 1 )
	833	if( DEBUG_VMM_DESTROY < cycle )
[595]	834	printk("\n[%s] found zombi vseg / vpn_base %x / vpn_size %d\n",
[443]	835	__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
	836	#endif
[611]	837	// clean vseg descriptor
	838	vseg->vmm = NULL;
	839
	840	// remove vseg from xlist
	841	xlist_unlink( XPTR( local_cxy , &vseg->xlist ) );
	842
	843	// release vseg descriptor
[1]	844	vseg_free( vseg );
[443]	845
	846	#if( DEBUG_VMM_DESTROY & 1 )
	847	if( DEBUG_VMM_DESTROY < cycle )
[595]	848	printk("\n[%s] zombi vseg released / vpn_base %x / vpn_size %d\n",
[443]	849	__FUNCTION__ , vseg_type_str( vseg->type ), vseg->vpn_base, vseg->vpn_size );
	850	#endif
[1]	851	}
	852	}
	853
[409]	854	// release memory allocated to the GPT itself
[1]	855	hal_gpt_destroy( &vmm->gpt );
	856
[438]	857	#if DEBUG_VMM_DESTROY
[433]	858	cycle = (uint32_t)hal_get_cycles();
[438]	859	if( DEBUG_VMM_DESTROY < cycle )
[595]	860	printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
	861	__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy , cycle );
[433]	862	#endif
[416]	863
[204]	864	} // end vmm_destroy()
	865
[1]	866	/////////////////////////////////////////////////
	867	vseg_t * vmm_check_conflict( process_t * process,
[21]	868	vpn_t vpn_base,
[1]	869	vpn_t vpn_size )
	870	{
	871	vmm_t * vmm = &process->vmm;
[408]	872
	873	// scan the VSL
[1]	874	vseg_t * vseg;
[408]	875	xptr_t iter_xp;
	876	xptr_t vseg_xp;
	877	xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
[1]	878
[408]	879	XLIST_FOREACH( root_xp , iter_xp )
[1]	880	{
[408]	881	vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
[433]	882	vseg = GET_PTR( vseg_xp );
[204]	883
[21]	884	if( ((vpn_base + vpn_size) > vseg->vpn_base) &&
	885	(vpn_base < (vseg->vpn_base + vseg->vpn_size)) ) return vseg;
[1]	886	}
	887	return NULL;
	888
[204]	889	} // end vmm_check_conflict()
	890
[1]	891	////////////////////////////////////////////////////////////////////////////////////////////
	892	// This static function is called by the vmm_create_vseg() function, and implements
	893	// the VMM stack_vseg specific allocator.
	894	////////////////////////////////////////////////////////////////////////////////////////////
	895	// @ vmm : pointer on VMM.
[21]	896	// @ vpn_base : (return value) first allocated page
[1]	897	// @ vpn_size : (return value) number of allocated pages
	898	////////////////////////////////////////////////////////////////////////////////////////////
	899	static error_t vmm_stack_alloc( vmm_t * vmm,
	900	vpn_t * vpn_base,
	901	vpn_t * vpn_size )
	902	{
	903	// get stack allocator pointer
	904	stack_mgr_t * mgr = &vmm->stack_mgr;
	905
	906	// get lock on stack allocator
[567]	907	busylock_acquire( &mgr->lock );
[1]	908
	909	// get first free slot index in bitmap
	910	int32_t index = bitmap_ffc( &mgr->bitmap , 4 );
[179]	911	if( (index < 0) \|\| (index > 31) )
	912	{
[567]	913	busylock_release( &mgr->lock );
	914	return 0xFFFFFFFF;
[179]	915	}
[1]	916
	917	// update bitmap
	918	bitmap_set( &mgr->bitmap , index );
[21]	919
[1]	920	// release lock on stack allocator
[567]	921	busylock_release( &mgr->lock );
[1]	922
[21]	923	// returns vpn_base, vpn_size (one page non allocated)
[1]	924	vpn_base = mgr->vpn_base + index CONFIG_VMM_STACK_SIZE + 1;
	925	*vpn_size = CONFIG_VMM_STACK_SIZE - 1;
	926	return 0;
	927
[204]	928	} // end vmm_stack_alloc()
	929
[1]	930	////////////////////////////////////////////////////////////////////////////////////////////
	931	// This static function is called by the vmm_create_vseg() function, and implements
	932	// the VMM MMAP specific allocator.
	933	////////////////////////////////////////////////////////////////////////////////////////////
	934	// @ vmm : [in] pointer on VMM.
	935	// @ npages : [in] requested number of pages.
[21]	936	// @ vpn_base : [out] first allocated page.
[1]	937	// @ vpn_size : [out] actual number of allocated pages.
	938	////////////////////////////////////////////////////////////////////////////////////////////
	939	static error_t vmm_mmap_alloc( vmm_t * vmm,
	940	vpn_t npages,
	941	vpn_t * vpn_base,
	942	vpn_t * vpn_size )
	943	{
	944	uint32_t index;
	945	vseg_t * vseg;
	946	vpn_t base;
	947	vpn_t size;
[21]	948	vpn_t free;
[1]	949
[614]	950	#if DEBUG_VMM_MMAP_ALLOC
	951	thread_t * this = CURRENT_THREAD;
	952	uint32_t cycle = (uint32_t)hal_get_cycles();
	953	if( DEBUG_VMM_MMAP_ALLOC < cycle )
	954	printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
	955	__FUNCTION__, this->process->pid, this->trdid, cycle );
	956	#endif
	957
	958	// vseg size must be power of 2
[1]	959	// compute actual size and index in zombi_list array
	960	size = POW2_ROUNDUP( npages );
	961	index = bits_log2( size );
	962
	963	// get mmap allocator pointer
	964	mmap_mgr_t * mgr = &vmm->mmap_mgr;
	965
	966	// get lock on mmap allocator
[567]	967	busylock_acquire( &mgr->lock );
[1]	968
	969	// get vseg from zombi_list or from mmap zone
	970	if( list_is_empty( &mgr->zombi_list[index] ) ) // from mmap zone
	971	{
	972	// check overflow
	973	free = mgr->first_free_vpn;
[614]	974	if( (free + size) > mgr->vpn_size ) return -1;
[1]	975
[614]	976	// update MMAP allocator
[1]	977	mgr->first_free_vpn += size;
	978
	979	// compute base
	980	base = free;
	981	}
	982	else // from zombi_list
	983	{
	984	// get pointer on zombi vseg from zombi_list
[408]	985	vseg = LIST_FIRST( &mgr->zombi_list[index] , vseg_t , zlist );
[1]	986
	987	// remove vseg from free-list
[408]	988	list_unlink( &vseg->zlist );
[1]	989
	990	// compute base
	991	base = vseg->vpn_base;
[21]	992	}
	993
[1]	994	// release lock on mmap allocator
[567]	995	busylock_release( &mgr->lock );
[1]	996
[614]	997	#if DEBUG_VMM_MMAP_ALLOC
	998	cycle = (uint32_t)hal_get_cycles();
	999	if( DEBUG_VMM_DESTROY < cycle )
	1000	printk("\n[%s] thread[%x,%x] exit / vpn_base %x / vpn_size %x / cycle %d\n",
	1001	__FUNCTION__, this->process->pid, this->trdid, base, size, cycle );
	1002	#endif
	1003
[1]	1004	// returns vpn_base, vpn_size
	1005	*vpn_base = base;
	1006	*vpn_size = size;
	1007	return 0;
	1008
[204]	1009	} // end vmm_mmap_alloc()
	1010
[407]	1011	////////////////////////////////////////////////
	1012	vseg_t * vmm_create_vseg( process_t * process,
	1013	vseg_type_t type,
	1014	intptr_t base,
	1015	uint32_t size,
	1016	uint32_t file_offset,
	1017	uint32_t file_size,
	1018	xptr_t mapper_xp,
	1019	cxy_t cxy )
[1]	1020	{
	1021	vseg_t * vseg; // created vseg pointer
[204]	1022	vpn_t vpn_base; // first page index
[595]	1023	vpn_t vpn_size; // number of pages covered by vseg
[1]	1024	error_t error;
	1025
[438]	1026	#if DEBUG_VMM_CREATE_VSEG
[595]	1027	thread_t * this = CURRENT_THREAD;
	1028	uint32_t cycle = (uint32_t)hal_get_cycles();
[438]	1029	if( DEBUG_VMM_CREATE_VSEG < cycle )
[614]	1030	printk("\n[%s] thread[%x,%x] enter for process %x / %s / cxy %x / cycle %d\n",
	1031	__FUNCTION__, this->process->pid, this->trdid, process->pid, vseg_type_str(type), cxy, cycle );
[433]	1032	#endif
[21]	1033
[407]	1034	// get pointer on VMM
	1035	vmm_t * vmm = &process->vmm;
[21]	1036
[204]	1037	// compute base, size, vpn_base, vpn_size, depending on vseg type
[407]	1038	// we use the VMM specific allocators for "stack", "file", "anon", & "remote" vsegs
[595]	1039
[1]	1040	if( type == VSEG_TYPE_STACK )
	1041	{
	1042	// get vpn_base and vpn_size from STACK allocator
	1043	error = vmm_stack_alloc( vmm , &vpn_base , &vpn_size );
	1044	if( error )
	1045	{
[407]	1046	printk("\n[ERROR] in %s : no space for stack vseg / process %x in cluster %x\n",
	1047	__FUNCTION__ , process->pid , local_cxy );
[1]	1048	return NULL;
	1049	}
	1050
	1051	// compute vseg base and size from vpn_base and vpn_size
	1052	base = vpn_base << CONFIG_PPM_PAGE_SHIFT;
	1053	size = vpn_size << CONFIG_PPM_PAGE_SHIFT;
	1054	}
[595]	1055	else if( type == VSEG_TYPE_FILE )
	1056	{
	1057	// compute page index (in mapper) for first byte
	1058	vpn_t vpn_min = file_offset >> CONFIG_PPM_PAGE_SHIFT;
	1059
	1060	// compute page index (in mapper) for last byte
	1061	vpn_t vpn_max = (file_offset + size - 1) >> CONFIG_PPM_PAGE_SHIFT;
	1062
	1063	// compute offset in first page
	1064	uint32_t offset = file_offset & CONFIG_PPM_PAGE_MASK;
	1065
	1066	// compute number of pages required in virtual space
	1067	vpn_t npages = vpn_max - vpn_min + 1;
	1068
	1069	// get vpn_base and vpn_size from MMAP allocator
	1070	error = vmm_mmap_alloc( vmm , npages , &vpn_base , &vpn_size );
	1071	if( error )
	1072	{
	1073	printk("\n[ERROR] in %s : no vspace for mmap vseg / process %x in cluster %x\n",
	1074	__FUNCTION__ , process->pid , local_cxy );
	1075	return NULL;
	1076	}
	1077
	1078	// set the vseg base (not always aligned for FILE)
	1079	base = (vpn_base << CONFIG_PPM_PAGE_SHIFT) + offset;
	1080	}
[21]	1081	else if( (type == VSEG_TYPE_ANON) \|\|
[1]	1082	(type == VSEG_TYPE_REMOTE) )
	1083	{
[595]	1084	// compute number of required pages in virtual space
	1085	vpn_t npages = size >> CONFIG_PPM_PAGE_SHIFT;
	1086	if( size & CONFIG_PPM_PAGE_MASK) npages++;
	1087
[1]	1088	// get vpn_base and vpn_size from MMAP allocator
	1089	error = vmm_mmap_alloc( vmm , npages , &vpn_base , &vpn_size );
	1090	if( error )
	1091	{
	1092	printk("\n[ERROR] in %s : no vspace for mmap vseg / process %x in cluster %x\n",
	1093	__FUNCTION__ , process->pid , local_cxy );
	1094	return NULL;
	1095	}
	1096
[595]	1097	// set vseg base (always aligned for ANON or REMOTE)
[1]	1098	base = vpn_base << CONFIG_PPM_PAGE_SHIFT;
	1099	}
[595]	1100	else // VSEG_TYPE_DATA or VSEG_TYPE_CODE
[1]	1101	{
[204]	1102	uint32_t vpn_min = base >> CONFIG_PPM_PAGE_SHIFT;
	1103	uint32_t vpn_max = (base + size - 1) >> CONFIG_PPM_PAGE_SHIFT;
	1104
	1105	vpn_base = vpn_min;
	1106	vpn_size = vpn_max - vpn_min + 1;
[1]	1107	}
	1108
	1109	// check collisions
	1110	vseg = vmm_check_conflict( process , vpn_base , vpn_size );
	1111	if( vseg != NULL )
	1112	{
[614]	1113	printk("\n[ERROR] in %s for process %x : new vseg [vpn_base %x / vpn_size %x]\n"
	1114	" overlap existing vseg [vpn_base %x / vpn_size %x]\n",
[407]	1115	__FUNCTION__ , process->pid, vpn_base, vpn_size, vseg->vpn_base, vseg->vpn_size );
[1]	1116	return NULL;
	1117	}
	1118
	1119	// allocate physical memory for vseg descriptor
	1120	vseg = vseg_alloc();
	1121	if( vseg == NULL )
	1122	{
	1123	printk("\n[ERROR] in %s for process %x : cannot allocate memory for vseg\n",
[407]	1124	__FUNCTION__ , process->pid );
[1]	1125	return NULL;
	1126	}
	1127
[614]	1128	#if DEBUG_VMM_CREATE_VSEG
	1129	if( DEBUG_VMM_CREATE_VSEG < cycle )
	1130	printk("\n[%s] thread[%x,%x] : base %x / size %x / vpn_base %x / vpn_size %x\n",
	1131	__FUNCTION__, this->process->pid, this->trdid, base, size, vpn_base, vpn_size );
	1132	#endif
	1133
[1]	1134	// initialize vseg descriptor
[407]	1135	vseg_init( vseg,
	1136	type,
	1137	base,
	1138	size,
	1139	vpn_base,
	1140	vpn_size,
	1141	file_offset,
	1142	file_size,
	1143	mapper_xp,
	1144	cxy );
[1]	1145
[408]	1146	// attach vseg to VSL
[611]	1147	vmm_attach_vseg_to_vsl( vmm , vseg );
[1]	1148
[438]	1149	#if DEBUG_VMM_CREATE_VSEG
[433]	1150	cycle = (uint32_t)hal_get_cycles();
[438]	1151	if( DEBUG_VMM_CREATE_VSEG < cycle )
[595]	1152	printk("\n[%s] thread[%x,%x] exit / %s / cxy %x / cycle %d\n",
	1153	__FUNCTION__, this->process->pid, this->trdid, vseg_type_str(type), cxy, cycle );
[433]	1154	#endif
[21]	1155
[1]	1156	return vseg;
	1157
[406]	1158	} // vmm_create_vseg()
	1159
[611]	1160	///////////////////////////////////
	1161	void vmm_delete_vseg( pid_t pid,
	1162	intptr_t vaddr )
[1]	1163	{
[611]	1164	process_t * process; // local pointer on local process
	1165	vmm_t * vmm; // local pointer on local process VMM
	1166	vseg_t * vseg; // local pointer on local vseg containing vaddr
	1167	gpt_t * gpt; // local pointer on local process GPT
[21]	1168	vpn_t vpn; // VPN of current PTE
	1169	vpn_t vpn_min; // VPN of first PTE
[1]	1170	vpn_t vpn_max; // VPN of last PTE (excluded)
[409]	1171	ppn_t ppn; // current PTE ppn value
	1172	uint32_t attr; // current PTE attributes
	1173	kmem_req_t req; // request to release memory
	1174	xptr_t page_xp; // extended pointer on page descriptor
	1175	cxy_t page_cxy; // page descriptor cluster
	1176	page_t * page_ptr; // page descriptor pointer
[433]	1177	xptr_t forks_xp; // extended pointer on pending forks counter
[469]	1178	xptr_t lock_xp; // extended pointer on lock protecting forks counter
	1179	uint32_t forks; // actual number of pendinf forks
[1]	1180
[611]	1181	#if DEBUG_VMM_DELETE_VSEG
[595]	1182	uint32_t cycle = (uint32_t)hal_get_cycles();
	1183	thread_t * this = CURRENT_THREAD;
[611]	1184	if( DEBUG_VMM_DELETE_VSEG < cycle )
	1185	printk("\n[%s] thread[%x,%x] enter / process %x / vaddr %x / cycle %d\n",
	1186	__FUNCTION__, this->process->pid, this->trdid, pid, vaddr, cycle );
[433]	1187	#endif
[409]	1188
[611]	1189	// get local pointer on local process descriptor
	1190	process = cluster_get_local_process_from_pid( pid );
[1]	1191
[611]	1192	if( process == NULL ) return;
	1193
	1194	// get pointers on local process VMM an GPT
	1195	vmm = &process->vmm;
	1196	gpt = &process->vmm.gpt;
	1197
	1198	// get local pointer on vseg containing vaddr
	1199	vseg = vmm_vseg_from_vaddr( vmm , vaddr );
	1200
	1201	if( vseg == NULL ) return;
	1202
	1203	// loop to invalidate all vseg PTEs in GPT
[1]	1204	vpn_min = vseg->vpn_base;
	1205	vpn_max = vpn_min + vseg->vpn_size;
	1206	for( vpn = vpn_min ; vpn < vpn_max ; vpn++ )
	1207	{
[409]	1208	// get GPT entry
[585]	1209	hal_gpt_get_pte( XPTR( local_cxy , gpt ) , vpn , &attr , &ppn );
[409]	1210
	1211	if( attr & GPT_MAPPED ) // entry is mapped
	1212	{
[437]	1213
[611]	1214	#if( DEBUG_VMM_DELETE_VSEG & 1 )
	1215	if( DEBUG_VMM_DELETE_VSEG < cycle )
	1216	printk("- unmap vpn %x / ppn %x / vseg %s \n" , vpn , ppn, vseg_type_str(vseg->type) );
[437]	1217	#endif
	1218
[567]	1219	// check small page
[585]	1220	assert( (attr & GPT_SMALL) , "an user vseg must use small pages" );
[409]	1221
[585]	1222	// unmap GPT entry in local GPT
[409]	1223	hal_gpt_reset_pte( gpt , vpn );
	1224
[433]	1225	// handle pending forks counter if
	1226	// 1) not identity mapped
[567]	1227	// 2) reference cluster
[433]	1228	if( ((vseg->flags & VSEG_IDENT) == 0) &&
	1229	(GET_CXY( process->ref_xp ) == local_cxy) )
[409]	1230	{
[433]	1231	// get extended pointer on physical page descriptor
[409]	1232	page_xp = ppm_ppn2page( ppn );
	1233	page_cxy = GET_CXY( page_xp );
[433]	1234	page_ptr = GET_PTR( page_xp );
[409]	1235
[469]	1236	// get extended pointers on forks and lock fields
	1237	forks_xp = XPTR( page_cxy , &page_ptr->forks );
	1238	lock_xp = XPTR( page_cxy , &page_ptr->lock );
[433]	1239
	1240	// get pending forks counter
[567]	1241	forks = hal_remote_l32( forks_xp );
[433]	1242
[469]	1243	if( forks ) // decrement pending forks counter
[409]	1244	{
[433]	1245	hal_remote_atomic_add( forks_xp , -1 );
	1246	}
	1247	else // release physical page to relevant cluster
[409]	1248	{
[433]	1249	if( page_cxy == local_cxy ) // local cluster
	1250	{
	1251	req.type = KMEM_PAGE;
	1252	req.ptr = page_ptr;
	1253	kmem_free( &req );
	1254	}
	1255	else // remote cluster
	1256	{
	1257	rpc_pmem_release_pages_client( page_cxy , page_ptr );
	1258	}
[611]	1259
	1260	#if( DEBUG_VMM_DELETE_VSEG & 1 )
	1261	if( DEBUG_VMM_DELETE_VSEG < cycle )
	1262	printk("- release ppn %x\n", ppn );
	1263	#endif
[409]	1264	}
	1265	}
	1266	}
[1]	1267	}
[433]	1268
[611]	1269	// remove vseg from VSL and release vseg descriptor (if not MMAP)
	1270	vmm_detach_vseg_from_vsl( vmm , vseg );
	1271
	1272	#if DEBUG_VMM_DELETE_VSEG
[433]	1273	cycle = (uint32_t)hal_get_cycles();
[611]	1274	if( DEBUG_VMM_DELETE_VSEG < cycle )
[595]	1275	printk("\n[%s] thread[%x,%x] exit / process %x / vseg %s / base %x / cycle %d\n",
[611]	1276	__FUNCTION__, this->process->pid, this->trdid, pid, vseg_type_str(vseg->type), vaddr, cycle );
[433]	1277	#endif
	1278
[611]	1279	} // end vmm_delete_vseg()
[1]	1280
[611]	1281	/////////////////////////////////////////////
	1282	vseg_t * vmm_vseg_from_vaddr( vmm_t * vmm,
	1283	intptr_t vaddr )
[406]	1284	{
[408]	1285	xptr_t iter_xp;
	1286	xptr_t vseg_xp;
	1287	vseg_t * vseg;
[406]	1288
[408]	1289	// get extended pointers on VSL lock and root
	1290	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
	1291	xptr_t root_xp = XPTR( local_cxy , &vmm->vsegs_root );
[406]	1292
[408]	1293	// get lock protecting the VSL
[567]	1294	remote_rwlock_rd_acquire( lock_xp );
[408]	1295
	1296	// scan the list of vsegs in VSL
	1297	XLIST_FOREACH( root_xp , iter_xp )
[406]	1298	{
[408]	1299	vseg_xp = XLIST_ELEMENT( iter_xp , vseg_t , xlist );
[433]	1300	vseg = GET_PTR( vseg_xp );
[595]	1301
[408]	1302	if( (vaddr >= vseg->min) && (vaddr < vseg->max) )
[595]	1303	{
[408]	1304	// return success
[567]	1305	remote_rwlock_rd_release( lock_xp );
[408]	1306	return vseg;
	1307	}
[406]	1308	}
	1309
[408]	1310	// return failure
[567]	1311	remote_rwlock_rd_release( lock_xp );
[408]	1312	return NULL;
[406]	1313
[595]	1314	} // end vmm_vseg_from_vaddr()
[406]	1315
[1]	1316	/////////////////////////////////////////////
	1317	error_t vmm_resize_vseg( process_t * process,
	1318	intptr_t base,
	1319	intptr_t size )
	1320	{
[406]	1321	error_t error;
	1322	vseg_t * new;
	1323	vpn_t vpn_min;
	1324	vpn_t vpn_max;
[1]	1325
	1326	// get pointer on process VMM
	1327	vmm_t * vmm = &process->vmm;
	1328
	1329	intptr_t addr_min = base;
	1330	intptr_t addr_max = base + size;
	1331
	1332	// get pointer on vseg
[595]	1333	vseg_t * vseg = vmm_vseg_from_vaddr( vmm , base );
[1]	1334
	1335	if( vseg == NULL) return EINVAL;
[21]	1336
[408]	1337	// get extended pointer on VSL lock
	1338	xptr_t lock_xp = XPTR( local_cxy , &vmm->vsegs_lock );
[21]	1339
[408]	1340	// get lock protecting VSL
[567]	1341	remote_rwlock_wr_acquire( lock_xp );
[408]	1342
[611]	1343	if( (vseg->min > addr_min) \|\| (vseg->max < addr_max) ) // not included in vseg
[1]	1344	{
[611]	1345	error = -1;
[1]	1346	}
[611]	1347	else if( (vseg->min == addr_min) && (vseg->max == addr_max) ) // vseg must be deleted
[1]	1348	{
[611]	1349	vmm_delete_vseg( process->pid , vseg->min );
[1]	1350	error = 0;
	1351	}
[611]	1352	else if( vseg->min == addr_min ) // vseg must be resized
[1]	1353	{
[406]	1354	// update vseg base address
	1355	vseg->min = addr_max;
	1356
	1357	// update vpn_base and vpn_size
	1358	vpn_min = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
	1359	vpn_max = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
	1360	vseg->vpn_base = vpn_min;
	1361	vseg->vpn_size = vpn_max - vpn_min + 1;
	1362	error = 0;
[1]	1363	}
[611]	1364	else if( vseg->max == addr_max ) // vseg must be resized
[1]	1365	{
[406]	1366	// update vseg max address
	1367	vseg->max = addr_min;
	1368
	1369	// update vpn_base and vpn_size
	1370	vpn_min = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
	1371	vpn_max = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
	1372	vseg->vpn_base = vpn_min;
	1373	vseg->vpn_size = vpn_max - vpn_min + 1;
	1374	error = 0;
[1]	1375	}
[611]	1376	else // vseg cut in three regions
[1]	1377	{
[406]	1378	// resize existing vseg
	1379	vseg->max = addr_min;
	1380
	1381	// update vpn_base and vpn_size
	1382	vpn_min = vseg->min >> CONFIG_PPM_PAGE_SHIFT;
	1383	vpn_max = (vseg->max - 1) >> CONFIG_PPM_PAGE_SHIFT;
	1384	vseg->vpn_base = vpn_min;
	1385	vseg->vpn_size = vpn_max - vpn_min + 1;
	1386
	1387	// create new vseg
[407]	1388	new = vmm_create_vseg( process,
	1389	vseg->type,
	1390	addr_min,
	1391	(vseg->max - addr_max),
	1392	vseg->file_offset,
	1393	vseg->file_size,
	1394	vseg->mapper_xp,
	1395	vseg->cxy );
	1396
[406]	1397	if( new == NULL ) error = EINVAL;
	1398	else error = 0;
[1]	1399	}
	1400
	1401	// release VMM lock
[567]	1402	remote_rwlock_wr_release( lock_xp );
[1]	1403
	1404	return error;
	1405
[406]	1406	} // vmm_resize_vseg()
	1407
[1]	1408	///////////////////////////////////////////
[388]	1409	error_t vmm_get_vseg( process_t * process,
[394]	1410	intptr_t vaddr,
[388]	1411	vseg_t ** found_vseg )
[1]	1412	{
[595]	1413	xptr_t vseg_xp;
	1414	vseg_t * vseg;
	1415	vmm_t * vmm;
	1416	error_t error;
[1]	1417
[440]	1418	// get pointer on local VMM
	1419	vmm = &process->vmm;
[1]	1420
[440]	1421	// try to get vseg from local VMM
[595]	1422	vseg = vmm_vseg_from_vaddr( vmm , vaddr );
[440]	1423
[388]	1424	if( vseg == NULL ) // vseg not found in local cluster => try to get it from ref
	1425	{
	1426	// get extended pointer on reference process
	1427	xptr_t ref_xp = process->ref_xp;
[1]	1428
[388]	1429	// get cluster and local pointer on reference process
	1430	cxy_t ref_cxy = GET_CXY( ref_xp );
[433]	1431	process_t * ref_ptr = GET_PTR( ref_xp );
[388]	1432
	1433	if( local_cxy == ref_cxy ) return -1; // local cluster is the reference
	1434
	1435	// get extended pointer on reference vseg
[394]	1436	rpc_vmm_get_vseg_client( ref_cxy , ref_ptr , vaddr , &vseg_xp , &error );
[388]	1437
[440]	1438	if( error ) return -1; // vseg not found => illegal user vaddr
[388]	1439
	1440	// allocate a vseg in local cluster
	1441	vseg = vseg_alloc();
	1442
[440]	1443	if( vseg == NULL ) return -1; // cannot allocate a local vseg
[388]	1444
	1445	// initialise local vseg from reference
	1446	vseg_init_from_ref( vseg , vseg_xp );
	1447
[611]	1448	// register local vseg in local VSL
	1449	vmm_attach_vseg_to_vsl( vmm , vseg );
[388]	1450	}
[595]	1451
[388]	1452	// success
	1453	*found_vseg = vseg;
[394]	1454	return 0;
[388]	1455
	1456	} // end vmm_get_vseg()
	1457
[407]	1458	//////////////////////////////////////////////////////////////////////////////////////
	1459	// This static function compute the target cluster to allocate a physical page
	1460	// for a given <vpn> in a given <vseg>, allocates the page (with an RPC if required)
	1461	// and returns an extended pointer on the allocated page descriptor.
[585]	1462	// It can be called by a thread running in any cluster.
[407]	1463	// The vseg cannot have the FILE type.
	1464	//////////////////////////////////////////////////////////////////////////////////////
	1465	static xptr_t vmm_page_allocate( vseg_t * vseg,
	1466	vpn_t vpn )
	1467	{
[433]	1468
[438]	1469	#if DEBUG_VMM_ALLOCATE_PAGE
[619]	1470	uint32_t cycle = (uint32_t)hal_get_cycles();
	1471	thread_t * this = CURRENT_THREAD;
	1472	xptr_t this_xp = XPTR( local_cxy , this );
[438]	1473	if( DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
[595]	1474	printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
	1475	__FUNCTION__ , this->process->pid, this->trdid, vpn, cycle );
[433]	1476	#endif
	1477
[407]	1478	page_t * page_ptr;
	1479	cxy_t page_cxy;
	1480	kmem_req_t req;
[577]	1481	uint32_t index;
[407]	1482
[577]	1483	uint32_t type = vseg->type;
	1484	uint32_t flags = vseg->flags;
	1485	uint32_t x_size = LOCAL_CLUSTER->x_size;
	1486	uint32_t y_size = LOCAL_CLUSTER->y_size;
[407]	1487
[567]	1488	// check vseg type
	1489	assert( ( type != VSEG_TYPE_FILE ) , "illegal vseg type\n" );
[407]	1490
	1491	if( flags & VSEG_DISTRIB ) // distributed => cxy depends on vpn LSB
	1492	{
[577]	1493	index = vpn & ((x_size * y_size) - 1);
	1494	page_cxy = HAL_CXY_FROM_XY( (index / y_size) , (index % y_size) );
[561]	1495
[577]	1496	// If the cluster selected from VPN's LSBs is empty, we select one randomly
	1497	if ( cluster_is_active( page_cxy ) == false )
	1498	{
	1499	page_cxy = cluster_random_select();
[561]	1500	}
[407]	1501	}
	1502	else // other cases => cxy specified in vseg
	1503	{
[561]	1504	page_cxy = vseg->cxy;
[407]	1505	}
	1506
	1507	// allocate a physical page from target cluster
	1508	if( page_cxy == local_cxy ) // target cluster is the local cluster
	1509	{
	1510	req.type = KMEM_PAGE;
	1511	req.size = 0;
	1512	req.flags = AF_NONE;
	1513	page_ptr = (page_t *)kmem_alloc( &req );
	1514	}
	1515	else // target cluster is not the local cluster
	1516	{
	1517	rpc_pmem_get_pages_client( page_cxy , 0 , &page_ptr );
	1518	}
	1519
[438]	1520	#if DEBUG_VMM_ALLOCATE_PAGE
[595]	1521	cycle = (uint32_t)hal_get_cycles();
[438]	1522	if( DEBUG_VMM_ALLOCATE_PAGE < (uint32_t)hal_get_cycles() )
[595]	1523	printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle %d\n",
	1524	__FUNCTION__ , this->process->pid, this->trdid, vpn,
	1525	ppm_page2ppn( XPTR( page_cxy , page_ptr ) , cycle );
[433]	1526	#endif
	1527
[407]	1528	if( page_ptr == NULL ) return XPTR_NULL;
	1529	else return XPTR( page_cxy , page_ptr );
	1530
	1531	} // end vmm_page_allocate()
	1532
[313]	1533	////////////////////////////////////////
	1534	error_t vmm_get_one_ppn( vseg_t * vseg,
	1535	vpn_t vpn,
	1536	ppn_t * ppn )
	1537	{
	1538	error_t error;
[407]	1539	xptr_t page_xp; // extended pointer on physical page descriptor
[606]	1540	uint32_t page_id; // missing page index in vseg mapper
[406]	1541	uint32_t type; // vseg type;
[313]	1542
[406]	1543	type = vseg->type;
[606]	1544	page_id = vpn - vseg->vpn_base;
[313]	1545
[438]	1546	#if DEBUG_VMM_GET_ONE_PPN
[595]	1547	uint32_t cycle = (uint32_t)hal_get_cycles();
	1548	thread_t * this = CURRENT_THREAD;
	1549	if( DEBUG_VMM_GET_ONE_PPN < cycle )
[606]	1550	printk("\n[%s] thread[%x,%x] enter for vpn %x / type %s / page_id %d / cycle %d\n",
	1551	__FUNCTION__, this->process->pid, this->trdid, vpn, vseg_type_str(type), page_id, cycle );
[433]	1552	#endif
[313]	1553
[406]	1554	// FILE type : get the physical page from the file mapper
[313]	1555	if( type == VSEG_TYPE_FILE )
	1556	{
[406]	1557	// get extended pointer on mapper
[407]	1558	xptr_t mapper_xp = vseg->mapper_xp;
[313]	1559
[567]	1560	assert( (mapper_xp != XPTR_NULL),
	1561	"mapper not defined for a FILE vseg\n" );
[406]	1562
[606]	1563	// get extended pointer on page descriptor
	1564	page_xp = mapper_remote_get_page( mapper_xp , page_id );
[406]	1565
[606]	1566	if ( page_xp == XPTR_NULL ) return EINVAL;
[313]	1567	}
	1568
[406]	1569	// Other types : allocate a physical page from target cluster,
[407]	1570	// as defined by vseg type and vpn value
[313]	1571	else
	1572	{
[433]	1573	// allocate one physical page
[407]	1574	page_xp = vmm_page_allocate( vseg , vpn );
[406]	1575
[407]	1576	if( page_xp == XPTR_NULL ) return ENOMEM;
[313]	1577
[406]	1578	// initialise missing page from .elf file mapper for DATA and CODE types
[440]	1579	// the vseg->mapper_xp field is an extended pointer on the .elf file mapper
[313]	1580	if( (type == VSEG_TYPE_CODE) \|\| (type == VSEG_TYPE_DATA) )
	1581	{
[406]	1582	// get extended pointer on mapper
	1583	xptr_t mapper_xp = vseg->mapper_xp;
[313]	1584
[567]	1585	assert( (mapper_xp != XPTR_NULL),
	1586	"mapper not defined for a CODE or DATA vseg\n" );
[406]	1587
	1588	// compute missing page offset in vseg
[606]	1589	uint32_t offset = page_id << CONFIG_PPM_PAGE_SHIFT;
[406]	1590
[313]	1591	// compute missing page offset in .elf file
[406]	1592	uint32_t elf_offset = vseg->file_offset + offset;
[313]	1593
[438]	1594	#if (DEBUG_VMM_GET_ONE_PPN & 0x1)
[469]	1595	if( DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
[595]	1596	printk("\n[%s] thread[%x,%x] for vpn = %x / elf_offset = %x\n",
	1597	__FUNCTION__, this->process->pid, this->trdid, vpn, elf_offset );
[433]	1598	#endif
[406]	1599	// compute extended pointer on page base
[407]	1600	xptr_t base_xp = ppm_page2base( page_xp );
[313]	1601
[406]	1602	// file_size (in .elf mapper) can be smaller than vseg_size (BSS)
	1603	uint32_t file_size = vseg->file_size;
	1604
	1605	if( file_size < offset ) // missing page fully in BSS
[313]	1606	{
[406]	1607
[438]	1608	#if (DEBUG_VMM_GET_ONE_PPN & 0x1)
[469]	1609	if( DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
[595]	1610	printk("\n[%s] thread[%x,%x] for vpn %x / fully in BSS\n",
	1611	__FUNCTION__, this->process->pid, this->trdid, vpn );
[433]	1612	#endif
[407]	1613	if( GET_CXY( page_xp ) == local_cxy )
[313]	1614	{
[315]	1615	memset( GET_PTR( base_xp ) , 0 , CONFIG_PPM_PAGE_SIZE );
[313]	1616	}
	1617	else
	1618	{
[315]	1619	hal_remote_memset( base_xp , 0 , CONFIG_PPM_PAGE_SIZE );
[313]	1620	}
	1621	}
[406]	1622	else if( file_size >= (offset + CONFIG_PPM_PAGE_SIZE) ) // fully in mapper
[315]	1623	{
[406]	1624
[438]	1625	#if (DEBUG_VMM_GET_ONE_PPN & 0x1)
[469]	1626	if( DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
[595]	1627	printk("\n[%s] thread[%x,%x] for vpn %x / fully in mapper\n",
	1628	__FUNCTION__, this->process->pid, this->trdid, vpn );
[433]	1629	#endif
[606]	1630	error = mapper_move_kernel( mapper_xp,
	1631	true, // to_buffer
	1632	elf_offset,
	1633	base_xp,
	1634	CONFIG_PPM_PAGE_SIZE );
[313]	1635	if( error ) return EINVAL;
	1636	}
[406]	1637	else // both in mapper and in BSS :
	1638	// - (file_size - offset) bytes from mapper
	1639	// - (page_size + offset - file_size) bytes from BSS
[313]	1640	{
[406]	1641
[438]	1642	#if (DEBUG_VMM_GET_ONE_PPN & 0x1)
[469]	1643	if( DEBUG_VMM_GET_ONE_PPN < (uint32_t)hal_get_cycles() )
[610]	1644	printk("\n[%s] thread[%x,%x] for vpn %x / both mapper & BSS\n"
[433]	1645	" %d bytes from mapper / %d bytes from BSS\n",
[595]	1646	__FUNCTION__, this->process->pid, this->trdid, vpn,
[407]	1647	file_size - offset , offset + CONFIG_PPM_PAGE_SIZE - file_size );
[433]	1648	#endif
[313]	1649	// initialize mapper part
[606]	1650	error = mapper_move_kernel( mapper_xp,
	1651	true, // to buffer
	1652	elf_offset,
	1653	base_xp,
	1654	file_size - offset );
[313]	1655	if( error ) return EINVAL;
	1656
	1657	// initialize BSS part
[407]	1658	if( GET_CXY( page_xp ) == local_cxy )
[313]	1659	{
[406]	1660	memset( GET_PTR( base_xp ) + file_size - offset , 0 ,
	1661	offset + CONFIG_PPM_PAGE_SIZE - file_size );
[313]	1662	}
	1663	else
	1664	{
[406]	1665	hal_remote_memset( base_xp + file_size - offset , 0 ,
	1666	offset + CONFIG_PPM_PAGE_SIZE - file_size );
[313]	1667	}
	1668	}
	1669	} // end initialisation for CODE or DATA types
	1670	}
	1671
	1672	// return ppn
[407]	1673	*ppn = ppm_page2ppn( page_xp );
[406]	1674
[438]	1675	#if DEBUG_VMM_GET_ONE_PPN
[595]	1676	cycle = (uint32_t)hal_get_cycles();
	1677	if( DEBUG_VMM_GET_ONE_PPN < cycle )
	1678	printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle\n",
	1679	__FUNCTION__ , this->process->pid, this->trdid , vpn , *ppn, cycle );
[433]	1680	#endif
[406]	1681
[313]	1682	return 0;
	1683
	1684	} // end vmm_get_one_ppn()
	1685
[585]	1686	///////////////////////////////////////////////////
	1687	error_t vmm_handle_page_fault( process_t * process,
	1688	vpn_t vpn )
[1]	1689	{
[585]	1690	vseg_t * vseg; // vseg containing vpn
	1691	uint32_t new_attr; // new PTE_ATTR value
	1692	ppn_t new_ppn; // new PTE_PPN value
	1693	uint32_t ref_attr; // PTE_ATTR value in reference GPT
	1694	ppn_t ref_ppn; // PTE_PPN value in reference GPT
	1695	cxy_t ref_cxy; // reference cluster for missing vpn
	1696	process_t * ref_ptr; // reference process for missing vpn
	1697	xptr_t local_gpt_xp; // extended pointer on local GPT
	1698	xptr_t local_lock_xp; // extended pointer on local GPT lock
	1699	xptr_t ref_gpt_xp; // extended pointer on reference GPT
	1700	xptr_t ref_lock_xp; // extended pointer on reference GPT lock
	1701	error_t error; // value returned by called functions
[1]	1702
[585]	1703	// get local vseg (access to reference VSL can be required)
	1704	error = vmm_get_vseg( process,
	1705	(intptr_t)vpn<<CONFIG_PPM_PAGE_SHIFT,
	1706	&vseg );
	1707	if( error )
	1708	{
[595]	1709	printk("\n[ERROR] in %s : vpn %x in process %x not in a registered vseg\n",
[585]	1710	__FUNCTION__ , vpn , process->pid );
	1711
	1712	return EXCP_USER_ERROR;
	1713	}
	1714
	1715	#if DEBUG_VMM_HANDLE_PAGE_FAULT
	1716	uint32_t cycle = (uint32_t)hal_get_cycles();
[567]	1717	thread_t * this = CURRENT_THREAD;
[585]	1718	if( DEBUG_VMM_HANDLE_PAGE_FAULT < cycle )
[595]	1719	printk("\n[%s] threadr[%x,%x] enter for vpn %x / %s / cycle %d\n",
[585]	1720	__FUNCTION__, this->process->pid, this->trdid, vpn, vseg_type_str(vseg->type), cycle );
[433]	1721	#endif
[406]	1722
[585]	1723	//////////////// private vseg => access only the local GPT
	1724	if( (vseg->type == VSEG_TYPE_STACK) \|\| (vseg->type == VSEG_TYPE_CODE) )
[438]	1725	{
[585]	1726	// build extended pointer on local GPT and local GPT lock
	1727	local_gpt_xp = XPTR( local_cxy , &process->vmm.gpt );
	1728	local_lock_xp = XPTR( local_cxy , &process->vmm.gpt_lock );
[407]	1729
[585]	1730	// take local GPT lock in write mode
	1731	remote_rwlock_wr_acquire( local_lock_xp );
[407]	1732
[585]	1733	// check VPN still unmapped in local GPT
[595]	1734
[585]	1735	// do nothing if VPN has been mapped by a a concurrent page_fault
	1736	hal_gpt_get_pte( local_gpt_xp,
	1737	vpn,
	1738	&new_attr,
	1739	&new_ppn );
[407]	1740
[585]	1741	if( (new_attr & GPT_MAPPED) == 0 ) // VPN still unmapped
	1742	{
	1743	// allocate and initialise a physical page depending on the vseg type
	1744	error = vmm_get_one_ppn( vseg , vpn , &new_ppn );
[407]	1745
[585]	1746	if( error )
[408]	1747	{
	1748	printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
	1749	__FUNCTION__ , process->pid , vpn );
[1]	1750
[585]	1751	// release local GPT lock in write mode
	1752	remote_rwlock_wr_release( local_lock_xp );
[406]	1753
[585]	1754	return EXCP_KERNEL_PANIC;
[407]	1755	}
	1756
[408]	1757	// define new_attr from vseg flags
[407]	1758	new_attr = GPT_MAPPED \| GPT_SMALL;
	1759	if( vseg->flags & VSEG_USER ) new_attr \|= GPT_USER;
	1760	if( vseg->flags & VSEG_WRITE ) new_attr \|= GPT_WRITABLE;
	1761	if( vseg->flags & VSEG_EXEC ) new_attr \|= GPT_EXECUTABLE;
	1762	if( vseg->flags & VSEG_CACHE ) new_attr \|= GPT_CACHABLE;
	1763
[585]	1764	// set PTE (PPN & attribute) to local GPT
	1765	error = hal_gpt_set_pte( local_gpt_xp,
[408]	1766	vpn,
	1767	new_attr,
	1768	new_ppn );
[585]	1769	if ( error )
[407]	1770	{
[585]	1771	printk("\n[ERROR] in %s : cannot update local GPT / process %x / vpn = %x\n",
[407]	1772	__FUNCTION__ , process->pid , vpn );
[585]	1773
	1774	// release local GPT lock in write mode
	1775	remote_rwlock_wr_release( local_lock_xp );
	1776
	1777	return EXCP_KERNEL_PANIC;
[407]	1778	}
	1779	}
[585]	1780
	1781	// release local GPT lock in write mode
	1782	remote_rwlock_wr_release( local_lock_xp );
	1783
	1784	#if DEBUG_VMM_HANDLE_PAGE_FAULT
	1785	cycle = (uint32_t)hal_get_cycles();
	1786	if( DEBUG_VMM_HANDLE_PAGE_FAULT < cycle )
[595]	1787	printk("\n[%s] private page fault handled / vpn %x / ppn %x / attr %x / cycle %d\n",
[585]	1788	__FUNCTION__, vpn, new_ppn, new_attr, cycle );
	1789	#endif
	1790	return EXCP_NON_FATAL;
	1791
	1792	} // end local GPT access
	1793
	1794	//////////// public vseg => access reference GPT
	1795	else
	1796	{
	1797	// get reference process cluster and local pointer
	1798	ref_cxy = GET_CXY( process->ref_xp );
	1799	ref_ptr = GET_PTR( process->ref_xp );
	1800
	1801	// build extended pointer on reference GPT and reference GPT lock
	1802	ref_gpt_xp = XPTR( ref_cxy , &ref_ptr->vmm.gpt );
	1803	ref_lock_xp = XPTR( ref_cxy , &ref_ptr->vmm.gpt_lock );
	1804
	1805	// build extended pointer on local GPT and local GPT lock
	1806	local_gpt_xp = XPTR( local_cxy , &process->vmm.gpt );
	1807	local_lock_xp = XPTR( local_cxy , &process->vmm.gpt_lock );
	1808
	1809	// take reference GPT lock in read mode
	1810	remote_rwlock_rd_acquire( ref_lock_xp );
	1811
	1812	// get directly PPN & attributes from reference GPT
	1813	// this can avoids a costly RPC for a false page fault
	1814	hal_gpt_get_pte( ref_gpt_xp,
	1815	vpn,
	1816	&ref_attr,
	1817	&ref_ppn );
	1818
	1819	// release reference GPT lock in read mode
	1820	remote_rwlock_rd_release( ref_lock_xp );
	1821
	1822	if( ref_attr & GPT_MAPPED ) // false page fault => update local GPT
[1]	1823	{
[585]	1824	// take local GPT lock in write mode
	1825	remote_rwlock_wr_acquire( local_lock_xp );
	1826
	1827	// check VPN still unmapped in local GPT
	1828	hal_gpt_get_pte( local_gpt_xp,
	1829	vpn,
	1830	&new_attr,
	1831	&new_ppn );
[1]	1832
[585]	1833	if( (new_attr & GPT_MAPPED) == 0 ) // VPN still unmapped
	1834	{
	1835	// update local GPT from reference GPT
	1836	error = hal_gpt_set_pte( local_gpt_xp,
	1837	vpn,
	1838	ref_attr,
	1839	ref_ppn );
	1840	if( error )
	1841	{
[595]	1842	printk("\n[ERROR] in %s : cannot update local GPT / process %x / vpn %x\n",
[585]	1843	__FUNCTION__ , process->pid , vpn );
	1844
	1845	// release local GPT lock in write mode
	1846	remote_rwlock_wr_release( local_lock_xp );
	1847
	1848	return EXCP_KERNEL_PANIC;
	1849	}
	1850	}
	1851	else // VPN has been mapped by a a concurrent page_fault
	1852	{
	1853	// keep PTE from local GPT
	1854	ref_attr = new_attr;
	1855	ref_ppn = new_ppn;
	1856	}
	1857
	1858	// release local GPT lock in write mode
	1859	remote_rwlock_wr_release( local_lock_xp );
	1860
	1861	#if DEBUG_VMM_HANDLE_PAGE_FAULT
[433]	1862	cycle = (uint32_t)hal_get_cycles();
[585]	1863	if( DEBUG_VMM_HANDLE_PAGE_FAULT < cycle )
[595]	1864	printk("\n[%s] false page fault handled / vpn %x / ppn %x / attr %x / cycle %d\n",
[585]	1865	__FUNCTION__, vpn, ref_ppn, ref_attr, cycle );
[433]	1866	#endif
[585]	1867	return EXCP_NON_FATAL;
	1868	}
	1869	else // true page fault => update reference GPT
	1870	{
	1871	// take reference GPT lock in write mode
	1872	remote_rwlock_wr_acquire( ref_lock_xp );
	1873
	1874	// check VPN still unmapped in reference GPT
	1875	// do nothing if VPN has been mapped by a a concurrent page_fault
	1876	hal_gpt_get_pte( ref_gpt_xp,
	1877	vpn,
	1878	&ref_attr,
	1879	&ref_ppn );
[406]	1880
[585]	1881	if( (ref_attr & GPT_MAPPED) == 0 ) // VPN actually unmapped
	1882	{
	1883	// allocate and initialise a physical page depending on the vseg type
	1884	error = vmm_get_one_ppn( vseg , vpn , &new_ppn );
[1]	1885
[585]	1886	if( error )
	1887	{
	1888	printk("\n[ERROR] in %s : no memory / process = %x / vpn = %x\n",
	1889	__FUNCTION__ , process->pid , vpn );
[313]	1890
[585]	1891	// release reference GPT lock in write mode
	1892	remote_rwlock_wr_release( ref_lock_xp );
	1893
	1894	return EXCP_KERNEL_PANIC;
	1895	}
[1]	1896
[585]	1897	// define new_attr from vseg flags
	1898	new_attr = GPT_MAPPED \| GPT_SMALL;
	1899	if( vseg->flags & VSEG_USER ) new_attr \|= GPT_USER;
	1900	if( vseg->flags & VSEG_WRITE ) new_attr \|= GPT_WRITABLE;
	1901	if( vseg->flags & VSEG_EXEC ) new_attr \|= GPT_EXECUTABLE;
	1902	if( vseg->flags & VSEG_CACHE ) new_attr \|= GPT_CACHABLE;
[440]	1903
[585]	1904	// update reference GPT
	1905	error = hal_gpt_set_pte( ref_gpt_xp,
	1906	vpn,
	1907	new_attr,
	1908	new_ppn );
	1909
	1910	// update local GPT (protected by reference GPT lock)
	1911	error \|= hal_gpt_set_pte( local_gpt_xp,
	1912	vpn,
	1913	new_attr,
	1914	new_ppn );
	1915
	1916	if( error )
	1917	{
	1918	printk("\n[ERROR] in %s : cannot update GPT / process %x / vpn = %x\n",
	1919	__FUNCTION__ , process->pid , vpn );
	1920
	1921	// release reference GPT lock in write mode
	1922	remote_rwlock_wr_release( ref_lock_xp );
	1923
	1924	return EXCP_KERNEL_PANIC;
	1925	}
	1926	}
	1927
	1928	// release reference GPT lock in write mode
	1929	remote_rwlock_wr_release( ref_lock_xp );
	1930
[440]	1931	#if DEBUG_VMM_HANDLE_PAGE_FAULT
[585]	1932	cycle = (uint32_t)hal_get_cycles();
[469]	1933	if( DEBUG_VMM_HANDLE_PAGE_FAULT < cycle )
[595]	1934	printk("\n[%s] true page fault handled / vpn %x / ppn %x / attr %x / cycle %d\n",
[585]	1935	__FUNCTION__, vpn, new_ppn, new_attr, cycle );
[435]	1936	#endif
[585]	1937	return EXCP_NON_FATAL;
	1938	}
	1939	}
	1940	} // end vmm_handle_page_fault()
[435]	1941
[585]	1942	////////////////////////////////////////////
	1943	error_t vmm_handle_cow( process_t * process,
	1944	vpn_t vpn )
	1945	{
	1946	vseg_t * vseg; // vseg containing vpn
	1947	cxy_t ref_cxy; // reference cluster for missing vpn
	1948	process_t * ref_ptr; // reference process for missing vpn
	1949	xptr_t gpt_xp; // extended pointer on GPT
	1950	xptr_t gpt_lock_xp; // extended pointer on GPT lock
	1951	uint32_t old_attr; // current PTE_ATTR value
	1952	ppn_t old_ppn; // current PTE_PPN value
	1953	uint32_t new_attr; // new PTE_ATTR value
	1954	ppn_t new_ppn; // new PTE_PPN value
	1955	error_t error;
[1]	1956
[585]	1957	#if DEBUG_VMM_HANDLE_COW
[619]	1958	uint32_t cycle = (uint32_t)hal_get_cycles();
	1959	thread_t * this = CURRENT_THREAD;
	1960	xptr_t this_xp = XPTR( local_cxy , this );
[585]	1961	if( DEBUG_VMM_HANDLE_COW < cycle )
[595]	1962	printk("\n[%s] thread[%x,%x] enter for vpn %x / core[%x,%d] / cycle %d\n",
[619]	1963	__FUNCTION__, this->process->pid, this->trdid, vpn, local_cxy, this->core->lid, cycle );
[585]	1964	#endif
	1965
[610]	1966	// access local GPT to get GPT_COW flag
	1967	bool_t cow = hal_gpt_pte_is_cow( &(process->vmm.gpt), vpn );
	1968
	1969	if( cow == false ) return EXCP_USER_ERROR;
	1970
[585]	1971	// get local vseg
	1972	error = vmm_get_vseg( process,
	1973	(intptr_t)vpn<<CONFIG_PPM_PAGE_SHIFT,
	1974	&vseg );
[440]	1975	if( error )
[1]	1976	{
[595]	1977	printk("\n[PANIC] in %s : vpn %x in process %x not in a registered vseg\n",
[585]	1978	__FUNCTION__, vpn, process->pid );
	1979
	1980	return EXCP_KERNEL_PANIC;
[440]	1981	}
[407]	1982
[619]	1983	#if( DEBUG_VMM_HANDLE_COW & 1)
	1984	if( DEBUG_VMM_HANDLE_COW < cycle )
	1985	printk("\n[%s] thread[%x,%x] get vseg for vpn %x\n",
	1986	__FUNCTION__, this->process->pid, this->trdid, vpn );
	1987	#endif
	1988
[585]	1989	// get reference GPT cluster and local pointer
	1990	ref_cxy = GET_CXY( process->ref_xp );
	1991	ref_ptr = GET_PTR( process->ref_xp );
[407]	1992
[610]	1993	// build relevant extended pointers on relevant GPT and GPT lock
[585]	1994	// - access local GPT for a private vseg
	1995	// - access reference GPT for a public vseg
	1996	if( (vseg->type == VSEG_TYPE_STACK) \|\| (vseg->type == VSEG_TYPE_CODE) )
[440]	1997	{
[585]	1998	gpt_xp = XPTR( local_cxy , &process->vmm.gpt );
	1999	gpt_lock_xp = XPTR( local_cxy , &process->vmm.gpt_lock );
[1]	2000	}
[440]	2001	else
[1]	2002	{
[585]	2003	gpt_xp = XPTR( ref_cxy , &ref_ptr->vmm.gpt );
	2004	gpt_lock_xp = XPTR( ref_cxy , &ref_ptr->vmm.gpt_lock );
[1]	2005	}
	2006
[585]	2007	// take GPT lock in write mode
	2008	remote_rwlock_wr_acquire( gpt_lock_xp );
[441]	2009
[585]	2010	// get current PTE from reference GPT
	2011	hal_gpt_get_pte( gpt_xp,
	2012	vpn,
	2013	&old_attr,
	2014	&old_ppn );
[441]	2015
[619]	2016	#if( DEBUG_VMM_HANDLE_COW & 1)
	2017	if( DEBUG_VMM_HANDLE_COW < cycle )
	2018	printk("\n[%s] thread[%x,%x] get pte for vpn %x : ppn %x / attr %x\n",
	2019	__FUNCTION__, this->process->pid, this->trdid, vpn, old_ppn, old_attr );
	2020	#endif
	2021
[585]	2022	// the PTE must be mapped for a COW
	2023	if( (old_attr & GPT_MAPPED) == 0 )
	2024	{
	2025	printk("\n[PANIC] in %s : VPN %x in process %x unmapped\n",
	2026	__FUNCTION__, vpn, process->pid );
[407]	2027
[585]	2028	// release GPT lock in write mode
[619]	2029	remote_rwlock_wr_release( gpt_lock_xp );
[407]	2030
[585]	2031	return EXCP_KERNEL_PANIC;
[407]	2032	}
	2033
[619]	2034	// get pointers on physical page descriptor
[585]	2035	xptr_t page_xp = ppm_ppn2page( old_ppn );
	2036	cxy_t page_cxy = GET_CXY( page_xp );
	2037	page_t * page_ptr = GET_PTR( page_xp );
[435]	2038
[585]	2039	// get extended pointers on forks and lock field in page descriptor
	2040	xptr_t forks_xp = XPTR( page_cxy , &page_ptr->forks );
	2041	xptr_t forks_lock_xp = XPTR( page_cxy , &page_ptr->lock );
[407]	2042
[585]	2043	// take lock protecting "forks" counter
	2044	remote_busylock_acquire( forks_lock_xp );
[407]	2045
[585]	2046	// get number of pending forks from page descriptor
	2047	uint32_t forks = hal_remote_l32( forks_xp );
[441]	2048
[619]	2049	#if( DEBUG_VMM_HANDLE_COW & 1)
	2050	if( DEBUG_VMM_HANDLE_COW < cycle )
	2051	printk("\n[%s] thread[%x,%x] get forks = %d for vpn %x\n",
	2052	__FUNCTION__, this->process->pid, this->trdid, forks, vpn );
	2053	#endif
	2054
[585]	2055	if( forks ) // pending fork => allocate a new page, and copy old to new
	2056	{
[619]	2057	// decrement pending forks counter in page descriptor
	2058	hal_remote_atomic_add( forks_xp , -1 );
	2059
	2060	// release lock protecting "forks" counter
	2061	remote_busylock_release( forks_lock_xp );
	2062
	2063	// allocate a new page
[585]	2064	page_xp = vmm_page_allocate( vseg , vpn );
[619]	2065
[585]	2066	if( page_xp == XPTR_NULL )
	2067	{
	2068	printk("\n[PANIC] in %s : no memory for vpn %x in process %x\n",
	2069	__FUNCTION__ , vpn, process->pid );
[441]	2070
[585]	2071	// release GPT lock in write mode
	2072	remote_rwlock_wr_acquire( gpt_lock_xp );
[441]	2073
[585]	2074	return EXCP_KERNEL_PANIC;
	2075	}
[441]	2076
[585]	2077	// compute allocated page PPN
	2078	new_ppn = ppm_page2ppn( page_xp );
[441]	2079
[619]	2080	#if( DEBUG_VMM_HANDLE_COW & 1)
	2081	if( DEBUG_VMM_HANDLE_COW < cycle )
	2082	printk("\n[%s] thread[%x,%x] get new ppn %x for vpn %x\n",
	2083	__FUNCTION__, this->process->pid, this->trdid, new_ppn, vpn );
	2084	#endif
	2085
[585]	2086	// copy old page content to new page
[619]	2087	hal_remote_memcpy( ppm_ppn2base( new_ppn ),
	2088	ppm_ppn2base( old_ppn ),
	2089	CONFIG_PPM_PAGE_SIZE );
[441]	2090
[585]	2091	#if(DEBUG_VMM_HANDLE_COW & 1)
	2092	if( DEBUG_VMM_HANDLE_COW < cycle )
[619]	2093	printk("\n[%s] thread[%x,%x] copied old page to new page\n",
	2094	__FUNCTION__, this->process->pid, this->trdid );
[585]	2095	#endif
[440]	2096
[585]	2097	}
	2098	else // no pending fork => keep the existing page
	2099	{
[619]	2100	// release lock protecting "forks" counter
	2101	remote_busylock_release( forks_lock_xp );
[1]	2102
[585]	2103	#if(DEBUG_VMM_HANDLE_COW & 1)
	2104	if( DEBUG_VMM_HANDLE_COW < cycle )
[619]	2105	printk("\n[%s] thread[%x,%x] no pending forks / keep existing PPN %x\n",
	2106	__FUNCTION__, this->process->pid, this->trdid, old_ppn );
[585]	2107	#endif
	2108	new_ppn = old_ppn;
	2109	}
[1]	2110
[585]	2111	// build new_attr : reset COW and set WRITABLE,
	2112	new_attr = (old_attr \| GPT_WRITABLE) & (~GPT_COW);
	2113
[619]	2114	// update the relevant GPT
[585]	2115	// - private vseg => update local GPT
	2116	// - public vseg => update all GPT copies
	2117	if( (vseg->type == VSEG_TYPE_STACK) \|\| (vseg->type == VSEG_TYPE_CODE) )
[1]	2118	{
[585]	2119	hal_gpt_set_pte( gpt_xp,
	2120	vpn,
	2121	new_attr,
	2122	new_ppn );
[1]	2123	}
[585]	2124	else
[1]	2125	{
[585]	2126	if( ref_cxy == local_cxy ) // reference cluster is local
	2127	{
	2128	vmm_global_update_pte( process,
	2129	vpn,
	2130	new_attr,
	2131	new_ppn );
	2132	}
	2133	else // reference cluster is remote
	2134	{
	2135	rpc_vmm_global_update_pte_client( ref_cxy,
	2136	ref_ptr,
	2137	vpn,
	2138	new_attr,
	2139	new_ppn );
	2140	}
[1]	2141	}
	2142
[585]	2143	// release GPT lock in write mode
	2144	remote_rwlock_wr_release( gpt_lock_xp );
[21]	2145
[585]	2146	#if DEBUG_VMM_HANDLE_COW
	2147	cycle = (uint32_t)hal_get_cycles();
	2148	if( DEBUG_VMM_HANDLE_COW < cycle )
[595]	2149	printk("\n[%s] thread[%x,%x] exit for vpn %x / core[%x,%d] / cycle %d\n",
[619]	2150	__FUNCTION__, this->process->pid, this->trdid, vpn, local_cxy, this->core->lid, cycle );
[585]	2151	#endif
[313]	2152
[585]	2153	return EXCP_NON_FATAL;
[1]	2154
[585]	2155	} // end vmm_handle_cow()
	2156

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

Download in other formats: