[421] | 1 | /* |
---|
| 2 | * sys_wait.c - wait termination or blocking of a child process. |
---|
| 3 | * |
---|
[440] | 4 | * Author Alain Greiner (2016,2017,2018) |
---|
[421] | 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 <hal_types.h> |
---|
| 25 | #include <hal_uspace.h> |
---|
[435] | 26 | #include <hal_irqmask.h> |
---|
[421] | 27 | #include <core.h> |
---|
| 28 | #include <thread.h> |
---|
| 29 | #include <process.h> |
---|
| 30 | #include <vmm.h> |
---|
| 31 | #include <printk.h> |
---|
| 32 | |
---|
| 33 | ///////////////////////////////// |
---|
| 34 | int sys_wait( uint32_t * status ) |
---|
| 35 | { |
---|
| 36 | error_t error; |
---|
[440] | 37 | vseg_t * vseg; |
---|
[421] | 38 | xptr_t iter_xp; |
---|
| 39 | xptr_t child_xp; |
---|
| 40 | process_t * child_ptr; |
---|
| 41 | cxy_t child_cxy; |
---|
| 42 | pid_t child_pid; |
---|
| 43 | int child_state; |
---|
[433] | 44 | thread_t * child_thread; |
---|
[435] | 45 | reg_t save_sr; |
---|
[421] | 46 | |
---|
| 47 | thread_t * this = CURRENT_THREAD; |
---|
| 48 | process_t * process = this->process; |
---|
[433] | 49 | pid_t pid = process->pid; |
---|
[421] | 50 | |
---|
[438] | 51 | #if DEBUG_SYS_WAIT |
---|
[421] | 52 | uint64_t tm_start; |
---|
| 53 | uint64_t tm_end; |
---|
| 54 | tm_start = hal_get_cycles(); |
---|
[438] | 55 | if( DEBUG_SYS_WAIT < tm_start ) |
---|
[433] | 56 | printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n", |
---|
| 57 | __FUNCTION__, this, process->pid, (uint32_t)tm_start ); |
---|
[421] | 58 | #endif |
---|
| 59 | |
---|
| 60 | // check status in user space |
---|
[440] | 61 | error = vmm_get_vseg( process, (intptr_t)status , &vseg ); |
---|
[421] | 62 | |
---|
| 63 | if( error ) |
---|
| 64 | { |
---|
[435] | 65 | |
---|
[438] | 66 | #if DEBUG_SYSCALLS_ERROR |
---|
[440] | 67 | printk("\n[ERROR] in %s : status buffer %x unmapped for thread %x in process %x\n", |
---|
| 68 | __FUNCTION__ , (intptr_t)status, this->trdid , process->pid ); |
---|
| 69 | vmm_display( process , false ); |
---|
[435] | 70 | #endif |
---|
[436] | 71 | this->errno = EINVAL; |
---|
[421] | 72 | return -1; |
---|
| 73 | } |
---|
| 74 | |
---|
[443] | 75 | // get calling process owner cluster |
---|
[436] | 76 | cxy_t owner_cxy = CXY_FROM_PID( pid ); |
---|
[421] | 77 | |
---|
[443] | 78 | // get calling thread trdid |
---|
| 79 | trdid_t trdid = this->trdid; |
---|
| 80 | |
---|
| 81 | // this function must be executed by the process main thread |
---|
[436] | 82 | if( (owner_cxy != local_cxy) || (LTID_FROM_TRDID(trdid) != 0) ) |
---|
| 83 | { |
---|
[421] | 84 | |
---|
[438] | 85 | #if DEBUG_SYSCALL_ERROR |
---|
[436] | 86 | printk("\n[ERROR] in %s : calling thread %x is not thread 0 in owner cluster %x\n", |
---|
| 87 | __FUNCTION__ , trdid , owner_cxy ); |
---|
| 88 | #endif |
---|
| 89 | this->errno = EINVAL; |
---|
| 90 | return -1; |
---|
| 91 | } |
---|
| 92 | |
---|
[433] | 93 | // get extended pointer on children list root and lock |
---|
| 94 | xptr_t children_root_xp = XPTR( owner_cxy , &process->children_root ); |
---|
| 95 | xptr_t children_lock_xp = XPTR( owner_cxy , &process->children_lock ); |
---|
[421] | 96 | |
---|
| 97 | // exit this blocking loop only when a child processes change state |
---|
| 98 | while( 1 ) |
---|
| 99 | { |
---|
[435] | 100 | // enable IRQS |
---|
| 101 | hal_enable_irq( &save_sr ); |
---|
| 102 | |
---|
[433] | 103 | // get lock protecting children list |
---|
| 104 | remote_spinlock_lock( children_lock_xp ); |
---|
[421] | 105 | |
---|
[436] | 106 | // scan the list of child process |
---|
[433] | 107 | XLIST_FOREACH( children_root_xp , iter_xp ) |
---|
[421] | 108 | { |
---|
[433] | 109 | // get child process owner cluster and local pointer |
---|
[421] | 110 | child_xp = XLIST_ELEMENT( iter_xp , process_t , children_list ); |
---|
| 111 | child_ptr = GET_PTR( child_xp ); |
---|
| 112 | child_cxy = GET_CXY( child_xp ); |
---|
| 113 | |
---|
[433] | 114 | // get term_state from child owner process |
---|
| 115 | child_state = (int)hal_remote_lw ( XPTR(child_cxy,&child_ptr->term_state)); |
---|
[421] | 116 | |
---|
[443] | 117 | // test if this child process is terminated, |
---|
[433] | 118 | // but termination not yet reported to parent process |
---|
[435] | 119 | if( ((child_state & PROCESS_TERM_EXIT) || |
---|
| 120 | (child_state & PROCESS_TERM_KILL) || |
---|
| 121 | (child_state & PROCESS_TERM_STOP)) && |
---|
| 122 | ((child_state & PROCESS_TERM_WAIT) == 0) ) |
---|
[421] | 123 | { |
---|
[443] | 124 | // get pointer on child main thread and PID from child owner process |
---|
[436] | 125 | child_pid = (pid_t) hal_remote_lw (XPTR( child_cxy , &child_ptr->pid )); |
---|
| 126 | child_thread = (thread_t *)hal_remote_lpt(XPTR( child_cxy , |
---|
| 127 | &child_ptr->th_tbl[0] )); |
---|
[421] | 128 | |
---|
[443] | 129 | // set the PROCESS_FLAG_WAIT in owner child process descriptor |
---|
[433] | 130 | hal_remote_atomic_or( XPTR( child_cxy , &child_ptr->term_state ), |
---|
[435] | 131 | PROCESS_TERM_WAIT ); |
---|
[433] | 132 | |
---|
| 133 | // set the THREAD_FLAG_REQ_DELETE in child main thread |
---|
| 134 | hal_remote_atomic_or( XPTR( child_cxy , &child_thread->flags ) , |
---|
| 135 | THREAD_FLAG_REQ_DELETE ); |
---|
| 136 | |
---|
[435] | 137 | // release lock protecting children list |
---|
| 138 | remote_spinlock_unlock( children_lock_xp ); |
---|
| 139 | |
---|
[438] | 140 | #if DEBUG_SYS_WAIT |
---|
[421] | 141 | tm_end = hal_get_cycles(); |
---|
[438] | 142 | if( DEBUG_SYS_WAIT < tm_end ) |
---|
[435] | 143 | printk("\n[DBG] %s : thread %x exit / parent %x / child %x / cycle %d\n", |
---|
| 144 | __FUNCTION__, this, process->pid, child_pid, (uint32_t)tm_end ); |
---|
[421] | 145 | #endif |
---|
[436] | 146 | // return child termination state to parent process |
---|
[433] | 147 | hal_copy_to_uspace( status , &child_state , sizeof(int) ); |
---|
| 148 | return child_pid; |
---|
[421] | 149 | } |
---|
[436] | 150 | } // end loop on children |
---|
[421] | 151 | |
---|
[435] | 152 | // release lock protecting children list |
---|
[433] | 153 | remote_spinlock_unlock( children_lock_xp ); |
---|
[421] | 154 | |
---|
[433] | 155 | // deschedule without blocking |
---|
| 156 | sched_yield( "parent wait children termination" ); |
---|
[421] | 157 | |
---|
[435] | 158 | } // end while |
---|
| 159 | |
---|
[421] | 160 | // never executed |
---|
| 161 | return -1; |
---|
| 162 | |
---|
| 163 | } // end sys_wait() |
---|