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

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

Improve signals.

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