Context Navigation

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

Last change on this file since 632 was 632, checked in by alain, 5 years ago
This version replace the RPC by direct remote memory access for physical pages allacation/release. It is commited before being tested.
File size: 81.5 KB

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

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

Download in other formats: