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

Last change on this file since 459 was 459, checked in by alain, 3 years ago

Introduce the math library, to support the floating point
data used by the multi-thread fft application.
Fix several bugs regarding the FPU context save/restore.
Introduce support for the %f format in printf.

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