source: trunk/kernel/syscalls/sys_exit.c @ 625

Last change on this file since 625 was 625, checked in by alain, 2 years ago

Fix a bug in the vmm_remove_vseg() function: the physical pages
associated to an user DATA vseg were released to the kernel when
the target process descriptor was in the reference cluster.
This physical pages release should be done only when the page
forks counter value is zero.
All other modifications are cosmetic.

File size: 5.5 KB
Line 
1/*
2 * sys_exit.c - Kernel function implementing the "exit" system call.
3 *
4 * Author    Alain Greiner (2016,2017,2018,2019)
5 *
6 * Copyright (c)  UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <kernel_config.h>
25#include <hal_kernel_types.h>
26#include <hal_irqmask.h>
27#include <errno.h>
28#include <thread.h>
29#include <printk.h>
30#include <process.h>
31#include <shared_syscalls.h>
32#include <cluster.h>
33#include <rpc.h>
34
35#include <syscalls.h>
36
37///////////////////////////////
38int sys_exit( uint32_t status )
39{
40    xptr_t      owner_xp;          // extended pointer on owner process
41    cxy_t       owner_cxy;         // owner process cluster
42    process_t * owner_ptr;         // local pointer on owner process
43    thread_t  * main_ptr;          // local pointer on process main thread
44    xptr_t      parent_xp;         // extended pointer on parent process
45    cxy_t       parent_cxy;        // parent process cluster
46    process_t * parent_ptr;        // local pointer on parent process
47    thread_t  * parent_main_ptr;   // local pointer on parent main thread
48    xptr_t      parent_main_xp;    // extended pointer on parent main thread
49    uint32_t    term_state;        // termination status for owner process
50
51    thread_t  * this    = CURRENT_THREAD;
52    process_t * process = this->process;
53    pid_t       pid     = process->pid;
54
55#if (DEBUG_SYS_EXIT || CONFIG_INSTRUMENTATION_SYSCALLS)
56uint64_t     tm_start = hal_get_cycles();
57#endif
58
59#if DEBUG_SYS_EXIT
60if( DEBUG_SYS_EXIT < tm_start )
61printk("\n[%s] thread[%x,%x] enter / status %x / cycle %d\n",
62__FUNCTION__, pid, this->trdid , status , (uint32_t)tm_start );
63#endif
64
65    // get owner process descriptor pointers
66    owner_xp  = process->owner_xp;
67    owner_cxy = GET_CXY( owner_xp );
68    owner_ptr = GET_PTR( owner_xp );
69
70    // get local pointer on the main thread
71    main_ptr  = hal_remote_lpt( XPTR( owner_cxy , &owner_ptr->th_tbl[0] ) );
72
73    // get parent process descriptor pointers
74    parent_xp  = process->parent_xp;
75    parent_cxy = GET_CXY( parent_xp );
76    parent_ptr = GET_PTR( parent_xp );
77
78    // get pointers on the parent process main thread
79    parent_main_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[0] ) ); 
80    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
81
82    // remove process from TXT list
83    process_txt_detach( owner_xp );
84
85#if( DEBUG_SYS_EXIT & 1)
86if( DEBUG_SYS_EXIT < tm_start )
87printk("\n[%s] thread[%x,%x] detached process %x from TXT\n",
88__FUNCTION__, pid, this->trdid, pid );
89#endif
90
91    // mark for delete all process threads in all clusters,
92    // but the main thread and this calling thread
93    process_sigaction( pid , DELETE_ALL_THREADS );
94
95#if( DEBUG_SYS_EXIT & 1)
96if( DEBUG_SYS_EXIT < tm_start )
97printk("\n[%s] thread[%x,%x] deleted all threads in process %x (but itself)\n",
98__FUNCTION__, pid, this->trdid, pid );
99#endif
100
101    // mark for delete the calling thread when it is not the main
102    if( (owner_cxy != local_cxy) || (main_ptr != this) )
103    {
104
105#if( DEBUG_SYS_EXIT & 1)
106if( tm_start > DEBUG_SYS_EXIT )
107printk("\n[%s] thread[%x,%x] marked iself for delete\n",
108__FUNCTION__, pid, this->trdid );
109#endif
110        thread_delete( XPTR( local_cxy , this ) , pid , true );
111    }
112
113    // block the main thread
114    thread_block( XPTR( owner_cxy , main_ptr ) , THREAD_BLOCKED_GLOBAL );
115
116#if( DEBUG_SYS_EXIT & 1)
117trdid_t main_trdid = hal_remote_l32( XPTR( owner_cxy , &main_ptr->trdid ) );
118if( tm_start > DEBUG_SYS_EXIT )
119printk("\n[%s] thread[%x,%x] blocked main thread[%x,%x]\n",
120__FUNCTION__, pid, this->trdid, pid, main_trdid );
121#endif
122
123    // update term_state in owner process descriptor to ask
124    // the parent process sys_wait() function to delete the process
125    term_state = (status & 0xFF) | PROCESS_TERM_EXIT;
126    hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) , term_state );
127
128#if( DEBUG_SYS_EXIT & 1)
129if( tm_start > DEBUG_SYS_EXIT )
130printk("\n[%s] thread[%x,%x] set exit status %x in owner process\n",
131__FUNCTION__, pid, this->trdid, term_state );
132#endif
133
134    // unblock the parent process main thread
135    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
136
137#if( DEBUG_SYS_EXIT & 1)
138if( tm_start > DEBUG_SYS_EXIT )
139printk("\n[%s] thread[%x,%x] unblocked parent main thread in process %x\n",
140__FUNCTION__ , pid, this->trdid,
141hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid) ) );
142#endif
143
144    hal_fence();
145
146#if (DEBUG_SYS_EXIT || CONFIG_INSTRUMENTATION_SYSCALLS)
147uint64_t     tm_end = hal_get_cycles();
148#endif
149
150#if DEBUG_SYS_EXIT
151if( DEBUG_SYS_EXIT < tm_end )
152printk("\n[%s] thread[%x,%x] exit / term_state %x / cycle %d\n",
153__FUNCTION__, pid, this->trdid, term_state,  (uint32_t)tm_end );
154#endif
155
156#if CONFIG_INSTRUMENTATION_SYSCALLS
157hal_atomic_add( &syscalls_cumul_cost[SYS_EXIT] , tm_end - tm_start );
158hal_atomic_add( &syscalls_occurences[SYS_EXIT] , 1 );
159#endif
160
161    // this thread deschedule
162    sched_yield( "process exit" );
163
164        return 0;
165
166}  // end sys_exit()
167
Note: See TracBrowser for help on using the repository browser.