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

Last change on this file since 415 was 415, checked in by alain, 4 years ago

Few bugs.

File size: 48.4 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)
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_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 <list.h>
42#include <string.h>
43#include <scheduler.h>
44#include <remote_spinlock.h>
45#include <dqdt.h>
46#include <cluster.h>
47#include <ppm.h>
48#include <boot_info.h>
49#include <process.h>
50#include <elf.h>
51#include <syscalls.h>
52#include <signal.h>
53
54//////////////////////////////////////////////////////////////////////////////////////////
55// Extern global variables
56//////////////////////////////////////////////////////////////////////////////////////////
57
58extern process_t process_zero;
59
60//////////////////////////////////////////////////////////////////////////////////////////
61// Process initialisation related functions
62//////////////////////////////////////////////////////////////////////////////////////////
63
64///////////////////////////
65process_t * process_alloc()
66{
67        kmem_req_t   req;
68
69    req.type  = KMEM_PROCESS;
70        req.size  = sizeof(process_t);
71        req.flags = AF_KERNEL;
72
73    return (process_t *)kmem_alloc( &req );
74}
75
76////////////////////////////////////////
77void process_free( process_t * process )
78{
79    kmem_req_t  req;
80
81        req.type = KMEM_PROCESS;
82        req.ptr  = process;
83        kmem_free( &req );
84}
85
86/////////////////////////////////////////////
87void process_zero_init( process_t * process )
88{
89    // initialize PID, PPID anf PREF
90    process->pid    = 0;
91    process->ppid   = 0;
92    process->ref_xp = XPTR( local_cxy , process );
93
94    // reset th_tbl[] array as empty
95    uint32_t i;
96    for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
97        {
98        process->th_tbl[i] = NULL;
99    }
100    process->th_nr  = 0;
101    spinlock_init( &process->th_lock );
102
103        hal_fence();
104
105process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
106__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , process->pid );
107
108}  // end process_zero_init()
109
110/////////////////////////////////////////////////
111void process_reference_init( process_t * process,
112                             pid_t       pid,
113                             pid_t       ppid,
114                             xptr_t      model_xp )
115{
116    cxy_t       model_cxy;
117    process_t * model_ptr;
118        error_t     error1;
119        error_t     error2;
120        error_t     error3;
121    xptr_t      stdin_xp;
122    xptr_t      stdout_xp;
123    xptr_t      stderr_xp;
124    uint32_t    stdin_id;
125    uint32_t    stdout_id;
126    uint32_t    stderr_id;
127    error_t     error;
128
129process_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / ppid = %x\n",
130__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid , ppid );
131
132    // get model process cluster and local pointer
133    model_cxy = GET_CXY( model_xp );
134    model_ptr = (process_t *)GET_PTR( model_xp );
135
136    // initialize PID, PPID, and REF
137        process->pid    = pid;
138    process->ppid   = ppid;
139    process->ref_xp = XPTR( local_cxy , process );
140
141    // initialize vmm as empty
142    error = vmm_init( process );
143    assert( (error == 0) , __FUNCTION__ , "cannot initialize VMM\n" );
144 
145
146process_dmsg("\n[DBG] %s : core[%x,%d] / vmm empty for process %x\n", 
147__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
148
149    // initialize fd_array as empty
150    process_fd_init( process );
151
152    // create stdin / stdout / stderr pseudo-files
153    if( ppid == 0 )                                       // process_init
154    {
155        error1 = vfs_open( process,
156                           CONFIG_INIT_STDIN,
157                           O_RDONLY, 
158                           0,                // FIXME chmod
159                           &stdin_xp, 
160                           &stdin_id );
161
162        error2 = vfs_open( process,
163                           CONFIG_INIT_STDOUT,
164                           O_WRONLY, 
165                           0,                // FIXME chmod
166                           &stdout_xp, 
167                           &stdout_id );
168
169        error3 = vfs_open( process,
170                           CONFIG_INIT_STDERR,
171                           O_WRONLY, 
172                           0,                // FIXME chmod
173                           &stderr_xp, 
174                           &stderr_id );
175    }
176    else                                                  // any other process
177    {
178        error1 = vfs_open( process,
179                           CONFIG_USER_STDIN,
180                           O_RDONLY, 
181                           0,                // FIXME chmod
182                           &stdin_xp, 
183                           &stdin_id );
184
185        error2 = vfs_open( process,
186                           CONFIG_USER_STDOUT,
187                           O_WRONLY, 
188                           0,                // FIXME chmod
189                           &stdout_xp, 
190                           &stdout_id );
191
192        error3 = vfs_open( process,
193                           CONFIG_USER_STDERR,
194                           O_WRONLY, 
195                           0,                // FIXME chmod
196                           &stderr_xp, 
197                           &stderr_id );
198    }
199
200    assert( ((error1 == 0) && (error2 == 0) && (error3 == 0)) , __FUNCTION__ ,
201    "cannot open stdin/stdout/stderr pseudo files\n");
202
203    assert( ((stdin_id == 0) && (stdout_id == 1) && (stderr_id == 2)) , __FUNCTION__ ,
204    "bad indexes : stdin %d / stdout %d / stderr %d \n", stdin_id , stdout_id , stderr_id );
205
206    // initialize specific inodes root and cwd
207    process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
208                                                         &model_ptr->vfs_root_xp ) );
209    process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
210                                                         &model_ptr->vfs_cwd_xp ) );
211    vfs_inode_remote_up( process->vfs_root_xp );
212    vfs_inode_remote_up( process->vfs_cwd_xp );
213
214    remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
215
216    // copy all open file descriptors (other than stdin / stdout / stderr)
217    process_fd_remote_copy( XPTR( local_cxy , &process->fd_array ),
218                            XPTR( model_cxy , &model_ptr->fd_array ) );
219
220process_dmsg("\n[DBG] %s : core[%x,%d] / fd array for process %x\n", 
221__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
222
223    // reset children list root
224    xlist_root_init( XPTR( local_cxy , &process->children_root ) );
225    process->children_nr     = 0;
226
227    // reset semaphore / mutex / barrier / condvar list roots
228    xlist_root_init( XPTR( local_cxy , &process->sem_root ) );
229    xlist_root_init( XPTR( local_cxy , &process->mutex_root ) );
230    xlist_root_init( XPTR( local_cxy , &process->barrier_root ) );
231    xlist_root_init( XPTR( local_cxy , &process->condvar_root ) );
232    remote_spinlock_init( XPTR( local_cxy , &process->sync_lock ) );
233
234    // register new process in the local cluster manager pref_tbl[]
235    lpid_t lpid = LPID_FROM_PID( pid );
236    LOCAL_CLUSTER->pmgr.pref_tbl[lpid] = XPTR( local_cxy , process );
237
238    // register new process descriptor in local cluster manager local_list
239    cluster_process_local_link( process );
240
241    // register new process descriptor in local cluster manager copies_list
242    cluster_process_copies_link( process );
243
244    // reset th_tbl[] array as empty in process descriptor
245    uint32_t i;
246    for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
247        {
248        process->th_tbl[i] = NULL;
249    }
250    process->th_nr  = 0;
251    spinlock_init( &process->th_lock );
252
253        hal_fence();
254
255process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
256__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
257
258}  // process_reference init()
259
260/////////////////////////////////////////////////////
261error_t process_copy_init( process_t * local_process,
262                           xptr_t      reference_process_xp )
263{
264    error_t error;
265
266    // get reference process cluster and local pointer
267    cxy_t       ref_cxy = GET_CXY( reference_process_xp );
268    process_t * ref_ptr = (process_t *)GET_PTR( reference_process_xp );
269
270    // set the pid, ppid, ref_xp fields in local process
271    local_process->pid    = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->pid ) );
272    local_process->ppid   = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->ppid ) );
273    local_process->ref_xp = reference_process_xp;
274
275process_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x in cluster %x\n",
276__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , local_process->pid );
277
278    // reset local process vmm
279    error = vmm_init( local_process );
280    assert( (error == 0) , __FUNCTION__ , "cannot initialize VMM\n");
281
282    // reset process file descriptors array
283        process_fd_init( local_process );
284
285    // reset vfs_root_xp / vfs_bin_xp / vfs_cwd_xp fields
286    local_process->vfs_root_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_root_xp ) );
287    local_process->vfs_bin_xp  = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_bin_xp ) );
288    local_process->vfs_cwd_xp  = XPTR_NULL;
289
290    // reset children list root (not used in a process descriptor copy)
291    xlist_root_init( XPTR( local_cxy , &local_process->children_root ) );
292    local_process->children_nr   = 0;
293
294    // reset brothers list (not used in a process descriptor copy)
295    xlist_entry_init( XPTR( local_cxy , &local_process->brothers_list ) );
296
297    // reset semaphores list root (not used in a process descriptor copy)
298    xlist_root_init( XPTR( local_cxy , &local_process->sem_root ) );
299    xlist_root_init( XPTR( local_cxy , &local_process->mutex_root ) );
300    xlist_root_init( XPTR( local_cxy , &local_process->barrier_root ) );
301    xlist_root_init( XPTR( local_cxy , &local_process->condvar_root ) );
302
303    // reset th_tbl[] array as empty
304    uint32_t i;
305    for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
306        {
307        local_process->th_tbl[i] = NULL;
308    }
309    local_process->th_nr  = 0;
310    spinlock_init( &local_process->th_lock );
311
312    // register new process descriptor in local cluster manager local_list
313    cluster_process_local_link( local_process );
314
315    // register new process descriptor in owner cluster manager copies_list
316    cluster_process_copies_link( local_process );
317
318        hal_fence();
319
320process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x in cluster %x\n",
321__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , local_process->pid );
322
323    return 0;
324
325} // end process_copy_init()
326
327///////////////////////////////////////////
328void process_destroy( process_t * process )
329{
330        if( process->th_nr != 0 )
331    {
332        panic("process %x in cluster %x has still active threads",
333              process->pid , local_cxy );
334    }
335
336    // get local process manager pointer
337    pmgr_t * pmgr = &LOCAL_CLUSTER->pmgr;
338
339    // get the lock protecting the list of local process descriptors
340    remote_spinlock_lock( XPTR( local_cxy , &pmgr->local_lock ) );
341
342    // remove the process descriptor from local_list in local cluster manager
343    xlist_unlink( XPTR( local_cxy , &process->local_list ) );
344
345    // release the lock protecting the list of local process descriptors
346    remote_spinlock_unlock( XPTR( local_cxy , &pmgr->local_lock ) );
347
348    // get extended pointer on copies_lock in owner cluster manager
349    cxy_t  owner_cxy    = CXY_FROM_PID( process->pid );
350        lpid_t lpid         = LPID_FROM_PID( process->pid );
351    xptr_t copies_lock  = XPTR( owner_cxy , &pmgr->copies_lock[lpid] );
352
353    // remove the local process descriptor from copies_list
354    remote_spinlock_lock( copies_lock );
355    xlist_unlink( XPTR( local_cxy , &process->copies_list ) );
356    remote_spinlock_unlock( copies_lock );
357
358        hal_fence();
359
360    // From this point, the process descriptor is unreachable
361
362    // FIXME close all open files and update dirty [AG]
363
364    // Decrease refcount for bin file, root file and cwd file
365        if( process->vfs_bin_xp  != XPTR_NULL ) vfs_file_count_down( process->vfs_bin_xp );
366        if( process->vfs_root_xp != XPTR_NULL ) vfs_file_count_down( process->vfs_root_xp );
367        if( process->vfs_cwd_xp  != XPTR_NULL ) vfs_file_count_down( process->vfs_cwd_xp );
368
369    // Destroy VMM
370    vmm_destroy( process );
371
372        process_dmsg("\n[DBG] %s for pid %d / page_faults = %d\n",
373                 __FUNCTION__ , process->pid, process->vmm.pgfault_nr );
374
375}  // end process_destroy()
376
377/////////////////////////////////////////////////
378char * process_action_str( uint32_t action_type )
379{
380    if     ( action_type == BLOCK_ALL_THREADS   ) return "BLOCK";
381    else if( action_type == UNBLOCK_ALL_THREADS ) return "UNBLOCK";
382    else if( action_type == DELETE_ALL_THREADS  ) return "DELETE";
383    else                                          return "undefined";
384}
385
386////////////////////////////////////////////
387void process_sigaction( process_t * process,
388                        uint32_t    action_type )
389{
390    cxy_t              owner_cxy;         // owner cluster identifier
391    lpid_t             lpid;              // process index in owner cluster
392    cluster_t        * cluster;           // pointer on cluster manager
393    xptr_t             root_xp;           // extended pointer on root of copies
394    xptr_t             lock_xp;           // extended pointer on lock protecting copies
395    xptr_t             client_xp;         // extended pointer on client thread
396    uint32_t           rsp_count;         // number of expected responses
397    xptr_t             rsp_xp;            // extended pointer on responses counter
398    xptr_t             iter_xp;           // iterator on copies list
399    xptr_t             process_xp;        // extended pointer on process copy
400    cxy_t              process_cxy;       // process copy cluster identifier
401    process_t        * process_ptr;       // local pointer on process copy
402
403sigaction_dmsg("\n[DBG] %s : enter for signal %s to process %x in cluster %x\n",
404__FUNCTION__ , process_action_str( action_type ) , process , local_cxy );
405
406    thread_t         * this = CURRENT_THREAD;
407
408    // get extended pointer on client thread and response counter
409    client_xp = XPTR( local_cxy , this );
410    rsp_xp    = XPTR( local_cxy , &rsp_count );
411
412    // get owner cluster identifier and process lpid
413    owner_cxy = CXY_FROM_PID( process->pid );
414    lpid      = LPID_FROM_PID( process->pid );
415
416    assert( (owner_cxy == local_cxy) , __FUNCTION__ , "illegal cluster\n" ); 
417   
418    // get local pointer on local cluster manager
419    cluster = LOCAL_CLUSTER;
420
421    // get extended pointers on copies root, copies lock, and number of copies
422    root_xp   = XPTR( local_cxy , &cluster->pmgr.copies_root[lpid] );
423    lock_xp   = XPTR( local_cxy , &cluster->pmgr.copies_lock[lpid] );
424
425    // initialize responses number
426    rsp_count = cluster->pmgr.copies_nr[lpid];
427
428    // take the lock protecting the copies
429    remote_spinlock_lock( lock_xp );
430
431    // send RPCs to all process copies
432    XLIST_FOREACH( root_xp , iter_xp )
433    {
434        process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
435        process_cxy = GET_CXY( process_xp );
436        process_ptr = (process_t *)GET_PTR( process_xp );
437
438sigaction_dmsg("\n[DBG] %s : process = %x / pid = %x / ppid = %x\n",
439__FUNCTION__ , process_ptr , process_ptr->pid , process_ptr->ppid );
440
441        rpc_process_sigaction_client( process_cxy, 
442                                      process_ptr,
443                                      action_type,
444                                      rsp_xp,
445                                      client_xp );
446    }
447   
448    // release the lock protecting process copies
449    remote_spinlock_unlock( lock_xp );
450
451    // block and deschedule to wait response
452    thread_block( CURRENT_THREAD , THREAD_BLOCKED_RPC );
453    sched_yield("BLOCKED on RPC");
454
455sigaction_dmsg("\n[DBG] %s : exit for signal %s to process %x in cluster %x\n",
456__FUNCTION__ , process_action_str( action_type ) , process , local_cxy );
457
458}  // end process_sigaction()
459
460////////////////////////////////////////
461void process_block( process_t * process,
462                    xptr_t      rsp_xp,
463                    xptr_t      client_xp )
464{
465    thread_t          * target;         // pointer on target thread
466    uint32_t            ltid;           // index in process th_tbl
467    thread_t          * killer;         // killer thread pointer
468    uint32_t            count;          // requests counter
469    volatile uint32_t   sig_rsp_count;  // responses counter
470    cxy_t               client_cxy;     // client thread cluster identifier
471    thread_t          * client_ptr;     // client thread pointer
472    core_t            * client_core;    // client thread core pointer
473
474    // get local killer thread pointer
475    killer = CURRENT_THREAD;
476
477sigaction_dmsg("\n[DBG] %s : enter for process %x in cluster %x\n",
478__FUNCTION__ , process->pid , local_cxy );
479
480    // get lock protecting process th_tbl[]
481    spinlock_lock( &process->th_lock );
482
483    // initialize local responses counter
484    sig_rsp_count = process->th_nr;
485
486    // loop on process threads to block and deschedule all threads in cluster
487    // we use both "ltid" and "count" because it can exist "holes" in th_tbl
488    for( ltid = 0 , count = 0 ; count < process->th_nr ; ltid++ )
489    {
490        target = process->th_tbl[ltid];
491
492        if( target != NULL )             // thread found
493        {
494            count++;
495
496            // set signal in target thread descriptor
497            thread_set_signal( target , (uint32_t *)sig_rsp_count );
498
499            // set the global blocked bit in target thread descriptor.
500            thread_block( target , THREAD_BLOCKED_GLOBAL );
501
502            // - if the killer thread and the target thread are not on the same core
503            //   we want the scheduler of target thread to acknowlege the signal
504            //   to be sure that the target thread is descheduled
505            // - if the killer thread and the target thread are on the same core
506            //   we simply decrement the response counter.
507            if( killer->core->lid != target->core->lid )
508            {
509                dev_pic_send_ipi( local_cxy , target->core->lid );
510            }
511            else                                                         
512            {
513                hal_atomic_add( (void *)&sig_rsp_count , -1 );
514            }
515        }
516    }
517
518    // poll the reponses counter
519    while( 1 )
520    {
521        // exit loop when all responses received
522        if ( sig_rsp_count == 0 ) break;
523   
524        // wait 1000 cycles before retry
525        hal_fixed_delay( 1000 );
526    }
527
528    // acknowledge client thread & unblock client thread if last response
529    client_cxy  = GET_CXY( client_xp );
530    client_ptr  = (thread_t *)GET_PTR( client_xp );
531    client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
532    if( hal_remote_atomic_add( rsp_xp , -1 ) == 1 ) 
533    {
534        thread_unblock( client_xp , THREAD_BLOCKED_RPC);
535        dev_pic_send_ipi( client_cxy , client_core->lid );
536    }
537
538sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x / %d threads blocked\n",
539__FUNCTION__ , process->pid , local_cxy , count );
540
541}  // end process_block()
542
543//////////////////////////////////////////
544void process_unblock( process_t * process,
545                      xptr_t      rsp_xp,
546                      xptr_t      client_xp )
547{
548    thread_t          * target;        // pointer on target thead
549    uint32_t            ltid;          // index in process th_tbl
550    thread_t          * killer;        // killer thread pointer
551    uint32_t            req_count;     // requests counter
552    cxy_t               client_cxy;    // client thread cluster identifier
553    thread_t          * client_ptr;    // client thread pointer
554    core_t            * client_core;   // client thread core pointer
555
556    // get local killer thread pointer
557    killer = CURRENT_THREAD;
558
559sigaction_dmsg("\n[DBG] %s : enter for process %x in cluster %x\n",
560__FUNCTION__ , process->pid , local_cxy );
561
562    // get lock protecting process th_tbl[]
563    spinlock_lock( &process->th_lock );
564
565    // loop on process threads to unblock all threads in cluster
566    // we use both "ltid" and "req_count" because it can exist "holes" in th_tbl
567    for( ltid = 0 , req_count = 0 ;
568         req_count < process->th_nr ;
569         ltid++ )
570    {
571        target = process->th_tbl[ltid];
572
573        if( target != NULL )             // thread found
574        {
575            req_count++;
576
577            // reset the global blocked bit in target thread descriptor.
578            thread_unblock( XPTR( local_cxy , target ) , THREAD_BLOCKED_GLOBAL );
579        }
580    }
581
582    // acknowledge client thread & unblock client thread if last response
583    client_cxy  = GET_CXY( client_xp );
584    client_ptr  = (thread_t *)GET_PTR( client_xp );
585    client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
586    if( hal_remote_atomic_add( rsp_xp , -1 ) == 1 ) 
587    {
588        thread_unblock( client_xp , THREAD_BLOCKED_RPC);
589        dev_pic_send_ipi( client_cxy , client_core->lid );
590    }
591
592sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x / %d threads blocked\n",
593__FUNCTION__ , process->pid , local_cxy , req_count );
594
595}  // end process_unblock()
596
597/////////////////////////////////////////
598void process_delete( process_t * process,
599                     xptr_t      rsp_xp,
600                     xptr_t      client_xp )
601{
602    thread_t          * thread;        // pointer on target thread
603    uint32_t            ltid;          // index in process th_tbl
604    uint32_t            count;         // request counter
605    pid_t               pid;           // process PID
606    cxy_t               client_cxy;    // client thread cluster identifier
607    thread_t          * client_ptr;    // client thread pointer
608    core_t            * client_core;   // client thread core pointer
609
610    // get process PID
611    pid = process->pid;
612
613sigaction_dmsg("\n[DBG] %s : enter for process %x in cluster %x at cycle %d\n",
614__FUNCTION__ , pid , local_cxy , (uint32_t)hal_get_cycles() );
615
616    // loop on threads to release memory allocated to threads
617    for( ltid = 0 , count = 0  ; count < process->th_nr ; ltid++ )
618    {
619        thread = process->th_tbl[ltid];
620
621        if( thread != NULL )             // thread found
622        {
623            count++;
624
625            // detach thread from parent if attached
626            if( (thread->flags & THREAD_FLAG_DETACHED) == 0 ) 
627            thread_child_parent_unlink( thread->parent , XPTR( local_cxy , thread ) );
628
629            // detach thread from process
630            process_remove_thread( thread );
631
632            // remove thread from scheduler
633            sched_remove_thread( thread );
634
635            // release memory allocated to thread
636            thread_destroy( thread );
637        }
638    }
639
640    // release memory allocated to process descriptors
641    // for all clusters other than the owner cluster
642    if( local_cxy != CXY_FROM_PID( process->pid ) ) process_destroy( process );
643
644    // acknowledge client thread & unblock client thread if last response
645    client_cxy  = GET_CXY( client_xp );
646    client_ptr  = (thread_t *)GET_PTR( client_xp );
647    client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
648    if( hal_remote_atomic_add( rsp_xp , -1 ) == 1 ) 
649    {
650        thread_unblock( client_xp , THREAD_BLOCKED_RPC);
651        dev_pic_send_ipi( client_cxy , client_core->lid );
652    }
653
654sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x at cycle %d\n",
655__FUNCTION__ , pid , local_cxy , (uint32_t)hal_get_cycles() );
656
657}  // end process_delete()
658
659///////////////////////////////////////////////
660process_t * process_get_local_copy( pid_t pid )
661{
662    error_t        error;
663    process_t    * process_ptr;   // local pointer on process
664    xptr_t         process_xp;    // extended pointer on process
665
666    cluster_t * cluster = LOCAL_CLUSTER;
667
668    // get lock protecting local list of processes
669    remote_spinlock_lock( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
670
671    // scan the local list of process descriptors to find the process
672    xptr_t  iter;
673    bool_t  found = false;
674    XLIST_FOREACH( XPTR( local_cxy , &cluster->pmgr.local_root ) , iter )
675    {
676        process_xp  = XLIST_ELEMENT( iter , process_t , local_list );
677        process_ptr = (process_t *)GET_PTR( process_xp );
678        if( process_ptr->pid == pid )
679        {
680            found = true;
681            break;
682        }
683    }
684
685    // release lock protecting local list of processes
686    remote_spinlock_unlock( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
687
688    // allocate memory for a new local process descriptor
689    // and initialise it from reference cluster if required
690    if( !found )
691    {
692        // get extended pointer on reference process descriptor
693        xptr_t ref_xp = cluster_get_reference_process_from_pid( pid );
694
695        assert( (ref_xp != XPTR_NULL) , __FUNCTION__ , "illegal pid\n" );
696
697        // allocate memory for local process descriptor
698        process_ptr = process_alloc();
699        if( process_ptr == NULL )  return NULL;
700
701        // initialize local process descriptor copy
702        error = process_copy_init( process_ptr , ref_xp );
703        if( error ) return NULL;
704    }
705
706    return process_ptr;
707
708}  // end process_get_local_copy()
709
710//////////////////////////////////////////////////////////////////////////////////////////
711// File descriptor array related functions
712//////////////////////////////////////////////////////////////////////////////////////////
713
714///////////////////////////////////////////
715void process_fd_init( process_t * process )
716{
717    uint32_t fd;
718
719    remote_spinlock_init( XPTR( local_cxy , &process->fd_array.lock ) );
720
721    process->fd_array.current = 0;
722
723    // initialize array
724    for ( fd = 0 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
725    {
726        process->fd_array.array[fd] = XPTR_NULL;
727    }
728}
729
730//////////////////////////////
731bool_t process_fd_array_full()
732{
733    // get extended pointer on reference process
734    xptr_t ref_xp = CURRENT_THREAD->process->ref_xp;
735
736    // get reference process cluster and local pointer
737    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
738    cxy_t       ref_cxy = GET_CXY( ref_xp );
739
740    // get number of open file descriptors from reference fd_array
741    uint32_t current = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->fd_array.current ) );
742
743        return ( current >= CONFIG_PROCESS_FILE_MAX_NR );
744}
745
746/////////////////////////////////////////////////
747error_t process_fd_register( process_t * process,
748                             xptr_t      file_xp,
749                             uint32_t  * fdid )
750{
751    bool_t    found;
752    uint32_t  id;
753    xptr_t    xp;
754
755    // get reference process cluster and local pointer
756    xptr_t ref_xp = process->ref_xp;
757    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
758    cxy_t       ref_cxy = GET_CXY( ref_xp );
759
760    // take lock protecting reference fd_array
761        remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->fd_array.lock ) );
762
763    found   = false;
764
765    for ( id = 0; id < CONFIG_PROCESS_FILE_MAX_NR ; id++ )
766    {
767        xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->fd_array.array[id] ) );
768        if ( xp == XPTR_NULL )
769        {
770            found = true;
771            hal_remote_swd( XPTR( ref_cxy , &ref_ptr->fd_array.array[id] ) , file_xp );
772                hal_remote_atomic_add( XPTR( ref_cxy , &ref_ptr->fd_array.current ) , 1 );
773                        *fdid = id;
774            break;
775        }
776    }
777
778    // release lock protecting reference fd_array
779        remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->fd_array.lock ) );
780
781    if ( !found ) return EMFILE;
782    else          return 0;
783}
784
785////////////////////////////////////////////////
786xptr_t process_fd_get_xptr( process_t * process,
787                            uint32_t    fdid )
788{
789    xptr_t  file_xp;
790
791    // access local copy of process descriptor
792    file_xp = process->fd_array.array[fdid];
793
794    if( file_xp == XPTR_NULL )
795    {
796        // get reference process cluster and local pointer
797        xptr_t      ref_xp  = process->ref_xp;
798        cxy_t       ref_cxy = GET_CXY( ref_xp );
799        process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
800
801        // access reference process descriptor
802        file_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->fd_array.array[fdid] ) );
803
804        // update local fd_array if found
805        if( file_xp != XPTR_NULL )
806        {
807            process->fd_array.array[fdid] = file_xp;
808        }
809    }
810
811    return file_xp;
812
813}  // end process_fd_get_xptr()
814
815///////////////////////////////////////////
816void process_fd_remote_copy( xptr_t dst_xp,
817                             xptr_t src_xp )
818{
819    uint32_t fd;
820    xptr_t   entry;
821
822    // get cluster and local pointer for src fd_array
823    cxy_t        src_cxy = GET_CXY( src_xp );
824    fd_array_t * src_ptr = (fd_array_t *)GET_PTR( src_xp );
825
826    // get cluster and local pointer for dst fd_array
827    cxy_t        dst_cxy = GET_CXY( dst_xp );
828    fd_array_t * dst_ptr = (fd_array_t *)GET_PTR( dst_xp );
829
830    // get the remote lock protecting the src fd_array
831        remote_spinlock_lock( XPTR( src_cxy , &src_ptr->lock ) );
832
833    // loop on all entries other than
834    // the three first entries: stdin/stdout/stderr
835    for( fd = 3 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
836        {
837                entry = (xptr_t)hal_remote_lwd( XPTR( src_cxy , &src_ptr->array[fd] ) );
838
839                if( entry != XPTR_NULL )
840                {
841            // increment file descriptor ref count
842            vfs_file_count_up( entry );
843
844                        // copy entry in destination process fd_array
845                        hal_remote_swd( XPTR( dst_cxy , &dst_ptr->array[fd] ) , entry );
846                }
847        }
848
849    // release lock on source process fd_array
850        remote_spinlock_unlock( XPTR( src_cxy , &src_ptr->lock ) );
851
852}  // end process_fd_remote_copy()
853
854////////////////////////////////////////////////////////////////////////////////////
855//  Thread related functions
856////////////////////////////////////////////////////////////////////////////////////
857
858/////////////////////////////////////////////////////
859error_t process_register_thread( process_t * process,
860                                 thread_t  * thread,
861                                 trdid_t   * trdid )
862{
863    ltid_t   ltid;
864    bool_t   found;
865
866    assert( (process != NULL) , __FUNCTION__ , "process argument is NULL" );
867
868    assert( (thread != NULL) , __FUNCTION__ , "thread argument is NULL" );
869
870    // search a free slot in th_tbl[]
871    // 0 is not a valid ltid value
872    found = false;
873    for( ltid = 1 ; ltid < CONFIG_THREAD_MAX_PER_CLUSTER ; ltid++ )
874    {
875        if( process->th_tbl[ltid] == NULL )
876        {
877            found = true;
878            break;
879        }
880    }
881
882    if( found )
883    {
884        // register thread in th_tbl[]
885        process->th_tbl[ltid] = thread;
886        process->th_nr++;
887
888        // returns trdid
889        *trdid = TRDID( local_cxy , ltid );
890    }
891
892    return (found) ? 0 : ENOMEM;
893
894}  // end process_register_thread()
895
896///////////////////////////////////////////////
897void process_remove_thread( thread_t * thread )
898{
899    assert( (thread != NULL) , __FUNCTION__ , "thread argument is NULL" );
900
901    process_t * process = thread->process;
902
903    // get thread local index
904    ltid_t  ltid = LTID_FROM_TRDID( thread->trdid );
905
906    // remove thread from th_tbl[]
907    process->th_tbl[ltid] = NULL;
908    process->th_nr--;
909
910}  // process_remove_thread()
911
912/////////////////////////////////////////////////////////
913error_t process_make_fork( xptr_t      parent_process_xp,
914                           xptr_t      parent_thread_xp,
915                           pid_t     * child_pid,
916                           thread_t ** child_thread )
917{
918    process_t * process;         // local pointer on child process descriptor
919    thread_t  * thread;          // local pointer on child thread descriptor
920    pid_t       new_pid;         // process identifier for child process
921    pid_t       parent_pid;      // process identifier for parent process
922    xptr_t      ref_xp;          // extended pointer on reference process
923    error_t     error;
924
925    // get cluster and local pointer for parent process
926    cxy_t       parent_process_cxy = GET_CXY( parent_process_xp );
927    process_t * parent_process_ptr = (process_t *)GET_PTR( parent_process_xp );
928
929    // get parent process PID
930    parent_pid = hal_remote_lw( XPTR( parent_process_cxy , &parent_process_ptr->pid ) );
931   
932    // check parent process is the reference
933    ref_xp = hal_remote_lwd( XPTR( parent_process_cxy , &parent_process_ptr->ref_xp ) );
934    assert( (parent_process_xp == ref_xp ) , __FUNCTION__ ,
935    "parent process must be the reference process\n" );
936
937fork_dmsg("\n[DBG] %s : core[%x,%d] enter at cycle %d\n",
938__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid , (uint32_t)hal_get_cycles() );
939
940    // allocate a process descriptor
941    process = process_alloc();
942    if( process == NULL )
943    {
944        printk("\n[ERROR] in %s : cannot get process in cluster %x\n", 
945        __FUNCTION__, local_cxy ); 
946        return -1;
947    }
948
949fork_dmsg("\n[DBG] %s : core[%x,%d] child process descriptor allocated at cycle %d\n",
950 __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
951
952    // allocate a child PID from local cluster
953    error = cluster_pid_alloc( XPTR( local_cxy , process ) , &new_pid );
954    if( (error != 0) || (new_pid == 0) )
955    {
956        printk("\n[ERROR] in %s : cannot get PID in cluster %x\n", 
957        __FUNCTION__, local_cxy ); 
958        process_free( process );
959        return -1;
960    }
961
962fork_dmsg("\n[DBG] %s : core[%x, %d] child process PID allocated = %x at cycle %d\n",
963 __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, new_pid , (uint32_t)hal_get_cycles() );
964
965    // initializes child process descriptor from parent process descriptor
966    process_reference_init( process,
967                            new_pid,
968                            parent_pid,
969                            parent_process_xp );
970
971fork_dmsg("\n[DBG] %s : core[%x, %d] child process initialised at cycle %d\n",
972__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
973
974    // copy VMM from parent descriptor to child descriptor
975    error = vmm_fork_copy( process,
976                           parent_process_xp );
977    if( error )
978    {
979        printk("\n[ERROR] in %s : cannot copy VMM in cluster %x\n", 
980        __FUNCTION__, local_cxy ); 
981        process_free( process );
982        cluster_pid_release( new_pid );
983        return -1;
984    }
985
986fork_dmsg("\n[DBG] %s : core[%x, %d] child process VMM copied at cycle %d\n",
987__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
988
989    // create child thread descriptor from parent thread descriptor
990    error = thread_user_fork( parent_thread_xp,
991                              process,
992                              &thread );
993    if( error )
994    {
995        printk("\n[ERROR] in %s : cannot create thread in cluster %x\n",
996        __FUNCTION__, local_cxy ); 
997        process_free( process );
998        cluster_pid_release( new_pid );
999        return -1;
1000    }
1001
1002fork_dmsg("\n[DBG] %s : core[%x,%d] child thread created at cycle %d\n", 
1003__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
1004
1005    // update parent process GPT to set Copy_On_Write for shared data vsegs
1006    // this includes all replicated GPT copies
1007    if( parent_process_cxy == local_cxy )   // reference is local
1008    {
1009        vmm_set_cow( parent_process_ptr );
1010    }
1011    else                                    // reference is remote
1012    {
1013        rpc_vmm_set_cow_client( parent_process_cxy,
1014                                parent_process_ptr );
1015    }
1016
1017fork_dmsg("\n[DBG] %s : core[%x,%d] COW set in parent_process at cycle %d\n",
1018__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
1019
1020    // update children list in parent process
1021        xlist_add_last( XPTR( parent_process_cxy , &parent_process_ptr->children_root ),
1022                    XPTR( local_cxy , &process->brothers_list ) );
1023        hal_remote_atomic_add( XPTR( parent_process_cxy,
1024                                 &parent_process_ptr->children_nr), 1 );
1025
1026// vmm_display( process , true );
1027// vmm_display( parent_process_ptr , true );
1028// sched_display( 0 );
1029
1030    // return success
1031    *child_thread = thread;
1032    *child_pid    = new_pid;
1033
1034fork_dmsg("\n[DBG] %s : core[%x,%d] exit at cycle %d\n",
1035__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
1036
1037    return 0;
1038
1039}  // end process_make_fork()
1040
1041/*  deprecated because we don't wand to destroy the existing process descriptor
1042
1043/////////////////////////////////////////////////////
1044error_t process_make_exec( exec_info_t  * exec_info )
1045{
1046    char           * path;                    // pathname to .elf file
1047    process_t      * old;                     // local pointer on old process
1048    process_t      * new;                     // local pointer on new process
1049    pid_t            pid;                     // old process identifier
1050    thread_t       * thread;                  // pointer on new thread
1051    pthread_attr_t   attr;                    // main thread attributes
1052    lid_t            lid;                     // selected core local index
1053        error_t          error;
1054
1055        // get .elf pathname and PID from exec_info
1056        path = exec_info->path;
1057    pid  = exec_info->pid;
1058
1059    // check local cluster is process owner
1060    assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
1061    "local cluster %x is not owner for process %x\n", local_cxy, pid );
1062
1063exec_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / path = %s\n",
1064__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid , path );
1065
1066    // get old process local pointer
1067    old = (process_t *)cluster_get_local_process_from_pid( pid );
1068   
1069    assert( (old != NULL ) , __FUNCTION__ ,
1070    "process %x not found in cluster %x\n", pid , local_cxy );
1071
1072    // allocate memory for new process descriptor
1073    new = process_alloc();
1074
1075    // initialize new process descriptor
1076    process_reference_init( new,
1077                            old->pid,                   // same as old
1078                            old->ppid,                  // same as old
1079                            XPTR( local_cxy , old ) );
1080
1081exec_dmsg("\n[DBG] %s : core[%x,%d] created new process %x / path = %s\n",
1082__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
1083
1084    // register "code" and "data" vsegs as well as entry-point
1085    // in new process VMM, using information contained in the elf file.
1086        if( elf_load_process( path , new ) )
1087        {
1088                printk("\n[ERROR] in %s : failed to access .elf file for process %x / path = %s\n",
1089                __FUNCTION__, pid , path );
1090        process_destroy( new );
1091        return -1;
1092        }
1093
1094exec_dmsg("\n[DBG] %s : core[%x,%d] vsegs registered / path = %s\n",
1095__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path );
1096
1097    // select a core in local cluster to execute the main thread
1098    lid  = cluster_select_local_core();
1099
1100    // initialize pthread attributes for main thread
1101    attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED | PT_ATTR_CORE_DEFINED;
1102    attr.cxy        = local_cxy;
1103    attr.lid        = lid;
1104
1105    // create and initialize thread descriptor
1106        error = thread_user_create( pid,
1107                                (void *)new->vmm.entry_point,
1108                                exec_info->args_pointers,
1109                                &attr,
1110                                &thread );
1111        if( error )
1112        {
1113                printk("\n[ERROR] in %s : cannot create thread for process %x / path = %s\n",
1114                       __FUNCTION__, pid , path );
1115        process_destroy( new );
1116        return -1;
1117        }
1118
1119exec_dmsg("\n[DBG] %s : core[%x,%d] created main thread %x for new process %x\n",
1120__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, thread->trdid, pid );
1121
1122    // update children list (rooted in parent process)
1123        xlist_replace( XPTR( local_cxy , &old->brothers_list ) ,
1124                   XPTR( local_cxy , &new->brothers_list ) );
1125
1126    // request destruction of old process copies and threads in all clusters
1127    process_sigaction( old , SIGKILL );
1128
1129    // activate new thread
1130        thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
1131
1132exec_dmsg("\n[DBG] %s : core[%x,%d] exit for path = %s\n",
1133__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path  );
1134
1135        return 0;
1136
1137}  // end process_make_exec()
1138
1139*/
1140
1141/////////////////////////////////////////////////////
1142error_t process_make_exec( exec_info_t  * exec_info )
1143{
1144    char           * path;                    // pathname to .elf file
1145    process_t      * process;                 // local pointer on old process
1146    pid_t            pid;                     // old process identifier
1147    thread_t       * thread;                  // pointer on new main thread
1148    pthread_attr_t   attr;                    // main thread attributes
1149    lid_t            lid;                     // selected core local index
1150        error_t          error;
1151
1152        // get .elf pathname and PID from exec_info
1153        path = exec_info->path;
1154    pid  = exec_info->pid;
1155
1156    // check local cluster is process owner
1157    assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
1158    "local cluster %x is not owner for process %x\n", local_cxy, pid );
1159
1160exec_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / path = %s\n",
1161__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid , path );
1162
1163    // get process local pointer
1164    process = (process_t *)cluster_get_local_process_from_pid( pid );
1165   
1166    assert( (process != NULL ) , __FUNCTION__ , 
1167    "process %x not found in cluster %x\n", pid , local_cxy ); 
1168
1169    // reset the existing vmm
1170    vmm_destroy( process );
1171
1172exec_dmsg("\n[DBG] %s : core[%x,%d] VMM cleared\n",
1173__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid );
1174
1175    // block all existing process threads
1176    process_sigaction( process , BLOCK_ALL_THREADS );
1177
1178    // kill all existing threads and process descriptors (other than owner)
1179    process_sigaction( process , DELETE_ALL_THREADS );
1180
1181    // check no threads
1182    assert( (process->th_nr == 0) , __FUNCTION__ , "no threads at this point" );
1183
1184exec_dmsg("\n[DBG] %s : core[%x,%d] all threads deleted\n",
1185__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid );
1186
1187    // initialize VMM
1188    error = vmm_init( process );
1189        {
1190                printk("\n[ERROR] in %s : cannot initialize VMM for process %x / path = %s\n",
1191                __FUNCTION__, pid , path );
1192        process_destroy( process );
1193        return -1;
1194        }
1195
1196    if( error )
1197
1198    // register "code" and "data" vsegs as well as entry-point and vfs_bin_xp
1199    // in VMM, using information contained in the elf file.
1200        error = elf_load_process( path , process );
1201
1202    if( error )
1203        {
1204                printk("\n[ERROR] in %s : failed to access .elf file for process %x / path = %s\n",
1205                __FUNCTION__, pid , path );
1206        process_destroy( process );
1207        return -1;
1208        }
1209
1210exec_dmsg("\n[DBG] %s : core[%x,%d] new vsegs registered / path = %s\n",
1211__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path );
1212
1213// @@@
1214vmm_display( process , true );
1215// @@@
1216
1217    // select a core in local cluster to execute the new main thread
1218    lid  = cluster_select_local_core();
1219
1220    // initialize pthread attributes for new main thread
1221    attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED | PT_ATTR_CORE_DEFINED;
1222    attr.cxy        = local_cxy;
1223    attr.lid        = lid;
1224
1225    // create and initialize thread descriptor
1226        error = thread_user_create( pid,
1227                                (void *)process->vmm.entry_point,
1228                                exec_info->args_pointers,
1229                                &attr,
1230                                &thread );
1231        if( error )
1232        {
1233                printk("\n[ERROR] in %s : cannot create thread for process %x / path = %s\n",
1234                       __FUNCTION__, pid , path );
1235        process_destroy( process );
1236        return -1;
1237        }
1238
1239exec_dmsg("\n[DBG] %s : core[%x,%d] created main thread %x for new process %x\n",
1240__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, thread->trdid, pid );
1241
1242    // activate new thread
1243        thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
1244
1245exec_dmsg("\n[DBG] %s : core[%x,%d] exit for path = %s\n",
1246__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path  );
1247
1248        return 0;
1249
1250}  // end process_make_exec()
1251
1252////////////////////////////////////////////
1253void process_make_kill( process_t * process,
1254                        uint32_t    sig_id )
1255{
1256    // this function must be executed by a thread running in owner cluster
1257    assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
1258    "must execute in owner cluster" );
1259
1260    // analyse signal type
1261    switch( sig_id )
1262    {
1263        case SIGSTOP:     // block all threads
1264        {
1265            process_sigaction( process , BLOCK_ALL_THREADS );
1266        }
1267        break;
1268        case SIGCONT:     // unblock all threads
1269        {
1270            process_sigaction( process , UNBLOCK_ALL_THREADS );
1271        }
1272        break;
1273        case SIGKILL:  // block all threads, then delete all threads
1274        {
1275            process_sigaction( process , BLOCK_ALL_THREADS );
1276            process_sigaction( process , DELETE_ALL_THREADS );
1277            process_destroy( process );
1278        }
1279        break;
1280    }
1281}  // end process_make_kill()
1282
1283////////////////////////////////////////////
1284void process_make_exit( process_t * process,
1285                        uint32_t    status )
1286{
1287    // this function must be executed by a thread running in owner cluster
1288    assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
1289    "must execute in owner cluster" );
1290
1291    // block all threads in all clusters
1292    process_sigaction( process , BLOCK_ALL_THREADS );
1293
1294    // delete all threads in all clusters
1295    process_sigaction( process , DELETE_ALL_THREADS );
1296
1297    // delete local process descriptor
1298    process_destroy( process ); 
1299
1300}  // end process_make_exit()
1301
1302//////////////////////////
1303void process_init_create()
1304{
1305    process_t      * process;       // local pointer on process_init descriptor
1306    pid_t            pid;           // process_init identifier
1307    thread_t       * thread;        // local pointer on main thread
1308    pthread_attr_t   attr;          // main thread attributes
1309    lid_t            lid;           // selected core local index for main thread
1310    error_t          error;
1311
1312kinit_dmsg("\n[DBG] %s :  core[%x,%d] enters\n", 
1313__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid );
1314
1315    // allocates memory for process descriptor from local cluster
1316        process = process_alloc(); 
1317        if( process == NULL )
1318    {
1319                printk("\n[PANIC] in %s : no memory for process descriptor in cluster %x\n",
1320                __FUNCTION__, local_cxy  );
1321    }
1322
1323    // get PID from local cluster
1324    error = cluster_pid_alloc( XPTR( local_cxy , process ) , &pid );
1325    if( error )
1326    {
1327                printk("\n[PANIC] in %s : cannot allocate PID in cluster %x\n",
1328                __FUNCTION__, local_cxy );
1329        process_destroy( process );
1330    }
1331
1332    assert( (LPID_FROM_PID(pid) == 1) , __FUNCTION__ , "LPID must be 1 for process_init" );
1333
1334    // initialize process descriptor / parent is local process_zero
1335    process_reference_init( process,
1336                            pid,
1337                            0,
1338                            XPTR( local_cxy , &process_zero ) );
1339
1340kinit_dmsg("\n[DBG] %s : core[%x,%d] / process initialised\n", 
1341__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid );
1342
1343    // register "code" and "data" vsegs as well as entry-point
1344    // in process VMM, using information contained in the elf file.
1345        if( elf_load_process( CONFIG_PROCESS_INIT_PATH , process ) )
1346        {
1347                printk("\n[PANIC] in %s : cannot access .elf file / path = %s\n",
1348                __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
1349        process_destroy( process );
1350        }
1351
1352kinit_dmsg("\n[DBG] %s : core[%x,%d] vsegs registered / path = %s\n",
1353__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, CONFIG_PROCESS_INIT_PATH );
1354
1355    // select a core in local cluster to execute the main thread
1356    lid  = cluster_select_local_core();
1357
1358    // initialize pthread attributes for main thread
1359    attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED | PT_ATTR_CORE_DEFINED;
1360    attr.cxy        = local_cxy;
1361    attr.lid        = lid;
1362
1363    // create and initialize thread descriptor
1364        error = thread_user_create( pid,
1365                                (void *)process->vmm.entry_point,
1366                                NULL,
1367                                &attr,
1368                                &thread );
1369        if( error )
1370        {
1371                printk("\n[PANIC] in %s : cannot create main thread / path = %s\n",
1372                __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
1373        process_destroy( process );
1374        }
1375
1376    // activate thread
1377        thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
1378
1379    hal_fence();
1380
1381kinit_dmsg("\n[DBG] %s : core[%x,%d] exit / main thread = %x\n",
1382__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, thread );
1383
1384}  // end process_init_create()
1385
Note: See TracBrowser for help on using the repository browser.