Context Navigation

source: trunk/kernel/kern/process.c @ 625

Last change on this file since 625 was 625, checked in by alain, 5 years ago
Fix a bug in the vmm_remove_vseg() function: the physical pages associated to an user DATA vseg were released to the kernel when the target process descriptor was in the reference cluster. This physical pages release should be done only when the page forks counter value is zero. All other modifications are cosmetic.
File size: 83.7 KB

Line
1	/*
2	* process.c - process related functions 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_remote.h>
29	#include <hal_uspace.h>
30	#include <hal_irqmask.h>
31	#include <hal_vmm.h>
32	#include <errno.h>
33	#include <printk.h>
34	#include <memcpy.h>
35	#include <bits.h>
36	#include <kmem.h>
37	#include <page.h>
38	#include <vmm.h>
39	#include <vfs.h>
40	#include <core.h>
41	#include <thread.h>
42	#include <chdev.h>
43	#include <list.h>
44	#include <string.h>
45	#include <scheduler.h>
46	#include <busylock.h>
47	#include <queuelock.h>
48	#include <remote_queuelock.h>
49	#include <rwlock.h>
50	#include <remote_rwlock.h>
51	#include <dqdt.h>
52	#include <cluster.h>
53	#include <ppm.h>
54	#include <boot_info.h>
55	#include <process.h>
56	#include <elf.h>
57	#include <syscalls.h>
58	#include <shared_syscalls.h>
59
60	//////////////////////////////////////////////////////////////////////////////////////////
61	// Extern global variables
62	//////////////////////////////////////////////////////////////////////////////////////////
63
64	extern process_t process_zero; // allocated in kernel_init.c
65	extern chdev_directory_t chdev_dir; // allocated in kernel_init.c
66
67	//////////////////////////////////////////////////////////////////////////////////////////
68	// Process initialisation related functions
69	//////////////////////////////////////////////////////////////////////////////////////////
70
71	/////////////////////////////////
72	process_t * process_alloc( void )
73	{
74	kmem_req_t req;
75
76	req.type = KMEM_PROCESS;
77	req.size = sizeof(process_t);
78	req.flags = AF_KERNEL;
79
80	return (process_t *)kmem_alloc( &req );
81	}
82
83	////////////////////////////////////////
84	void process_free( process_t * process )
85	{
86	kmem_req_t req;
87
88	req.type = KMEM_PROCESS;
89	req.ptr = process;
90	kmem_free( &req );
91	}
92
93	////////////////////////////////////////////////////
94	error_t process_reference_init( process_t * process,
95	pid_t pid,
96	xptr_t parent_xp )
97	{
98	error_t error;
99	xptr_t process_xp;
100	cxy_t parent_cxy;
101	process_t * parent_ptr;
102	xptr_t stdin_xp;
103	xptr_t stdout_xp;
104	xptr_t stderr_xp;
105	uint32_t stdin_id;
106	uint32_t stdout_id;
107	uint32_t stderr_id;
108	uint32_t txt_id;
109	char rx_path[40];
110	char tx_path[40];
111	xptr_t file_xp;
112	xptr_t chdev_xp;
113	chdev_t * chdev_ptr;
114	cxy_t chdev_cxy;
115	pid_t parent_pid;
116	vmm_t * vmm;
117
118	// build extended pointer on this reference process
119	process_xp = XPTR( local_cxy , process );
120
121	// get pointer on process vmm
122	vmm = &process->vmm;
123
124	// get parent process cluster and local pointer
125	parent_cxy = GET_CXY( parent_xp );
126	parent_ptr = GET_PTR( parent_xp );
127
128	// get parent_pid
129	parent_pid = hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid ) );
130
131	#if DEBUG_PROCESS_REFERENCE_INIT
132	thread_t * this = CURRENT_THREAD;
133	uint32_t cycle = (uint32_t)hal_get_cycles();
134	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
135	printk("\n[%s] thread[%x,%x] enter to initialize process %x / cycle %d\n",
136	__FUNCTION__, this->process->pid, this->trdid, pid, cycle );
137	#endif
138
139	// initialize pid, ref_xp, parent_xp, owner_xp, term_state fields
140	process->pid = pid;
141	process->ref_xp = XPTR( local_cxy , process );
142	process->owner_xp = XPTR( local_cxy , process );
143	process->parent_xp = parent_xp;
144	process->term_state = 0;
145
146	// initialize VFS root inode and CWD inode
147	process->vfs_root_xp = hal_remote_l64( XPTR( parent_cxy, &parent_ptr->vfs_root_xp ) );
148	process->cwd_xp = hal_remote_l64( XPTR( parent_cxy, &parent_ptr->cwd_xp ) );
149
150	// initialize VSL as empty
151	vmm->vsegs_nr = 0;
152	xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
153
154	// create an empty GPT as required by the architecture
155	error = hal_gpt_create( &vmm->gpt );
156	if( error )
157	{
158	printk("\n[ERROR] in %s : cannot create empty GPT\n", __FUNCTION__ );
159	return -1;
160	}
161
162	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
163	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
164	printk("\n[%s] thread[%x,%x] created empty GPT for process %x\n",
165	__FUNCTION__, parent_pid, this->trdid, pid );
166	#endif
167
168	// initialize GPT and VSL locks
169	remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
170	remote_rwlock_init( XPTR( local_cxy , &vmm->vsl_lock ) , LOCK_VMM_VSL );
171
172	// register kernel vsegs in VMM as required by the architecture
173	error = hal_vmm_kernel_update( process );
174	if( error )
175	{
176	printk("\n[ERROR] in %s : cannot register kernel vsegs in VMM\n", __FUNCTION__ );
177	return -1;
178	}
179
180	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
181	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
182	printk("\n[%s] thread[%x,%x] registered kernel vsegs for process %x\n",
183	__FUNCTION__, parent_pid, this->trdid, pid );
184	#endif
185
186	// create "args" and "envs" vsegs
187	// create "stacks" and "mmap" vsegs allocators
188	// initialize locks protecting GPT and VSL
189	error = vmm_user_init( process );
190	if( error )
191	{
192	printk("\n[ERROR] in %s : cannot register user vsegs in VMM\n", __FUNCTION__ );
193	return -1;
194	}
195
196	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
197	cycle = (uint32_t)hal_get_cycles();
198	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
199	printk("\n[%s] thread[%x,%x] initialized vmm for process %x\n",
200	__FUNCTION__, parent_pid, this->trdid, pid );
201	#endif
202
203	// initialize fd_array as empty
204	process_fd_init( process );
205
206	// define the stdin/stdout/stderr pseudo files <=> select a TXT terminal.
207	if( (pid == 1) \|\| (parent_pid == 1) ) // INIT or KSH process
208	{
209	// select a TXT channel
210	if( pid == 1 ) txt_id = 0; // INIT
211	else txt_id = process_txt_alloc(); // KSH
212
213	// attach process to TXT
214	process_txt_attach( process , txt_id );
215
216	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
217	cycle = (uint32_t)hal_get_cycles();
218	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
219	printk("\n[%s] thread[%x,%x] / process %x attached to TXT%d / cycle %d\n",
220	__FUNCTION__, parent_pid, this->trdid, pid, txt_id, cycle );
221	#endif
222	// build path to TXT_RX[i] and TXT_TX[i] chdevs
223	snprintf( rx_path , 40 , "/dev/external/txt%d_rx", txt_id );
224	snprintf( tx_path , 40 , "/dev/external/txt%d_tx", txt_id );
225
226	// create stdin pseudo file
227	error = vfs_open( process->vfs_root_xp,
228	rx_path,
229	process_xp,
230	O_RDONLY,
231	0, // FIXME chmod
232	&stdin_xp,
233	&stdin_id );
234	if( error )
235	{
236	printk("\n[ERROR] in %s : cannot open stdout pseudo-file\n", __FUNCTION__ );
237	return -1;
238	}
239
240	assert( (stdin_id == 0) , "stdin index must be 0" );
241
242	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
243	cycle = (uint32_t)hal_get_cycles();
244	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
245	printk("\n[%s] thread[%x,%x] / stdin open for process %x / cycle %d\n",
246	__FUNCTION__, parent_pid, this->trdid, pid, cycle );
247	#endif
248
249	// create stdout pseudo file
250	error = vfs_open( process->vfs_root_xp,
251	tx_path,
252	process_xp,
253	O_WRONLY,
254	0, // FIXME chmod
255	&stdout_xp,
256	&stdout_id );
257	if( error )
258	{
259	printk("\n[ERROR] in %s : cannot open stdout pseudo-file\n", __FUNCTION__ );
260	return -1;
261	}
262
263	assert( (stdout_id == 1) , "stdout index must be 1" );
264
265	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
266	cycle = (uint32_t)hal_get_cycles();
267	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
268	printk("\n[%s] thread[%x,%x] / stdout open for process %x / cycle %d\n",
269	__FUNCTION__, parent_pid, this->trdid, pid, cycle );
270	#endif
271
272	// create stderr pseudo file
273	error = vfs_open( process->vfs_root_xp,
274	tx_path,
275	process_xp,
276	O_WRONLY,
277	0, // FIXME chmod
278	&stderr_xp,
279	&stderr_id );
280	if( error )
281	{
282	printk("\n[ERROR] in %s : cannot open stderr pseudo-file\n", __FUNCTION__ );
283	return -1;
284	}
285
286	assert( (stderr_id == 2) , "stderr index must be 2" );
287
288	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
289	cycle = (uint32_t)hal_get_cycles();
290	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
291	printk("\n[%s] thread[%x,%x] / stderr open for process %x / cycle %d\n",
292	__FUNCTION__, parent_pid, this->trdid, pid, cycle );
293	#endif
294
295	}
296	else // normal user process
297	{
298	// get extended pointer on stdin pseudo file in parent process
299	file_xp = (xptr_t)hal_remote_l64( XPTR( parent_cxy,
300	&parent_ptr->fd_array.array[0] ) );
301
302	// get extended pointer on parent process TXT chdev
303	chdev_xp = chdev_from_file( file_xp );
304
305	// get cluster and local pointer on chdev
306	chdev_cxy = GET_CXY( chdev_xp );
307	chdev_ptr = GET_PTR( chdev_xp );
308
309	// get parent process TXT terminal index
310	txt_id = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
311
312	// attach child process to parent process TXT terminal
313	process_txt_attach( process , txt_id );
314
315	// copy all open files from parent process fd_array to this process
316	process_fd_remote_copy( XPTR( local_cxy , &process->fd_array ),
317	XPTR( parent_cxy , &parent_ptr->fd_array ) );
318	}
319
320	// initialize lock protecting CWD changes
321	remote_busylock_init( XPTR( local_cxy ,
322	&process->cwd_lock ), LOCK_PROCESS_CWD );
323
324	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
325	cycle = (uint32_t)hal_get_cycles();
326	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
327	printk("\n[%s] thread[%x,%x] / set fd_array for process %x / cycle %d\n",
328	__FUNCTION__, parent_pid, this->trdid, pid , cycle );
329	#endif
330
331	// reset children list root
332	xlist_root_init( XPTR( local_cxy , &process->children_root ) );
333	process->children_nr = 0;
334	remote_queuelock_init( XPTR( local_cxy,
335	&process->children_lock ), LOCK_PROCESS_CHILDREN );
336
337	// reset semaphore / mutex / barrier / condvar list roots and lock
338	xlist_root_init( XPTR( local_cxy , &process->sem_root ) );
339	xlist_root_init( XPTR( local_cxy , &process->mutex_root ) );
340	xlist_root_init( XPTR( local_cxy , &process->barrier_root ) );
341	xlist_root_init( XPTR( local_cxy , &process->condvar_root ) );
342	remote_queuelock_init( XPTR( local_cxy ,
343	&process->sync_lock ), LOCK_PROCESS_USERSYNC );
344
345	// reset open directories root and lock
346	xlist_root_init( XPTR( local_cxy , &process->dir_root ) );
347	remote_queuelock_init( XPTR( local_cxy ,
348	&process->dir_lock ), LOCK_PROCESS_DIR );
349
350	// register new process in the local cluster manager pref_tbl[]
351	lpid_t lpid = LPID_FROM_PID( pid );
352	LOCAL_CLUSTER->pmgr.pref_tbl[lpid] = XPTR( local_cxy , process );
353
354	// register new process descriptor in local cluster manager local_list
355	cluster_process_local_link( process );
356
357	// register new process descriptor in local cluster manager copies_list
358	cluster_process_copies_link( process );
359
360	// initialize th_tbl[] array and associated threads
361	uint32_t i;
362
363	for( i = 0 ; i < CONFIG_THREADS_MAX_PER_CLUSTER ; i++ )
364	{
365	process->th_tbl[i] = NULL;
366	}
367	process->th_nr = 0;
368	rwlock_init( &process->th_lock , LOCK_PROCESS_THTBL );
369
370	hal_fence();
371
372	#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
373	cycle = (uint32_t)hal_get_cycles();
374	if( DEBUG_PROCESS_REFERENCE_INIT < cycle )
375	printk("\n[%s] thread[%x,%x] exit for process %x / cycle %d\n",
376	__FUNCTION__, parent_pid, this->trdid, pid, cycle );
377	#endif
378
379	return 0;
380
381	} // process_reference_init()
382
383	/////////////////////////////////////////////////////
384	error_t process_copy_init( process_t * local_process,
385	xptr_t reference_process_xp )
386	{
387	error_t error;
388	vmm_t * vmm;
389
390	// get reference process cluster and local pointer
391	cxy_t ref_cxy = GET_CXY( reference_process_xp );
392	process_t * ref_ptr = GET_PTR( reference_process_xp );
393
394	// get pointer on process vmm
395	vmm = &local_process->vmm;
396
397	// initialize PID, REF_XP, PARENT_XP, and STATE
398	local_process->pid = hal_remote_l32( XPTR( ref_cxy , &ref_ptr->pid ) );
399	local_process->parent_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->parent_xp ) );
400	local_process->ref_xp = reference_process_xp;
401	local_process->owner_xp = reference_process_xp;
402	local_process->term_state = 0;
403
404	#if DEBUG_PROCESS_COPY_INIT
405	thread_t * this = CURRENT_THREAD;
406	uint32_t cycle = (uint32_t)hal_get_cycles();
407	if( DEBUG_PROCESS_COPY_INIT < cycle )
408	printk("\n[%s] thread[%x,%x] enter for process %x / cycle %d\n",
409	__FUNCTION__, this->process->pid, this->trdid, local_process->pid, cycle );
410	#endif
411
412	// check user process
413	assert( (local_process->pid != 0), "LPID cannot be 0" );
414
415	// initialize VSL as empty
416	vmm->vsegs_nr = 0;
417	xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
418
419	// create an empty GPT as required by the architecture
420	error = hal_gpt_create( &vmm->gpt );
421	if( error )
422	{
423	printk("\n[ERROR] in %s : cannot create empty GPT\n", __FUNCTION__ );
424	return -1;
425	}
426
427	// initialize GPT and VSL locks
428	remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
429	remote_rwlock_init( XPTR( local_cxy , &vmm->vsl_lock ) , LOCK_VMM_VSL );
430
431	// register kernel vsegs in VMM as required by the architecture
432	error = hal_vmm_kernel_update( local_process );
433	if( error )
434	{
435	printk("\n[ERROR] in %s : cannot register kernel vsegs in VMM\n", __FUNCTION__ );
436	return -1;
437	}
438
439	// create "args" and "envs" vsegs
440	// create "stacks" and "mmap" vsegs allocators
441	// initialize locks protecting GPT and VSL
442	error = vmm_user_init( local_process );
443	if( error )
444	{
445	printk("\n[ERROR] in %s : cannot register user vsegs in VMM\n", __FUNCTION__ );
446	return -1;
447	}
448
449	#if (DEBUG_PROCESS_COPY_INIT & 1)
450	cycle = (uint32_t)hal_get_cycles();
451	if( DEBUG_PROCESS_COPY_INIT < cycle )
452	printk("\n[%s] thread[%x,%x] initialized vmm for process %x / cycle %d\n",
453	__FUNCTION__, parent_pid, this->trdid, pid, cycle );
454	#endif
455
456	// set process file descriptors array
457	process_fd_init( local_process );
458
459	// set vfs_root_xp / vfs_bin_xp / cwd_xp fields
460	local_process->vfs_root_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->vfs_root_xp ) );
461	local_process->vfs_bin_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->vfs_bin_xp ) );
462	local_process->cwd_xp = XPTR_NULL;
463
464	// reset children list root (not used in a process descriptor copy)
465	xlist_root_init( XPTR( local_cxy , &local_process->children_root ) );
466	local_process->children_nr = 0;
467	remote_queuelock_init( XPTR( local_cxy , &local_process->children_lock ),
468	LOCK_PROCESS_CHILDREN );
469
470	// reset children_list (not used in a process descriptor copy)
471	xlist_entry_init( XPTR( local_cxy , &local_process->children_list ) );
472
473	// reset semaphores list root (not used in a process descriptor copy)
474	xlist_root_init( XPTR( local_cxy , &local_process->sem_root ) );
475	xlist_root_init( XPTR( local_cxy , &local_process->mutex_root ) );
476	xlist_root_init( XPTR( local_cxy , &local_process->barrier_root ) );
477	xlist_root_init( XPTR( local_cxy , &local_process->condvar_root ) );
478
479	// initialize th_tbl[] array and associated fields
480	uint32_t i;
481	for( i = 0 ; i < CONFIG_THREADS_MAX_PER_CLUSTER ; i++ )
482	{
483	local_process->th_tbl[i] = NULL;
484	}
485	local_process->th_nr = 0;
486	rwlock_init( &local_process->th_lock , LOCK_PROCESS_THTBL );
487
488	// register new process descriptor in local cluster manager local_list
489	cluster_process_local_link( local_process );
490
491	// register new process descriptor in owner cluster manager copies_list
492	cluster_process_copies_link( local_process );
493
494	hal_fence();
495
496	#if DEBUG_PROCESS_COPY_INIT
497	cycle = (uint32_t)hal_get_cycles();
498	if( DEBUG_PROCESS_COPY_INIT < cycle )
499	printk("\n[%s] thread[%x,%x] exit for process %x / cycle %d\n",
500	__FUNCTION__, this->process->pid, this->trdid, local_process->pid, cycle );
501	#endif
502
503	return 0;
504
505	} // end process_copy_init()
506
507	///////////////////////////////////////////
508	void process_destroy( process_t * process )
509	{
510	xptr_t parent_xp;
511	process_t * parent_ptr;
512	cxy_t parent_cxy;
513	xptr_t children_lock_xp;
514	xptr_t children_nr_xp;
515
516	pid_t pid = process->pid;
517
518	// check no more threads
519	assert( (process->th_nr == 0),
520	"process %x in cluster %x contains threads", pid , local_cxy );
521
522	#if DEBUG_PROCESS_DESTROY
523	thread_t * this = CURRENT_THREAD;
524	uint32_t cycle = (uint32_t)hal_get_cycles();
525	if( DEBUG_PROCESS_DESTROY < cycle )
526	printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
527	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy, cycle );
528	#endif
529
530	// Destroy VMM
531	vmm_destroy( process );
532
533	#if (DEBUG_PROCESS_DESTROY & 1)
534	if( DEBUG_PROCESS_DESTROY < cycle )
535	printk("\n[%s] thread[%x,%x] destroyed VMM for process %x in cluster %x\n",
536	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy );
537	#endif
538
539	// remove process from local_list in local cluster manager
540	cluster_process_local_unlink( process );
541
542	#if (DEBUG_PROCESS_DESTROY & 1)
543	if( DEBUG_PROCESS_DESTROY < cycle )
544	printk("\n[%s] thread[%x,%x] removed process %x in cluster %x from local list\n",
545	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy );
546	#endif
547
548	// remove process from copies_list in owner cluster manager
549	cluster_process_copies_unlink( process );
550
551	#if (DEBUG_PROCESS_DESTROY & 1)
552	if( DEBUG_PROCESS_DESTROY < cycle )
553	printk("\n[%s] thread[%x,%x] removed process %x in cluster %x from copies list\n",
554	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy );
555	#endif
556
557	// when target process cluster is the owner cluster
558	// - remove process from TXT list and transfer ownership
559	// - remove process from children_list
560	// - release PID
561	if( CXY_FROM_PID( pid ) == local_cxy )
562	{
563	process_txt_detach( XPTR( local_cxy , process ) );
564
565	#if (DEBUG_PROCESS_DESTROY & 1)
566	if( DEBUG_PROCESS_DESTROY < cycle )
567	printk("\n[%s] thread[%x,%x] removed process %x from TXT list\n",
568	__FUNCTION__, this->process->pid, this->trdid, pid );
569	#endif
570
571	// get pointers on parent process
572	parent_xp = process->parent_xp;
573	parent_cxy = GET_CXY( parent_xp );
574	parent_ptr = GET_PTR( parent_xp );
575
576	// get extended pointer on children_lock in parent process
577	children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
578	children_nr_xp = XPTR( parent_cxy , &parent_ptr->children_nr );
579
580	// remove process from children_list
581	remote_queuelock_acquire( children_lock_xp );
582	xlist_unlink( XPTR( local_cxy , &process->children_list ) );
583	hal_remote_atomic_add( children_nr_xp , -1 );
584	remote_queuelock_release( children_lock_xp );
585
586	#if (DEBUG_PROCESS_DESTROY & 1)
587	if( DEBUG_PROCESS_DESTROY < cycle )
588	printk("\n[%s] thread[%x,%x] removed process %x from parent process children list\n",
589	__FUNCTION__, this->process->pid, this->trdid, pid );
590	#endif
591
592	// release the process PID to cluster manager
593	cluster_pid_release( pid );
594
595	#if (DEBUG_PROCESS_DESTROY & 1)
596	if( DEBUG_PROCESS_DESTROY < cycle )
597	printk("\n[%s] thread[%x,%x] released process PID %x to pmgr in cluster %x\n",
598	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy );
599	#endif
600
601	}
602
603	// FIXME decrement the refcount on file pointer for vfs_bin_xp [AG]
604
605	// FIXME close all open files [AG]
606
607	// FIXME synchronize dirty files [AG]
608
609	// release memory allocated to process descriptor
610	process_free( process );
611
612	#if DEBUG_PROCESS_DESTROY
613	cycle = (uint32_t)hal_get_cycles();
614	if( DEBUG_PROCESS_DESTROY < cycle )
615	printk("\n[%s] thread[%x,%x] exit / process %x in cluster %x / cycle %d\n",
616	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy, cycle );
617	#endif
618
619	} // end process_destroy()
620
621	///////////////////////////////////////////////////////////////////
622	const char * process_action_str( process_sigactions_t action_type )
623	{
624	switch ( action_type )
625	{
626	case BLOCK_ALL_THREADS: return "BLOCK";
627	case UNBLOCK_ALL_THREADS: return "UNBLOCK";
628	case DELETE_ALL_THREADS: return "DELETE";
629	default: return "undefined";
630	}
631	}
632
633	////////////////////////////////////////
634	void process_sigaction( pid_t pid,
635	uint32_t type )
636	{
637	cxy_t owner_cxy; // owner cluster identifier
638	lpid_t lpid; // process index in owner cluster
639	cluster_t * cluster; // pointer on cluster manager
640	xptr_t root_xp; // extended pointer on root of copies
641	xptr_t lock_xp; // extended pointer on lock protecting copies
642	xptr_t iter_xp; // iterator on copies list
643	xptr_t process_xp; // extended pointer on process copy
644	cxy_t process_cxy; // process copy cluster identifier
645	process_t * process_ptr; // local pointer on process copy
646	reg_t save_sr; // for critical section
647	thread_t * client; // pointer on client thread
648	xptr_t client_xp; // extended pointer on client thread
649	process_t * local; // pointer on process copy in local cluster
650	uint32_t remote_nr; // number of remote process copies
651	rpc_desc_t rpc; // shared RPC descriptor
652	uint32_t responses; // shared RPC responses counter
653
654	client = CURRENT_THREAD;
655	client_xp = XPTR( local_cxy , client );
656	local = NULL;
657	remote_nr = 0;
658
659	// check calling thread can yield
660	thread_assert_can_yield( client , __FUNCTION__ );
661
662	#if DEBUG_PROCESS_SIGACTION
663	uint32_t cycle = (uint32_t)hal_get_cycles();
664	if( DEBUG_PROCESS_SIGACTION < cycle )
665	printk("\n[%s] thread[%x,%x] enter to %s process %x / cycle %d\n",
666	__FUNCTION__ , client->process->pid, client->trdid,
667	process_action_str( type ) , pid , cycle );
668	#endif
669
670	// get pointer on local cluster manager
671	cluster = LOCAL_CLUSTER;
672
673	// get owner cluster identifier and process lpid
674	owner_cxy = CXY_FROM_PID( pid );
675	lpid = LPID_FROM_PID( pid );
676
677	// get root of list of copies and lock from owner cluster
678	root_xp = XPTR( owner_cxy , &cluster->pmgr.copies_root[lpid] );
679	lock_xp = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] );
680
681	// check action type
682	assert( ((type == DELETE_ALL_THREADS ) \|\|
683	(type == BLOCK_ALL_THREADS ) \|\|
684	(type == UNBLOCK_ALL_THREADS )), "illegal action type" );
685
686	// This client thread send parallel RPCs to all remote clusters containing
687	// target process copies, wait all responses, and then handles directly
688	// the threads in local cluster, when required.
689	// The client thread allocates a - shared - RPC descriptor in the stack,
690	// because all parallel, non-blocking, server threads use the same input
691	// arguments, and use the shared RPC response field
692
693	// mask IRQs
694	hal_disable_irq( &save_sr);
695
696	// client thread blocks itself
697	thread_block( client_xp , THREAD_BLOCKED_RPC );
698
699	// initialize RPC responses counter
700	responses = 0;
701
702	// initialize shared RPC descriptor
703	// can be shared, because no out arguments
704	rpc.rsp = &responses;
705	rpc.blocking = false;
706	rpc.index = RPC_PROCESS_SIGACTION;
707	rpc.thread = client;
708	rpc.lid = client->core->lid;
709	rpc.args[0] = pid;
710	rpc.args[1] = type;
711
712	// take the lock protecting process copies
713	remote_queuelock_acquire( lock_xp );
714
715	// scan list of process copies
716	XLIST_FOREACH( root_xp , iter_xp )
717	{
718	// get extended pointers and cluster on process
719	process_xp = XLIST_ELEMENT( iter_xp , process_t , copies_list );
720	process_cxy = GET_CXY( process_xp );
721	process_ptr = GET_PTR( process_xp );
722
723	if( process_cxy == local_cxy ) // process copy is local
724	{
725	local = process_ptr;
726	}
727	else // process copy is remote
728	{
729	// update number of remote process copies
730	remote_nr++;
731
732	// atomically increment RPC responses counter
733	hal_atomic_add( &responses , 1 );
734
735	#if DEBUG_PROCESS_SIGACTION
736	if( DEBUG_PROCESS_SIGACTION < cycle )
737	printk("\n[%s] thread[%x,%x] send RPC to cluster %x for process %x\n",
738	__FUNCTION__, client->process->pid, client->trdid, process_cxy, pid );
739	#endif
740	// call RPC in target cluster
741	rpc_send( process_cxy , &rpc );
742	}
743	} // end list of copies
744
745	// release the lock protecting process copies
746	remote_queuelock_release( lock_xp );
747
748	// restore IRQs
749	hal_restore_irq( save_sr);
750
751	// - if there is remote process copies, the client thread deschedules,
752	// (it will be unblocked by the last RPC server thread).
753	// - if there is no remote copies, the client thread unblock itself.
754	if( remote_nr )
755	{
756	sched_yield("blocked on rpc_process_sigaction");
757	}
758	else
759	{
760	thread_unblock( client_xp , THREAD_BLOCKED_RPC );
761	}
762
763	// handle the local process copy if required
764	if( local != NULL )
765	{
766
767	#if DEBUG_PROCESS_SIGACTION
768	if( DEBUG_PROCESS_SIGACTION < cycle )
769	printk("\n[%s] thread[%x,%x] handles local process %x in cluster %x\n",
770	__FUNCTION__, client->process->pid, client->trdid, pid , local_cxy );
771	#endif
772	if (type == DELETE_ALL_THREADS ) process_delete_threads ( local , client_xp );
773	else if(type == BLOCK_ALL_THREADS ) process_block_threads ( local );
774	else if(type == UNBLOCK_ALL_THREADS ) process_unblock_threads( local );
775	}
776
777	#if DEBUG_PROCESS_SIGACTION
778	cycle = (uint32_t)hal_get_cycles();
779	if( DEBUG_PROCESS_SIGACTION < cycle )
780	printk("\n[%s] thread[%x,%x] exit after %s process %x / cycle %d\n",
781	__FUNCTION__, client->process->pid, client->trdid,
782	process_action_str( type ), pid, cycle );
783	#endif
784
785	} // end process_sigaction()
786
787	/////////////////////////////////////////////////
788	void process_block_threads( process_t * process )
789	{
790	thread_t * target; // pointer on target thread
791	thread_t * this; // pointer on calling thread
792	uint32_t ltid; // index in process th_tbl[]
793	cxy_t owner_cxy; // target process owner cluster
794	uint32_t count; // requests counter
795	volatile uint32_t ack_count; // acknowledges counter
796
797	// get calling thread pointer
798	this = CURRENT_THREAD;
799
800	#if DEBUG_PROCESS_SIGACTION
801	pid_t pid = process->pid;
802	uint32_t cycle = (uint32_t)hal_get_cycles();
803	if( DEBUG_PROCESS_SIGACTION < cycle )
804	printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
805	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy , cycle );
806	#endif
807
808	// check target process is an user process
809	assert( (LPID_FROM_PID( process->pid ) != 0 ),
810	"process %x is not an user process\n", process->pid );
811
812	// get target process owner cluster
813	owner_cxy = CXY_FROM_PID( process->pid );
814
815	// get lock protecting process th_tbl[]
816	rwlock_rd_acquire( &process->th_lock );
817
818	// loop on target process local threads
819	// we use both "ltid" and "count" because it can exist "holes" in th_tbl
820	// - if the calling thread and the target thread are not running on the same
821	// core, we ask the target scheduler to acknowlege the blocking
822	// to be sure that the target thread is not running.
823	// - if the calling thread and the target thread are running on the same core,
824	// we don't need confirmation from scheduler.
825
826	for( ltid = 0 , count = 0 , ack_count = 0 ; count < process->th_nr ; ltid++ )
827	{
828	target = process->th_tbl[ltid];
829
830	if( target != NULL ) // thread exist
831	{
832	count++;
833
834	// set the global blocked bit in target thread descriptor.
835	thread_block( XPTR( local_cxy , target ) , THREAD_BLOCKED_GLOBAL );
836
837	if( this->core->lid != target->core->lid )
838	{
839	// increment responses counter
840	hal_atomic_add( (void*)&ack_count , 1 );
841
842	// set FLAG_REQ_ACK and &ack_rsp_count in target descriptor
843	thread_set_req_ack( target , (uint32_t *)&ack_count );
844
845	// force scheduling on target thread
846	dev_pic_send_ipi( local_cxy , target->core->lid );
847	}
848	}
849	}
850
851	// release lock protecting process th_tbl[]
852	rwlock_rd_release( &process->th_lock );
853
854	// wait other threads acknowledges TODO this could be improved...
855	while( 1 )
856	{
857	// exit when all scheduler acknowledges received
858	if ( ack_count == 0 ) break;
859
860	// wait 1000 cycles before retry
861	hal_fixed_delay( 1000 );
862	}
863
864	#if DEBUG_PROCESS_SIGACTION
865	cycle = (uint32_t)hal_get_cycles();
866	if( DEBUG_PROCESS_SIGACTION < cycle )
867	printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
868	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy , cycle );
869	#endif
870
871	} // end process_block_threads()
872
873	/////////////////////////////////////////////////
874	void process_delete_threads( process_t * process,
875	xptr_t client_xp )
876	{
877	thread_t * this; // pointer on calling thread
878	thread_t * target; // local pointer on target thread
879	xptr_t target_xp; // extended pointer on target thread
880	cxy_t owner_cxy; // owner process cluster
881	uint32_t ltid; // index in process th_tbl
882	uint32_t count; // threads counter
883
884	// get calling thread pointer
885	this = CURRENT_THREAD;
886
887	// get target process owner cluster
888	owner_cxy = CXY_FROM_PID( process->pid );
889
890	#if DEBUG_PROCESS_SIGACTION
891	uint32_t cycle = (uint32_t)hal_get_cycles();
892	if( DEBUG_PROCESS_SIGACTION < cycle )
893	printk("\n[%s] thread[%x,%x] enter for process %x n cluster %x / cycle %d\n",
894	__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy, cycle );
895	#endif
896
897	// check target process is an user process
898	assert( (LPID_FROM_PID( process->pid ) != 0),
899	"process %x is not an user process\n", process->pid );
900
901	// get lock protecting process th_tbl[]
902	rwlock_wr_acquire( &process->th_lock );
903
904	// loop on target process local threads
905	// we use both "ltid" and "count" because it can exist "holes" in th_tbl
906	for( ltid = 0 , count = 0 ; count < process->th_nr ; ltid++ )
907	{
908	target = process->th_tbl[ltid];
909
910	if( target != NULL ) // valid thread
911	{
912	count++;
913	target_xp = XPTR( local_cxy , target );
914
915	// main thread and client thread should not be deleted
916	if( ((ltid != 0) \|\| (owner_cxy != local_cxy)) && // not main thread
917	(client_xp) != target_xp ) // not client thread
918	{
919	// mark target thread for delete and block it
920	thread_delete( target_xp , process->pid , false ); // not forced
921	}
922	}
923	}
924
925	// release lock protecting process th_tbl[]
926	rwlock_wr_release( &process->th_lock );
927
928	#if DEBUG_PROCESS_SIGACTION
929	cycle = (uint32_t)hal_get_cycles();
930	if( DEBUG_PROCESS_SIGACTION < cycle )
931	printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
932	__FUNCTION__, this->process->pid, this->trdid, process->pid, local_cxy , cycle );
933	#endif
934
935	} // end process_delete_threads()
936
937	///////////////////////////////////////////////////
938	void process_unblock_threads( process_t * process )
939	{
940	thread_t * target; // pointer on target thead
941	thread_t * this; // pointer on calling thread
942	uint32_t ltid; // index in process th_tbl
943	uint32_t count; // requests counter
944
945	// get calling thread pointer
946	this = CURRENT_THREAD;
947
948	#if DEBUG_PROCESS_SIGACTION
949	pid_t pid = process->pid;
950	uint32_t cycle = (uint32_t)hal_get_cycles();
951	if( DEBUG_PROCESS_SIGACTION < cycle )
952	printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
953	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy , cycle );
954	#endif
955
956	// check target process is an user process
957	assert( ( LPID_FROM_PID( process->pid ) != 0 ),
958	"process %x is not an user process\n", process->pid );
959
960	// get lock protecting process th_tbl[]
961	rwlock_rd_acquire( &process->th_lock );
962
963	// loop on process threads to unblock all threads
964	// we use both "ltid" and "count" because it can exist "holes" in th_tbl
965	for( ltid = 0 , count = 0 ; count < process->th_nr ; ltid++ )
966	{
967	target = process->th_tbl[ltid];
968
969	if( target != NULL ) // thread found
970	{
971	count++;
972
973	// reset the global blocked bit in target thread descriptor.
974	thread_unblock( XPTR( local_cxy , target ) , THREAD_BLOCKED_GLOBAL );
975	}
976	}
977
978	// release lock protecting process th_tbl[]
979	rwlock_rd_release( &process->th_lock );
980
981	#if DEBUG_PROCESS_SIGACTION
982	cycle = (uint32_t)hal_get_cycles();
983	if( DEBUG_PROCESS_SIGACTION < cycle )
984	printk("\n[%s] thread[%x,%x] exit for process %x in cluster %x / cycle %d\n",
985	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy, cycle );
986	#endif
987
988	} // end process_unblock_threads()
989
990	///////////////////////////////////////////////
991	process_t * process_get_local_copy( pid_t pid )
992	{
993	error_t error;
994	process_t * process_ptr; // local pointer on process
995	xptr_t process_xp; // extended pointer on process
996
997	cluster_t * cluster = LOCAL_CLUSTER;
998
999	#if DEBUG_PROCESS_GET_LOCAL_COPY
1000	thread_t * this = CURRENT_THREAD;
1001	uint32_t cycle = (uint32_t)hal_get_cycles();
1002	if( DEBUG_PROCESS_GET_LOCAL_COPY < cycle )
1003	printk("\n[%s] thread[%x,%x] enter for process %x in cluster %x / cycle %d\n",
1004	__FUNCTION__, this->process->pid, this->trdid, pid, local_cxy, cycle );
1005	#endif
1006
1007	// get lock protecting local list of processes
1008	remote_queuelock_acquire( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
1009
1010	// scan the local list of process descriptors to find the process
1011	xptr_t iter;
1012	bool_t found = false;
1013	XLIST_FOREACH( XPTR( local_cxy , &cluster->pmgr.local_root ) , iter )
1014	{
1015	process_xp = XLIST_ELEMENT( iter , process_t , local_list );
1016	process_ptr = GET_PTR( process_xp );
1017	if( process_ptr->pid == pid )
1018	{
1019	found = true;
1020	break;
1021	}
1022	}
1023
1024	// release lock protecting local list of processes
1025	remote_queuelock_release( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
1026
1027	// allocate memory for a new local process descriptor
1028	// and initialise it from reference cluster if not found
1029	if( !found )
1030	{
1031	// get extended pointer on reference process descriptor
1032	xptr_t ref_xp = cluster_get_reference_process_from_pid( pid );
1033
1034	assert( (ref_xp != XPTR_NULL) , "illegal pid\n" );
1035
1036	// allocate memory for local process descriptor
1037	process_ptr = process_alloc();
1038
1039	if( process_ptr == NULL ) return NULL;
1040
1041	// initialize local process descriptor copy
1042	error = process_copy_init( process_ptr , ref_xp );
1043
1044	if( error ) return NULL;
1045	}
1046
1047	#if DEBUG_PROCESS_GET_LOCAL_COPY
1048	cycle = (uint32_t)hal_get_cycles();
1049	if( DEBUG_PROCESS_GET_LOCAL_COPY < cycle )
1050	printk("\n[%s] thread[%x,%x] exit in cluster %x / process %x / cycle %d\n",
1051	__FUNCTION__, this->process->pid, this->trdid, local_cxy, process_ptr, cycle );
1052	#endif
1053
1054	return process_ptr;
1055
1056	} // end process_get_local_copy()
1057
1058	////////////////////////////////////////////
1059	pid_t process_get_ppid( xptr_t process_xp )
1060	{
1061	cxy_t process_cxy;
1062	process_t * process_ptr;
1063	xptr_t parent_xp;
1064	cxy_t parent_cxy;
1065	process_t * parent_ptr;
1066
1067	// get process cluster and local pointer
1068	process_cxy = GET_CXY( process_xp );
1069	process_ptr = GET_PTR( process_xp );
1070
1071	// get pointers on parent process
1072	parent_xp = (xptr_t)hal_remote_l64( XPTR( process_cxy , &process_ptr->parent_xp ) );
1073	parent_cxy = GET_CXY( parent_xp );
1074	parent_ptr = GET_PTR( parent_xp );
1075
1076	return hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid ) );
1077	}
1078
1079	//////////////////////////////////////////////////////////////////////////////////////////
1080	// File descriptor array related functions
1081	//////////////////////////////////////////////////////////////////////////////////////////
1082
1083	///////////////////////////////////////////
1084	void process_fd_init( process_t * process )
1085	{
1086	uint32_t fd;
1087
1088	// initialize lock
1089	remote_queuelock_init( XPTR( local_cxy , &process->fd_array.lock ), LOCK_PROCESS_FDARRAY );
1090
1091	// initialize number of open files
1092	process->fd_array.current = 0;
1093
1094	// initialize array
1095	for ( fd = 0 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
1096	{
1097	process->fd_array.array[fd] = XPTR_NULL;
1098	}
1099	}
1100	////////////////////////////////////////////////////
1101	error_t process_fd_register( xptr_t process_xp,
1102	xptr_t file_xp,
1103	uint32_t * fdid )
1104	{
1105	bool_t found;
1106	uint32_t id;
1107	xptr_t xp;
1108
1109	// get reference process cluster and local pointer
1110	process_t * process_ptr = GET_PTR( process_xp );
1111	cxy_t process_cxy = GET_CXY( process_xp );
1112
1113	// check client process is reference process
1114	assert( (process_xp == hal_remote_l64( XPTR( process_cxy , &process_ptr->ref_xp ) ) ),
1115	"client process must be reference process\n" );
1116
1117	#if DEBUG_PROCESS_FD_REGISTER
1118	thread_t * this = CURRENT_THREAD;
1119	uint32_t cycle = (uint32_t)hal_get_cycles();
1120	pid_t pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid) );
1121	if( DEBUG_PROCESS_FD_REGISTER < cycle )
1122	printk("\n[%s] thread[%x,%x] enter for process %x / cycle %d\n",
1123	__FUNCTION__, this->process->pid, this->trdid, pid, cycle );
1124	#endif
1125
1126	// build extended pointer on lock protecting reference fd_array
1127	xptr_t lock_xp = XPTR( process_cxy , &process_ptr->fd_array.lock );
1128
1129	// take lock protecting reference fd_array
1130	remote_queuelock_acquire( lock_xp );
1131
1132	found = false;
1133
1134	for ( id = 0; id < CONFIG_PROCESS_FILE_MAX_NR ; id++ )
1135	{
1136	xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[id] ) );
1137	if ( xp == XPTR_NULL )
1138	{
1139	// update reference fd_array
1140	hal_remote_s64( XPTR( process_cxy , &process_ptr->fd_array.array[id] ) , file_xp );
1141	hal_remote_atomic_add( XPTR( process_cxy , &process_ptr->fd_array.current ) , 1 );
1142
1143	// exit
1144	*fdid = id;
1145	found = true;
1146	break;
1147	}
1148	}
1149
1150	// release lock protecting fd_array
1151	remote_queuelock_release( lock_xp );
1152
1153	#if DEBUG_PROCESS_FD_REGISTER
1154	cycle = (uint32_t)hal_get_cycles();
1155	if( DEBUG_PROCESS_FD_REGISTER < cycle )
1156	printk("\n[%s] thread[%x,%x] exit for process %x / fdid %d / cycle %d\n",
1157	__FUNCTION__, this->process->pid, this->trdid, pid, id, cycle );
1158	#endif
1159
1160	if ( !found ) return -1;
1161	else return 0;
1162
1163	} // end process_fd_register()
1164
1165	////////////////////////////////////////////////
1166	xptr_t process_fd_get_xptr( process_t * process,
1167	uint32_t fdid )
1168	{
1169	xptr_t file_xp;
1170	xptr_t lock_xp;
1171
1172	// access local copy of process descriptor
1173	file_xp = process->fd_array.array[fdid];
1174
1175	if( file_xp == XPTR_NULL )
1176	{
1177	// get reference process cluster and local pointer
1178	xptr_t ref_xp = process->ref_xp;
1179	cxy_t ref_cxy = GET_CXY( ref_xp );
1180	process_t * ref_ptr = GET_PTR( ref_xp );
1181
1182	// build extended pointer on lock protecting reference fd_array
1183	lock_xp = XPTR( ref_cxy , &ref_ptr->fd_array.lock );
1184
1185	// take lock protecting reference fd_array
1186	remote_queuelock_acquire( lock_xp );
1187
1188	// access reference process descriptor
1189	file_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->fd_array.array[fdid] ) );
1190
1191	// update local fd_array if found
1192	if( file_xp != XPTR_NULL ) process->fd_array.array[fdid] = file_xp;
1193
1194	// release lock protecting reference fd_array
1195	remote_queuelock_release( lock_xp );
1196	}
1197
1198	return file_xp;
1199
1200	} // end process_fd_get_xptr()
1201
1202	///////////////////////////////////////////
1203	void process_fd_remote_copy( xptr_t dst_xp,
1204	xptr_t src_xp )
1205	{
1206	uint32_t fd;
1207	xptr_t entry;
1208
1209	// get cluster and local pointer for src fd_array
1210	cxy_t src_cxy = GET_CXY( src_xp );
1211	fd_array_t * src_ptr = GET_PTR( src_xp );
1212
1213	// get cluster and local pointer for dst fd_array
1214	cxy_t dst_cxy = GET_CXY( dst_xp );
1215	fd_array_t * dst_ptr = GET_PTR( dst_xp );
1216
1217	// get the remote lock protecting the src fd_array
1218	remote_queuelock_acquire( XPTR( src_cxy , &src_ptr->lock ) );
1219
1220	// loop on all fd_array entries
1221	for( fd = 0 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
1222	{
1223	entry = (xptr_t)hal_remote_l64( XPTR( src_cxy , &src_ptr->array[fd] ) );
1224
1225	if( entry != XPTR_NULL )
1226	{
1227	// increment file descriptor refcount
1228	vfs_file_count_up( entry );
1229
1230	// copy entry in destination process fd_array
1231	hal_remote_s64( XPTR( dst_cxy , &dst_ptr->array[fd] ) , entry );
1232	}
1233	}
1234
1235	// release lock on source process fd_array
1236	remote_queuelock_release( XPTR( src_cxy , &src_ptr->lock ) );
1237
1238	} // end process_fd_remote_copy()
1239
1240
1241	////////////////////////////////////
1242	bool_t process_fd_array_full( void )
1243	{
1244	// get extended pointer on reference process
1245	xptr_t ref_xp = CURRENT_THREAD->process->ref_xp;
1246
1247	// get reference process cluster and local pointer
1248	process_t * ref_ptr = GET_PTR( ref_xp );
1249	cxy_t ref_cxy = GET_CXY( ref_xp );
1250
1251	// get number of open file descriptors from reference fd_array
1252	uint32_t current = hal_remote_l32( XPTR( ref_cxy , &ref_ptr->fd_array.current ) );
1253
1254	return ( current >= CONFIG_PROCESS_FILE_MAX_NR );
1255	}
1256
1257
1258	////////////////////////////////////////////////////////////////////////////////////
1259	// Thread related functions
1260	////////////////////////////////////////////////////////////////////////////////////
1261
1262	/////////////////////////////////////////////////////
1263	error_t process_register_thread( process_t * process,
1264	thread_t * thread,
1265	trdid_t * trdid )
1266	{
1267	ltid_t ltid;
1268	bool_t found = false;
1269
1270	// check arguments
1271	assert( (process != NULL) , "process argument is NULL" );
1272	assert( (thread != NULL) , "thread argument is NULL" );
1273
1274	// get the lock protecting th_tbl for all threads
1275	// but the idle thread executing kernel_init (cannot yield)
1276	if( thread->type != THREAD_IDLE ) rwlock_wr_acquire( &process->th_lock );
1277
1278	// scan th_tbl
1279	for( ltid = 0 ; ltid < CONFIG_THREADS_MAX_PER_CLUSTER ; ltid++ )
1280	{
1281	if( process->th_tbl[ltid] == NULL )
1282	{
1283	found = true;
1284	break;
1285	}
1286	}
1287
1288	if( found )
1289	{
1290	// register thread in th_tbl[]
1291	process->th_tbl[ltid] = thread;
1292	process->th_nr++;
1293
1294	// returns trdid
1295	*trdid = TRDID( local_cxy , ltid );
1296	}
1297
1298	// release the lock protecting th_tbl
1299	if( thread->type != THREAD_IDLE ) rwlock_wr_release( &process->th_lock );
1300
1301	return (found) ? 0 : 0xFFFFFFFF;
1302
1303	} // end process_register_thread()
1304
1305	///////////////////////////////////////////////////
1306	uint32_t process_remove_thread( thread_t * thread )
1307	{
1308	uint32_t count; // number of threads in local process descriptor
1309
1310	// check thread
1311	assert( (thread != NULL) , "thread argument is NULL" );
1312
1313	process_t * process = thread->process;
1314
1315	// get thread local index
1316	ltid_t ltid = LTID_FROM_TRDID( thread->trdid );
1317
1318	// get the lock protecting th_tbl[]
1319	rwlock_wr_acquire( &process->th_lock );
1320
1321	// get number of threads
1322	count = process->th_nr;
1323
1324	// check th_nr value
1325	assert( (count > 0) , "process th_nr cannot be 0" );
1326
1327	// remove thread from th_tbl[]
1328	process->th_tbl[ltid] = NULL;
1329	process->th_nr = count-1;
1330
1331	// release lock protecting th_tbl
1332	rwlock_wr_release( &process->th_lock );
1333
1334	return count;
1335
1336	} // end process_remove_thread()
1337
1338	/////////////////////////////////////////////////////////
1339	error_t process_make_fork( xptr_t parent_process_xp,
1340	xptr_t parent_thread_xp,
1341	pid_t * child_pid,
1342	thread_t ** child_thread )
1343	{
1344	process_t * process; // local pointer on child process descriptor
1345	thread_t * thread; // local pointer on child thread descriptor
1346	pid_t new_pid; // process identifier for child process
1347	pid_t parent_pid; // process identifier for parent process
1348	xptr_t ref_xp; // extended pointer on reference process
1349	xptr_t vfs_bin_xp; // extended pointer on .elf file
1350	error_t error;
1351
1352	// get cluster and local pointer for parent process
1353	cxy_t parent_process_cxy = GET_CXY( parent_process_xp );
1354	process_t * parent_process_ptr = GET_PTR( parent_process_xp );
1355
1356	// get parent process PID and extended pointer on .elf file
1357	parent_pid = hal_remote_l32 (XPTR( parent_process_cxy , &parent_process_ptr->pid));
1358	vfs_bin_xp = hal_remote_l64(XPTR( parent_process_cxy , &parent_process_ptr->vfs_bin_xp));
1359
1360	// get extended pointer on reference process
1361	ref_xp = hal_remote_l64( XPTR( parent_process_cxy , &parent_process_ptr->ref_xp ) );
1362
1363	// check parent process is the reference process
1364	assert( (parent_process_xp == ref_xp ) ,
1365	"parent process must be the reference process" );
1366
1367	#if DEBUG_PROCESS_MAKE_FORK
1368	uint32_t cycle = (uint32_t)hal_get_cycles();
1369	thread_t * this = CURRENT_THREAD;
1370	trdid_t trdid = this->trdid;
1371	pid_t pid = this->process->pid;
1372	if( DEBUG_PROCESS_MAKE_FORK < cycle )
1373	printk("\n[%s] thread[%x,%x] enter / cluster %x / cycle %d\n",
1374	__FUNCTION__, pid, trdid, local_cxy, cycle );
1375	#endif
1376
1377	// allocate a process descriptor
1378	process = process_alloc();
1379	if( process == NULL )
1380	{
1381	printk("\n[ERROR] in %s : cannot get process in cluster %x\n",
1382	__FUNCTION__, local_cxy );
1383	return -1;
1384	}
1385
1386	// allocate a child PID from local cluster
1387	error = cluster_pid_alloc( process , &new_pid );
1388	if( error )
1389	{
1390	printk("\n[ERROR] in %s : cannot get PID in cluster %x\n",
1391	__FUNCTION__, local_cxy );
1392	process_free( process );
1393	return -1;
1394	}
1395
1396	#if( DEBUG_PROCESS_MAKE_FORK & 1 )
1397	cycle = (uint32_t)hal_get_cycles();
1398	if( DEBUG_PROCESS_MAKE_FORK < cycle )
1399	printk("\n[%s] thread[%x,%x] allocated child_process %x / cycle %d\n",
1400	__FUNCTION__, pid, trdid, new_pid, cycle );
1401	#endif
1402
1403	// initializes child process descriptor from parent process descriptor
1404	error = process_reference_init( process,
1405	new_pid,
1406	parent_process_xp );
1407	if( error )
1408	{
1409	printk("\n[ERROR] in %s : cannot initialize child process in cluster %x\n",
1410	__FUNCTION__, local_cxy );
1411	process_free( process );
1412	return -1;
1413	}
1414
1415	#if( DEBUG_PROCESS_MAKE_FORK & 1 )
1416	cycle = (uint32_t)hal_get_cycles();
1417	if( DEBUG_PROCESS_MAKE_FORK < cycle )
1418	printk("\n[%s] thread[%x,%x] initialized child_process %x / cycle %d\n",
1419	__FUNCTION__, pid, trdid, new_pid, cycle );
1420	#endif
1421
1422	// copy VMM from parent descriptor to child descriptor
1423	error = vmm_fork_copy( process,
1424	parent_process_xp );
1425	if( error )
1426	{
1427	printk("\n[ERROR] in %s : cannot copy VMM in cluster %x\n",
1428	__FUNCTION__, local_cxy );
1429	process_free( process );
1430	cluster_pid_release( new_pid );
1431	return -1;
1432	}
1433
1434	#if( DEBUG_PROCESS_MAKE_FORK & 1 )
1435	cycle = (uint32_t)hal_get_cycles();
1436	if( DEBUG_PROCESS_MAKE_FORK < cycle )
1437	printk("\n[%s] thread[%x,%x] copied VMM from parent to child / cycle %d\n",
1438	__FUNCTION__, pid, trdid, cycle );
1439	#endif
1440
1441	// if parent_process is INIT, or if parent_process is the TXT owner,
1442	// the child_process becomes the owner of its TXT terminal
1443	if( (parent_pid == 1) \|\| process_txt_is_owner( parent_process_xp ) )
1444	{
1445	process_txt_set_ownership( XPTR( local_cxy , process ) );
1446
1447	#if( DEBUG_PROCESS_MAKE_FORK & 1 )
1448	cycle = (uint32_t)hal_get_cycles();
1449	if( DEBUG_PROCESS_MAKE_EXEC < cycle )
1450	printk("\n[%s] thread[%x,%x] / child takes TXT ownership / cycle %d\n",
1451	__FUNCTION__ , pid, trdid, cycle );
1452	#endif
1453
1454	}
1455
1456	// update extended pointer on .elf file
1457	process->vfs_bin_xp = vfs_bin_xp;
1458
1459	// create child thread descriptor from parent thread descriptor
1460	error = thread_user_fork( parent_thread_xp,
1461	process,
1462	&thread );
1463	if( error )
1464	{
1465	printk("\n[ERROR] in %s : cannot create thread in cluster %x\n",
1466	__FUNCTION__, local_cxy );
1467	process_free( process );
1468	cluster_pid_release( new_pid );
1469	return -1;
1470	}
1471
1472	// check main thread LTID
1473	assert( (LTID_FROM_TRDID(thread->trdid) == 0) ,
1474	"main thread must have LTID == 0" );
1475
1476	#if( DEBUG_PROCESS_MAKE_FORK & 1 )
1477	cycle = (uint32_t)hal_get_cycles();
1478	if( DEBUG_PROCESS_MAKE_FORK < cycle )
1479	printk("\n[%s] thread[%x,%x] created main thread %x / cycle %d\n",
1480	__FUNCTION__, pid, trdid, thread, cycle );
1481	#endif
1482
1483	// set COW flag in DATA, ANON, REMOTE vsegs for parent process VMM
1484	// this includes all parnet process copies in all clusters
1485	if( parent_process_cxy == local_cxy ) // reference is local
1486	{
1487	vmm_set_cow( parent_process_ptr );
1488	}
1489	else // reference is remote
1490	{
1491	rpc_vmm_set_cow_client( parent_process_cxy,
1492	parent_process_ptr );
1493	}
1494
1495	// set COW flag in DATA, ANON, REMOTE vsegs for child process VMM
1496	vmm_set_cow( process );
1497
1498	#if( DEBUG_PROCESS_MAKE_FORK & 1 )
1499	cycle = (uint32_t)hal_get_cycles();
1500	if( DEBUG_PROCESS_MAKE_FORK < cycle )
1501	printk("\n[%s] thread[%x,%x] set COW in parent and child / cycle %d\n",
1502	__FUNCTION__, pid, trdid, cycle );
1503	#endif
1504
1505	// get extended pointers on parent children_root, children_lock and children_nr
1506	xptr_t children_root_xp = XPTR( parent_process_cxy , &parent_process_ptr->children_root );
1507	xptr_t children_lock_xp = XPTR( parent_process_cxy , &parent_process_ptr->children_lock );
1508	xptr_t children_nr_xp = XPTR( parent_process_cxy , &parent_process_ptr->children_nr );
1509
1510	// register process in parent children list
1511	remote_queuelock_acquire( children_lock_xp );
1512	xlist_add_last( children_root_xp , XPTR( local_cxy , &process->children_list ) );
1513	hal_remote_atomic_add( children_nr_xp , 1 );
1514	remote_queuelock_release( children_lock_xp );
1515
1516	// return success
1517	*child_thread = thread;
1518	*child_pid = new_pid;
1519
1520	#if DEBUG_PROCESS_MAKE_FORK
1521	cycle = (uint32_t)hal_get_cycles();
1522	if( DEBUG_PROCESS_MAKE_FORK < cycle )
1523	printk("\n[%s] thread[%x,%x] exit / created process %x / cycle %d\n",
1524	__FUNCTION__, pid, trdid, new_pid, cycle );
1525	#endif
1526
1527	return 0;
1528
1529	} // end process_make_fork()
1530
1531	/////////////////////////////////////////////////////
1532	error_t process_make_exec( exec_info_t * exec_info )
1533	{
1534	thread_t * thread; // local pointer on this thread
1535	process_t * process; // local pointer on this process
1536	pid_t pid; // this process identifier
1537	xptr_t ref_xp; // reference process for this process
1538	error_t error; // value returned by called functions
1539	char * path; // path to .elf file
1540	xptr_t file_xp; // extended pointer on .elf file descriptor
1541	uint32_t file_id; // file index in fd_array
1542	uint32_t args_nr; // number of main thread arguments
1543	char ** args_pointers; // array of pointers on main thread arguments
1544
1545	// get calling thread, process, pid and ref_xp
1546	thread = CURRENT_THREAD;
1547	process = thread->process;
1548	pid = process->pid;
1549	ref_xp = process->ref_xp;
1550
1551	// get relevant infos from exec_info
1552	path = exec_info->path;
1553	args_nr = exec_info->args_nr;
1554	args_pointers = exec_info->args_pointers;
1555
1556	#if DEBUG_PROCESS_MAKE_EXEC
1557	uint32_t cycle = (uint32_t)hal_get_cycles();
1558	if( DEBUG_PROCESS_MAKE_EXEC < cycle )
1559	printk("\n[%s] thread[%x,%x] enters for %s / cycle %d\n",
1560	__FUNCTION__, pid, thread->trdid, path, cycle );
1561	#endif
1562
1563	// open the file identified by <path>
1564	file_xp = XPTR_NULL;
1565	file_id = 0xFFFFFFFF;
1566	error = vfs_open( process->vfs_root_xp,
1567	path,
1568	ref_xp,
1569	O_RDONLY,
1570	0,
1571	&file_xp,
1572	&file_id );
1573	if( error )
1574	{
1575	printk("\n[ERROR] in %s : failed to open file <%s>\n", __FUNCTION__ , path );
1576	return -1;
1577	}
1578
1579	#if (DEBUG_PROCESS_MAKE_EXEC & 1)
1580	cycle = (uint32_t)hal_get_cycles();
1581	if( DEBUG_PROCESS_MAKE_EXEC < cycle )
1582	printk("\n[%s] thread[%x,%x] opened file <%s> / cycle %d\n",
1583	__FUNCTION__, pid, thread->trdid, path, cycle );
1584	#endif
1585
1586	// delete all threads other than this main thread in all clusters
1587	process_sigaction( pid , DELETE_ALL_THREADS );
1588
1589	#if (DEBUG_PROCESS_MAKE_EXEC & 1)
1590	cycle = (uint32_t)hal_get_cycles();
1591	if( DEBUG_PROCESS_MAKE_EXEC < cycle )
1592	printk("\n[%s] thread[%x,%x] deleted existing threads / cycle %d\n",
1593	__FUNCTION__, pid, thread->trdid, cycle );
1594	#endif
1595
1596	// reset calling process VMM
1597	vmm_user_reset( process );
1598
1599	#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
1600	cycle = (uint32_t)hal_get_cycles();
1601	if( DEBUG_PROCESS_MAKE_EXEC < cycle )
1602	printk("\n[%s] thread[%x,%x] completed VMM reset / cycle %d\n",
1603	__FUNCTION__, pid, thread->trdid, cycle );
1604	#endif
1605
1606	// re-initialize the VMM (args/envs vsegs registration)
1607	error = vmm_user_init( process );
1608	if( error )
1609	{
1610	printk("\n[ERROR] in %s : cannot initialise VMM for %s\n", __FUNCTION__ , path );
1611	vfs_close( file_xp , file_id );
1612	// FIXME restore old process VMM [AG]
1613	return -1;
1614	}
1615
1616	#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
1617	cycle = (uint32_t)hal_get_cycles();
1618	if( DEBUG_PROCESS_MAKE_EXEC < cycle )
1619	printk("\n[%s] thread[%x,%x] registered args/envs vsegs / cycle %d\n",
1620	__FUNCTION__, pid, thread->trdid, cycle );
1621	#endif
1622
1623	// register code & data vsegs as well as entry-point in process VMM,
1624	// and register extended pointer on .elf file in process descriptor
1625	error = elf_load_process( file_xp , process );
1626	if( error )
1627	{
1628	printk("\n[ERROR] in %s : failed to access <%s>\n", __FUNCTION__ , path );
1629	vfs_close( file_xp , file_id );
1630	// FIXME restore old process VMM [AG]
1631	return -1;
1632	}
1633
1634	#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
1635	cycle = (uint32_t)hal_get_cycles();
1636	if( DEBUG_PROCESS_MAKE_EXEC < cycle )
1637	printk("\n[%s] thread[%x,%x] registered code/data vsegs / cycle %d\n",
1638	__FUNCTION__, pid, thread->trdid, cycle );
1639	#endif
1640
1641	// update the existing main thread descriptor... and jump to user code
1642	error = thread_user_exec( (void *)process->vmm.entry_point,
1643	args_nr,
1644	args_pointers );
1645	if( error )
1646	{
1647	printk("\n[ERROR] in %s : cannot update main thread for %s\n", __FUNCTION__ , path );
1648	vfs_close( file_xp , file_id );
1649	// FIXME restore old process VMM
1650	return -1;
1651	}
1652
1653	assert( false, "we should not execute this code");
1654
1655	return 0;
1656
1657	} // end process_make_exec()
1658
1659
1660	////////////////////////////////////////////////
1661	void process_zero_create( process_t * process,
1662	boot_info_t * info )
1663	{
1664	error_t error;
1665	pid_t pid;
1666
1667	#if DEBUG_PROCESS_ZERO_CREATE
1668	uint32_t cycle = (uint32_t)hal_get_cycles();
1669	if( DEBUG_PROCESS_ZERO_CREATE < cycle )
1670	printk("\n[%s] enter / cluster %x / cycle %d\n",
1671	__FUNCTION__, local_cxy, cycle );
1672	#endif
1673
1674	// get pointer on VMM
1675	vmm_t * vmm = &process->vmm;
1676
1677	// get PID from local cluster manager for this kernel process
1678	error = cluster_pid_alloc( process , &pid );
1679
1680	if( error \|\| (LPID_FROM_PID( pid ) != 0) )
1681	{
1682	printk("\n[PANIC] in %s : cannot get valid PID in cluster %x / PID = %x\n",
1683	__FUNCTION__ , local_cxy, pid );
1684	hal_core_sleep();
1685	}
1686
1687	// initialize PID, REF_XP, PARENT_XP, and STATE
1688	// the kernel process_zero is its own parent_process,
1689	// reference_process, and owner_process, and cannot be killed...
1690	process->pid = pid;
1691	process->ref_xp = XPTR( local_cxy , process );
1692	process->owner_xp = XPTR( local_cxy , process );
1693	process->parent_xp = XPTR( local_cxy , process );
1694	process->term_state = 0;
1695
1696	// initilise VSL as empty
1697	vmm->vsegs_nr = 0;
1698	xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
1699
1700	// initialise GPT as empty
1701	error = hal_gpt_create( &vmm->gpt );
1702	if( error )
1703	{
1704	printk("\n[PANIC] in %s : cannot create empty GPT\n", __FUNCTION__ );
1705	hal_core_sleep();
1706	}
1707
1708	// initialize VSL and GPT locks
1709	remote_rwlock_init( XPTR( local_cxy , &vmm->vsl_lock ) , LOCK_VMM_VSL );
1710	remote_rwlock_init( XPTR( local_cxy , &vmm->gpt_lock ) , LOCK_VMM_GPT );
1711
1712	// create kernel vsegs in GPT and VSL, as required by the hardware architecture
1713	error = hal_vmm_kernel_init( info );
1714	if( error )
1715	{
1716	printk("\n[PANIC] in %s : cannot create kernel vsegs in VMM\n", __FUNCTION__ );
1717	hal_core_sleep();
1718	}
1719
1720	// reset th_tbl[] array and associated fields
1721	uint32_t i;
1722	for( i = 0 ; i < CONFIG_THREADS_MAX_PER_CLUSTER ; i++ )
1723	{
1724	process->th_tbl[i] = NULL;
1725	}
1726	process->th_nr = 0;
1727	rwlock_init( &process->th_lock , LOCK_PROCESS_THTBL );
1728
1729
1730	// reset children list as empty
1731	xlist_root_init( XPTR( local_cxy , &process->children_root ) );
1732	process->children_nr = 0;
1733	remote_queuelock_init( XPTR( local_cxy , &process->children_lock ),
1734	LOCK_PROCESS_CHILDREN );
1735
1736	// register kernel process in cluster manager local_list
1737	cluster_process_local_link( process );
1738
1739	hal_fence();
1740
1741	#if DEBUG_PROCESS_ZERO_CREATE
1742	cycle = (uint32_t)hal_get_cycles();
1743	if( DEBUG_PROCESS_ZERO_CREATE < cycle )
1744	printk("\n[%s] exit / cluster %x / cycle %d\n",
1745	__FUNCTION__, local_cxy, cycle );
1746	#endif
1747
1748	} // end process_zero_create()
1749
1750	////////////////////////////////
1751	void process_init_create( void )
1752	{
1753	process_t * process; // local pointer on process descriptor
1754	pid_t pid; // process_init identifier
1755	thread_t * thread; // local pointer on main thread
1756	pthread_attr_t attr; // main thread attributes
1757	lid_t lid; // selected core local index for main thread
1758	xptr_t file_xp; // extended pointer on .elf file descriptor
1759	uint32_t file_id; // file index in fd_array
1760	error_t error;
1761
1762	#if DEBUG_PROCESS_INIT_CREATE
1763	thread_t * this = CURRENT_THREAD;
1764	uint32_t cycle = (uint32_t)hal_get_cycles();
1765	if( DEBUG_PROCESS_INIT_CREATE < cycle )
1766	printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
1767	__FUNCTION__, this->process->pid, this->trdid, cycle );
1768	#endif
1769
1770	// allocates memory for process descriptor from local cluster
1771	process = process_alloc();
1772	if( process == NULL )
1773	{
1774	printk("\n[PANIC] in %s : cannot allocate process\n", __FUNCTION__ );
1775	hal_core_sleep();
1776	}
1777
1778	// set the CWD and VFS_ROOT fields in process descriptor
1779	process->cwd_xp = process_zero.vfs_root_xp;
1780	process->vfs_root_xp = process_zero.vfs_root_xp;
1781
1782	// get PID from local cluster
1783	error = cluster_pid_alloc( process , &pid );
1784	if( error )
1785	{
1786	printk("\n[PANIC] in %s : cannot allocate PID\n", __FUNCTION__ );
1787	hal_core_sleep();
1788	}
1789	if( pid != 1 )
1790	{
1791	printk("\n[PANIC] in %s : process PID must be 0x1\n", __FUNCTION__ );
1792	hal_core_sleep();
1793	}
1794
1795	// initialize process descriptor / parent is local process_zero
1796	error = process_reference_init( process,
1797	pid,
1798	XPTR( local_cxy , &process_zero ) );
1799	if( error )
1800	{
1801	printk("\n[PANIC] in %s : cannot initialize process\n", __FUNCTION__ );
1802	hal_core_sleep();
1803	}
1804
1805	#if(DEBUG_PROCESS_INIT_CREATE & 1)
1806	if( DEBUG_PROCESS_INIT_CREATE < cycle )
1807	printk("\n[%s] thread[%x,%x] initialized process descriptor\n",
1808	__FUNCTION__, this->process->pid, this->trdid );
1809	#endif
1810
1811	// open the file identified by CONFIG_PROCESS_INIT_PATH
1812	file_xp = XPTR_NULL;
1813	file_id = -1;
1814	error = vfs_open( process->vfs_root_xp,
1815	CONFIG_PROCESS_INIT_PATH,
1816	XPTR( local_cxy , process ),
1817	O_RDONLY,
1818	0,
1819	&file_xp,
1820	&file_id );
1821	if( error )
1822	{
1823	printk("\n[PANIC] in %s : cannot open file <%s>\n",
1824	__FUNCTION__, CONFIG_PROCESS_INIT_PATH );
1825	hal_core_sleep();
1826	}
1827
1828	#if(DEBUG_PROCESS_INIT_CREATE & 1)
1829	if( DEBUG_PROCESS_INIT_CREATE < cycle )
1830	printk("\n[%s] thread[%x,%x] open .elf file decriptor\n",
1831	__FUNCTION__, this->process->pid, this->trdid );
1832	#endif
1833
1834	// register "code" and "data" vsegs as well as entry-point
1835	// in process VMM, using information contained in the elf file.
1836	error = elf_load_process( file_xp , process );
1837
1838	if( error )
1839	{
1840	printk("\n[PANIC] in %s : cannot access file <%s>\n",
1841	__FUNCTION__, CONFIG_PROCESS_INIT_PATH );
1842	hal_core_sleep();
1843	}
1844
1845
1846	#if(DEBUG_PROCESS_INIT_CREATE & 1)
1847	if( DEBUG_PROCESS_INIT_CREATE < cycle )
1848	printk("\n[%s] thread[%x,%x] registered code/data vsegs in VMM\n",
1849	__FUNCTION__, this->process->pid, this->trdid );
1850	#endif
1851
1852	#if (DEBUG_PROCESS_INIT_CREATE & 1)
1853	hal_vmm_display( process , true );
1854	#endif
1855
1856	// get extended pointers on process_zero children_root, children_lock
1857	xptr_t children_root_xp = XPTR( local_cxy , &process_zero.children_root );
1858	xptr_t children_lock_xp = XPTR( local_cxy , &process_zero.children_lock );
1859
1860	// take lock protecting kernel process children list
1861	remote_queuelock_acquire( children_lock_xp );
1862
1863	// register process INIT in parent local process_zero
1864	xlist_add_last( children_root_xp , XPTR( local_cxy , &process->children_list ) );
1865	hal_atomic_add( &process_zero.children_nr , 1 );
1866
1867	// release lock protecting kernel process children list
1868	remote_queuelock_release( children_lock_xp );
1869
1870	#if(DEBUG_PROCESS_INIT_CREATE & 1)
1871	if( DEBUG_PROCESS_INIT_CREATE < cycle )
1872	printk("\n[%s] thread[%x,%x] registered init process in parent\n",
1873	__FUNCTION__, this->process->pid, this->trdid );
1874	#endif
1875
1876	// select a core in local cluster to execute the main thread
1877	lid = cluster_select_local_core();
1878
1879	// initialize pthread attributes for main thread
1880	attr.attributes = PT_ATTR_DETACH \| PT_ATTR_CLUSTER_DEFINED \| PT_ATTR_CORE_DEFINED;
1881	attr.cxy = local_cxy;
1882	attr.lid = lid;
1883
1884	// create and initialize thread descriptor
1885	error = thread_user_create( pid,
1886	(void *)process->vmm.entry_point,
1887	NULL,
1888	&attr,
1889	&thread );
1890
1891	if( error )
1892	{
1893	printk("\n[PANIC] in %s : cannot create main thread\n", __FUNCTION__ );
1894	hal_core_sleep();
1895	}
1896	if( thread->trdid != 0 )
1897	{
1898	printk("\n[PANIC] in %s : bad main thread trdid\n", __FUNCTION__ );
1899	hal_core_sleep();
1900	}
1901
1902	#if(DEBUG_PROCESS_INIT_CREATE & 1)
1903	if( DEBUG_PROCESS_INIT_CREATE < cycle )
1904	printk("\n[%s] thread[%x,%x] created main thread\n",
1905	__FUNCTION__, this->process->pid, this->trdid );
1906	#endif
1907
1908	// activate thread
1909	thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
1910
1911	hal_fence();
1912
1913	#if DEBUG_PROCESS_INIT_CREATE
1914	cycle = (uint32_t)hal_get_cycles();
1915	if( DEBUG_PROCESS_INIT_CREATE < cycle )
1916	printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
1917	__FUNCTION__, this->process->pid, this->trdid, cycle );
1918	#endif
1919
1920	} // end process_init_create()
1921
1922	/////////////////////////////////////////
1923	void process_display( xptr_t process_xp )
1924	{
1925	process_t * process_ptr;
1926	cxy_t process_cxy;
1927
1928	xptr_t parent_xp; // extended pointer on parent process
1929	process_t * parent_ptr;
1930	cxy_t parent_cxy;
1931
1932	xptr_t owner_xp; // extended pointer on owner process
1933	process_t * owner_ptr;
1934	cxy_t owner_cxy;
1935
1936	pid_t pid;
1937	pid_t ppid;
1938	lpid_t lpid;
1939	uint32_t state;
1940	uint32_t th_nr;
1941
1942	xptr_t txt_file_xp; // extended pointer on TXT_RX file descriptor
1943	xptr_t txt_chdev_xp; // extended pointer on TXT_RX chdev
1944	chdev_t * txt_chdev_ptr;
1945	cxy_t txt_chdev_cxy;
1946	xptr_t txt_owner_xp; // extended pointer on TXT owner process
1947
1948	xptr_t elf_file_xp; // extended pointer on .elf file
1949	cxy_t elf_file_cxy;
1950	vfs_file_t * elf_file_ptr;
1951	vfs_inode_t * elf_inode_ptr; // local pointer on .elf inode
1952
1953	char txt_name[CONFIG_VFS_MAX_NAME_LENGTH];
1954	char elf_name[CONFIG_VFS_MAX_NAME_LENGTH];
1955
1956	// get cluster and local pointer on process
1957	process_ptr = GET_PTR( process_xp );
1958	process_cxy = GET_CXY( process_xp );
1959
1960	// get process PID, LPID, and state
1961	pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
1962	lpid = LPID_FROM_PID( pid );
1963	state = hal_remote_l32( XPTR( process_cxy , &process_ptr->term_state ) );
1964
1965	// get process PPID
1966	parent_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->parent_xp ) );
1967	parent_cxy = GET_CXY( parent_xp );
1968	parent_ptr = GET_PTR( parent_xp );
1969	ppid = hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid ) );
1970
1971	// get number of threads
1972	th_nr = hal_remote_l32( XPTR( process_cxy , &process_ptr->th_nr ) );
1973
1974	// get pointers on owner process descriptor
1975	owner_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->owner_xp ) );
1976	owner_cxy = GET_CXY( owner_xp );
1977	owner_ptr = GET_PTR( owner_xp );
1978
1979	// get process TXT name and .elf name
1980	if( lpid ) // user process
1981	{
1982
1983	// get extended pointer on file descriptor associated to TXT_RX
1984	txt_file_xp = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->fd_array.array[0] ) );
1985
1986	assert( (txt_file_xp != XPTR_NULL) ,
1987	"process must be attached to one TXT terminal" );
1988
1989	// get TXT_RX chdev pointers
1990	txt_chdev_xp = chdev_from_file( txt_file_xp );
1991	txt_chdev_cxy = GET_CXY( txt_chdev_xp );
1992	txt_chdev_ptr = GET_PTR( txt_chdev_xp );
1993
1994	// get TXT_RX name and ownership
1995	hal_remote_strcpy( XPTR( local_cxy , txt_name ) ,
1996	XPTR( txt_chdev_cxy , txt_chdev_ptr->name ) );
1997
1998	txt_owner_xp = (xptr_t)hal_remote_l64( XPTR( txt_chdev_cxy,
1999	&txt_chdev_ptr->ext.txt.owner_xp ) );
2000
2001	// get process .elf name
2002	elf_file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->vfs_bin_xp ) );
2003	elf_file_cxy = GET_CXY( elf_file_xp );
2004	elf_file_ptr = GET_PTR( elf_file_xp );
2005	elf_inode_ptr = hal_remote_lpt( XPTR( elf_file_cxy , &elf_file_ptr->inode ) );
2006	vfs_inode_get_name( XPTR( elf_file_cxy , elf_inode_ptr ) , elf_name );
2007	}
2008	else // kernel process_zero
2009	{
2010	// TXT name and .elf name are not registered in kernel process_zero
2011	strcpy( txt_name , "txt0_rx" );
2012	txt_owner_xp = process_xp;
2013	strcpy( elf_name , "kernel.elf" );
2014	}
2015
2016	// display process info
2017	if( txt_owner_xp == process_xp )
2018	{
2019	nolock_printk("PID %X \| %s (FG) \| %X \| PPID %X \| TS %X \| %d \| %s\n",
2020	pid, txt_name, process_ptr, ppid, state, th_nr, elf_name );
2021	}
2022	else
2023	{
2024	nolock_printk("PID %X \| %s (BG) \| %X \| PPID %X \| TS %X \| %d \| %s\n",
2025	pid, txt_name, process_ptr, ppid, state, th_nr, elf_name );
2026	}
2027	} // end process_display()
2028
2029
2030	////////////////////////////////////////////////////////////////////////////////////////
2031	// Terminals related functions
2032	////////////////////////////////////////////////////////////////////////////////////////
2033
2034	//////////////////////////////////
2035	uint32_t process_txt_alloc( void )
2036	{
2037	uint32_t index; // TXT terminal index
2038	xptr_t chdev_xp; // extended pointer on TXT_RX chdev
2039	chdev_t * chdev_ptr; // local pointer on TXT_RX chdev
2040	cxy_t chdev_cxy; // TXT_RX chdev cluster
2041	xptr_t root_xp; // extended pointer on owner field in chdev
2042
2043	// scan the user TXT_RX chdevs (TXT0 is reserved for kernel)
2044	for( index = 1 ; index < LOCAL_CLUSTER->nb_txt_channels ; index ++ )
2045	{
2046	// get pointers on TXT_RX[index]
2047	chdev_xp = chdev_dir.txt_rx[index];
2048	chdev_cxy = GET_CXY( chdev_xp );
2049	chdev_ptr = GET_PTR( chdev_xp );
2050
2051	// get extended pointer on root of attached process
2052	root_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.root );
2053
2054	// return free TXT index if found
2055	if( xlist_is_empty( root_xp ) ) return index;
2056	}
2057
2058	assert( false , "no free TXT terminal found" );
2059
2060	return -1;
2061
2062	} // end process_txt_alloc()
2063
2064	/////////////////////////////////////////////
2065	void process_txt_attach( process_t * process,
2066	uint32_t txt_id )
2067	{
2068	xptr_t chdev_xp; // extended pointer on TXT_RX chdev
2069	cxy_t chdev_cxy; // TXT_RX chdev cluster
2070	chdev_t * chdev_ptr; // local pointer on TXT_RX chdev
2071	xptr_t root_xp; // extended pointer on list root in chdev
2072	xptr_t lock_xp; // extended pointer on list lock in chdev
2073
2074	// check process is in owner cluster
2075	assert( (CXY_FROM_PID( process->pid ) == local_cxy) ,
2076	"process descriptor not in owner cluster" );
2077
2078	// check terminal index
2079	assert( (txt_id < LOCAL_CLUSTER->nb_txt_channels) ,
2080	"illegal TXT terminal index" );
2081
2082	// get pointers on TXT_RX[txt_id] chdev
2083	chdev_xp = chdev_dir.txt_rx[txt_id];
2084	chdev_cxy = GET_CXY( chdev_xp );
2085	chdev_ptr = GET_PTR( chdev_xp );
2086
2087	// get extended pointer on root & lock of attached process list
2088	root_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.root );
2089	lock_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.lock );
2090
2091	// get lock protecting list of processes attached to TXT
2092	remote_busylock_acquire( lock_xp );
2093
2094	// insert process in attached process list
2095	xlist_add_last( root_xp , XPTR( local_cxy , &process->txt_list ) );
2096
2097	// release lock protecting list of processes attached to TXT
2098	remote_busylock_release( lock_xp );
2099
2100	#if DEBUG_PROCESS_TXT
2101	thread_t * this = CURRENT_THREAD;
2102	uint32_t cycle = (uint32_t)hal_get_cycles();
2103	if( DEBUG_PROCESS_TXT < cycle )
2104	printk("\n[%s] thread[%x,%x] attached process %x to TXT %d / cycle %d\n",
2105	__FUNCTION__, this->process->pid, this->trdid, process->pid, txt_id , cycle );
2106	#endif
2107
2108	} // end process_txt_attach()
2109
2110	/////////////////////////////////////////////
2111	void process_txt_detach( xptr_t process_xp )
2112	{
2113	process_t * process_ptr; // local pointer on process in owner cluster
2114	cxy_t process_cxy; // process owner cluster
2115	pid_t process_pid; // process identifier
2116	xptr_t file_xp; // extended pointer on stdin file
2117	xptr_t chdev_xp; // extended pointer on TXT_RX chdev
2118	cxy_t chdev_cxy; // TXT_RX chdev cluster
2119	chdev_t * chdev_ptr; // local pointer on TXT_RX chdev
2120	xptr_t lock_xp; // extended pointer on list lock in chdev
2121
2122	// get process cluster, local pointer, and PID
2123	process_cxy = GET_CXY( process_xp );
2124	process_ptr = GET_PTR( process_xp );
2125	process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
2126
2127	// check process descriptor in owner cluster
2128	assert( (CXY_FROM_PID( process_pid ) == process_cxy ) ,
2129	"process descriptor not in owner cluster" );
2130
2131	// release TXT ownership (does nothing if not TXT owner)
2132	process_txt_transfer_ownership( process_xp );
2133
2134	// get extended pointer on process stdin pseudo file
2135	file_xp = (xptr_t)hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
2136
2137	// get pointers on TXT_RX chdev
2138	chdev_xp = chdev_from_file( file_xp );
2139	chdev_cxy = GET_CXY( chdev_xp );
2140	chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
2141
2142	// get extended pointer on lock protecting attached process list
2143	lock_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.lock );
2144
2145	// get lock protecting list of processes attached to TXT
2146	remote_busylock_acquire( lock_xp );
2147
2148	// unlink process from attached process list
2149	xlist_unlink( XPTR( process_cxy , &process_ptr->txt_list ) );
2150
2151	// release lock protecting list of processes attached to TXT
2152	remote_busylock_release( lock_xp );
2153
2154	#if DEBUG_PROCESS_TXT
2155	thread_t * this = CURRENT_THREAD;
2156	uint32_t cycle = (uint32_t)hal_get_cycles();
2157	uint32_t txt_id = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
2158	if( DEBUG_PROCESS_TXT < cycle )
2159	printk("\n[%s] thread[%x,%x] detached process %x from TXT%d / cycle %d\n",
2160	__FUNCTION__, this->process->pid, this->trdid, process_pid, txt_id, cycle );
2161	#endif
2162
2163	} // end process_txt_detach()
2164
2165	///////////////////////////////////////////////////
2166	void process_txt_set_ownership( xptr_t process_xp )
2167	{
2168	process_t * process_ptr;
2169	cxy_t process_cxy;
2170	pid_t process_pid;
2171	xptr_t file_xp;
2172	xptr_t txt_xp;
2173	chdev_t * txt_ptr;
2174	cxy_t txt_cxy;
2175
2176	// get pointers on process in owner cluster
2177	process_cxy = GET_CXY( process_xp );
2178	process_ptr = GET_PTR( process_xp );
2179	process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
2180
2181	// check owner cluster
2182	assert( (process_cxy == CXY_FROM_PID( process_pid )) ,
2183	"process descriptor not in owner cluster" );
2184
2185	// get extended pointer on stdin pseudo file
2186	file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
2187
2188	// get pointers on TXT chdev
2189	txt_xp = chdev_from_file( file_xp );
2190	txt_cxy = GET_CXY( txt_xp );
2191	txt_ptr = GET_PTR( txt_xp );
2192
2193	// set owner field in TXT chdev
2194	hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , process_xp );
2195
2196	#if DEBUG_PROCESS_TXT
2197	thread_t * this = CURRENT_THREAD;
2198	uint32_t cycle = (uint32_t)hal_get_cycles();
2199	uint32_t txt_id = hal_remote_l32( XPTR( txt_cxy , &txt_ptr->channel ) );
2200	if( DEBUG_PROCESS_TXT < cycle )
2201	printk("\n[%s] thread[%x,%x] give TXT%d ownership to process %x / cycle %d\n",
2202	__FUNCTION__, this->process->pid, this->trdid, txt_id, process_pid, cycle );
2203	#endif
2204
2205	} // end process_txt_set ownership()
2206
2207	////////////////////////////////////////////////////////
2208	void process_txt_transfer_ownership( xptr_t process_xp )
2209	{
2210	process_t * process_ptr; // local pointer on process releasing ownership
2211	cxy_t process_cxy; // process cluster
2212	pid_t process_pid; // process identifier
2213	xptr_t file_xp; // extended pointer on TXT_RX pseudo file
2214	xptr_t txt_xp; // extended pointer on TXT_RX chdev
2215	chdev_t * txt_ptr; // local pointer on TXT_RX chdev
2216	cxy_t txt_cxy; // cluster of TXT_RX chdev
2217	uint32_t txt_id; // TXT_RX channel
2218	xptr_t owner_xp; // extended pointer on current TXT_RX owner
2219	xptr_t root_xp; // extended pointer on root of attached process list
2220	xptr_t lock_xp; // extended pointer on lock protecting attached process list
2221	xptr_t iter_xp; // iterator for xlist
2222	xptr_t current_xp; // extended pointer on current process
2223	bool_t found;
2224
2225	#if DEBUG_PROCESS_TXT
2226	thread_t * this = CURRENT_THREAD;
2227	uint32_t cycle;
2228	#endif
2229
2230	// get pointers on target process
2231	process_cxy = GET_CXY( process_xp );
2232	process_ptr = GET_PTR( process_xp );
2233	process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
2234
2235	// check owner cluster
2236	assert( (process_cxy == CXY_FROM_PID( process_pid )) ,
2237	"process descriptor not in owner cluster" );
2238
2239	// get extended pointer on stdin pseudo file
2240	file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
2241
2242	// get pointers on TXT chdev
2243	txt_xp = chdev_from_file( file_xp );
2244	txt_cxy = GET_CXY( txt_xp );
2245	txt_ptr = GET_PTR( txt_xp );
2246
2247	// get relevant infos from chdev descriptor
2248	owner_xp = hal_remote_l64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
2249	txt_id = hal_remote_l32( XPTR( txt_cxy , &txt_ptr->channel ) );
2250
2251	// transfer ownership only if target process is the TXT owner
2252	if( (owner_xp == process_xp) && (txt_id > 0) )
2253	{
2254	// get extended pointers on root and lock of attached processes list
2255	root_xp = XPTR( txt_cxy , &txt_ptr->ext.txt.root );
2256	lock_xp = XPTR( txt_cxy , &txt_ptr->ext.txt.lock );
2257
2258	if( process_get_ppid( process_xp ) != 1 ) // target process is not KSH
2259	{
2260	// get lock
2261	remote_busylock_acquire( lock_xp );
2262
2263	// scan attached process list to find KSH process
2264	found = false;
2265	for( iter_xp = hal_remote_l64( root_xp ) ;
2266	(iter_xp != root_xp) && (found == false) ;
2267	iter_xp = hal_remote_l64( iter_xp ) )
2268	{
2269	current_xp = XLIST_ELEMENT( iter_xp , process_t , txt_list );
2270
2271	if( process_get_ppid( current_xp ) == 1 ) // current is KSH
2272	{
2273	// set owner field in TXT chdev
2274	hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
2275
2276	#if DEBUG_PROCESS_TXT
2277	cycle = (uint32_t)hal_get_cycles();
2278	if( DEBUG_PROCESS_TXT < cycle )
2279	printk("\n[%s] thread[%x,%x] transfered TXT%d ownership to KSH / cycle %d\n",
2280	__FUNCTION__, this->process->pid, this->trdid, txt_id, cycle );
2281	#endif
2282	found = true;
2283	}
2284	}
2285
2286	// release lock
2287	remote_busylock_release( lock_xp );
2288
2289	// It must exist a KSH process for each user TXT channel
2290	assert( (found == true), "KSH process not found for TXT%d", txt_id );
2291
2292	}
2293	else // target process is KSH
2294	{
2295	// get lock
2296	remote_busylock_acquire( lock_xp );
2297
2298	// scan attached process list to find another process
2299	found = false;
2300	for( iter_xp = hal_remote_l64( root_xp ) ;
2301	(iter_xp != root_xp) && (found == false) ;
2302	iter_xp = hal_remote_l64( iter_xp ) )
2303	{
2304	current_xp = XLIST_ELEMENT( iter_xp , process_t , txt_list );
2305
2306	if( current_xp != process_xp ) // current is not KSH
2307	{
2308	// set owner field in TXT chdev
2309	hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
2310
2311	#if DEBUG_PROCESS_TXT
2312	cycle = (uint32_t)hal_get_cycles();
2313	cxy_t current_cxy = GET_CXY( current_xp );
2314	process_t * current_ptr = GET_PTR( current_xp );
2315	uint32_t new_pid = hal_remote_l32( XPTR( current_cxy , &current_ptr->pid ) );
2316	if( DEBUG_PROCESS_TXT < cycle )
2317	printk("\n[%s] thread[%x,%x] transfered TXT%d ownership to process %x / cycle %d\n",
2318	__FUNCTION__,this->process->pid, this->trdid, txt_id, new_pid, cycle );
2319	#endif
2320	found = true;
2321	}
2322	}
2323
2324	// release lock
2325	remote_busylock_release( lock_xp );
2326
2327	// no more owner for TXT if no other process found
2328	if( found == false )
2329	{
2330	// set owner field in TXT chdev
2331	hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , XPTR_NULL );
2332
2333	#if DEBUG_PROCESS_TXT
2334	cycle = (uint32_t)hal_get_cycles();
2335	if( DEBUG_PROCESS_TXT < cycle )
2336	printk("\n[%s] thread[%x,%x] released TXT%d (no attached process) / cycle %d\n",
2337	__FUNCTION__, this->process->pid, this->trdid, txt_id, cycle );
2338	#endif
2339	}
2340	}
2341	}
2342	else
2343	{
2344
2345	#if DEBUG_PROCESS_TXT
2346	cycle = (uint32_t)hal_get_cycles();
2347	if( DEBUG_PROCESS_TXT < cycle )
2348	printk("\n[%s] thread[%x,%x] does nothing for process %x (not TXT owner) / cycle %d\n",
2349	__FUNCTION__, this->process->pid, this->trdid, process_pid, cycle );
2350	#endif
2351
2352	}
2353
2354	} // end process_txt_transfer_ownership()
2355
2356
2357	////////////////////////////////////////////////
2358	bool_t process_txt_is_owner( xptr_t process_xp )
2359	{
2360	// get local pointer and cluster of process in owner cluster
2361	cxy_t process_cxy = GET_CXY( process_xp );
2362	process_t * process_ptr = GET_PTR( process_xp );
2363
2364	// check calling thread execute in target process owner cluster
2365	pid_t process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
2366	assert( (process_cxy == CXY_FROM_PID( process_pid )) ,
2367	"process descriptor not in owner cluster" );
2368
2369	// get extended pointer on stdin pseudo file
2370	xptr_t file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
2371
2372	// get pointers on TXT chdev
2373	xptr_t txt_xp = chdev_from_file( file_xp );
2374	cxy_t txt_cxy = GET_CXY( txt_xp );
2375	chdev_t * txt_ptr = GET_PTR( txt_xp );
2376
2377	// get extended pointer on TXT_RX owner process
2378	xptr_t owner_xp = hal_remote_l64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
2379
2380	return (process_xp == owner_xp);
2381
2382	} // end process_txt_is_owner()
2383
2384	////////////////////////////////////////////////
2385	xptr_t process_txt_get_owner( uint32_t channel )
2386	{
2387	xptr_t txt_rx_xp = chdev_dir.txt_rx[channel];
2388	cxy_t txt_rx_cxy = GET_CXY( txt_rx_xp );
2389	chdev_t * txt_rx_ptr = GET_PTR( txt_rx_xp );
2390
2391	return (xptr_t)hal_remote_l64( XPTR( txt_rx_cxy , &txt_rx_ptr->ext.txt.owner_xp ) );
2392
2393	} // end process_txt_get_owner()
2394
2395	///////////////////////////////////////////
2396	void process_txt_display( uint32_t txt_id )
2397	{
2398	xptr_t chdev_xp;
2399	cxy_t chdev_cxy;
2400	chdev_t * chdev_ptr;
2401	xptr_t root_xp;
2402	xptr_t lock_xp;
2403	xptr_t current_xp;
2404	xptr_t iter_xp;
2405	cxy_t txt0_cxy;
2406	chdev_t * txt0_ptr;
2407	xptr_t txt0_xp;
2408	xptr_t txt0_lock_xp;
2409
2410	assert( (txt_id < LOCAL_CLUSTER->nb_txt_channels) ,
2411	"illegal TXT terminal index" );
2412
2413	// get pointers on TXT0 chdev
2414	txt0_xp = chdev_dir.txt_tx[0];
2415	txt0_cxy = GET_CXY( txt0_xp );
2416	txt0_ptr = GET_PTR( txt0_xp );
2417
2418	// get extended pointer on TXT0 lock
2419	txt0_lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
2420
2421	// get pointers on TXT_RX[txt_id] chdev
2422	chdev_xp = chdev_dir.txt_rx[txt_id];
2423	chdev_cxy = GET_CXY( chdev_xp );
2424	chdev_ptr = GET_PTR( chdev_xp );
2425
2426	// get extended pointer on root & lock of attached process list
2427	root_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.root );
2428	lock_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.lock );
2429
2430	// get lock on attached process list
2431	remote_busylock_acquire( lock_xp );
2432
2433	// get TXT0 lock in busy waiting mode
2434	remote_busylock_acquire( txt0_lock_xp );
2435
2436	// display header
2437	nolock_printk("\n***** processes attached to TXT_%d / cycle %d\n",
2438	txt_id , (uint32_t)hal_get_cycles() );
2439
2440	// scan attached process list
2441	XLIST_FOREACH( root_xp , iter_xp )
2442	{
2443	current_xp = XLIST_ELEMENT( iter_xp , process_t , txt_list );
2444	process_display( current_xp );
2445	}
2446
2447	// release TXT0 lock in busy waiting mode
2448	remote_busylock_release( txt0_lock_xp );
2449
2450	// release lock on attached process list
2451	remote_busylock_release( lock_xp );
2452
2453	} // end process_txt_display

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

Download in other formats: