[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 | |
---|
[436] | 75 | // get process owner cluster and calling thread trdid |
---|
| 76 | cxy_t owner_cxy = CXY_FROM_PID( pid ); |
---|
| 77 | trdid_t trdid = this->trdid; |
---|
[421] | 78 | |
---|
[436] | 79 | // wait must be executed by the main thread |
---|
| 80 | if( (owner_cxy != local_cxy) || (LTID_FROM_TRDID(trdid) != 0) ) |
---|
| 81 | { |
---|
[421] | 82 | |
---|
[438] | 83 | #if DEBUG_SYSCALL_ERROR |
---|
[436] | 84 | printk("\n[ERROR] in %s : calling thread %x is not thread 0 in owner cluster %x\n", |
---|
| 85 | __FUNCTION__ , trdid , owner_cxy ); |
---|
| 86 | #endif |
---|
| 87 | this->errno = EINVAL; |
---|
| 88 | return -1; |
---|
| 89 | } |
---|
| 90 | |
---|
[433] | 91 | // get extended pointer on children list root and lock |
---|
| 92 | xptr_t children_root_xp = XPTR( owner_cxy , &process->children_root ); |
---|
| 93 | xptr_t children_lock_xp = XPTR( owner_cxy , &process->children_lock ); |
---|
[421] | 94 | |
---|
| 95 | // exit this blocking loop only when a child processes change state |
---|
| 96 | while( 1 ) |
---|
| 97 | { |
---|
[435] | 98 | // enable IRQS |
---|
| 99 | hal_enable_irq( &save_sr ); |
---|
| 100 | |
---|
[433] | 101 | // get lock protecting children list |
---|
| 102 | remote_spinlock_lock( children_lock_xp ); |
---|
[421] | 103 | |
---|
[436] | 104 | // scan the list of child process |
---|
[433] | 105 | XLIST_FOREACH( children_root_xp , iter_xp ) |
---|
[421] | 106 | { |
---|
[433] | 107 | // get child process owner cluster and local pointer |
---|
[421] | 108 | child_xp = XLIST_ELEMENT( iter_xp , process_t , children_list ); |
---|
| 109 | child_ptr = GET_PTR( child_xp ); |
---|
| 110 | child_cxy = GET_CXY( child_xp ); |
---|
| 111 | |
---|
[433] | 112 | // get term_state from child owner process |
---|
| 113 | child_state = (int)hal_remote_lw ( XPTR(child_cxy,&child_ptr->term_state)); |
---|
[421] | 114 | |
---|
[433] | 115 | // test if child process is terminated, |
---|
| 116 | // but termination not yet reported to parent process |
---|
[435] | 117 | if( ((child_state & PROCESS_TERM_EXIT) || |
---|
| 118 | (child_state & PROCESS_TERM_KILL) || |
---|
| 119 | (child_state & PROCESS_TERM_STOP)) && |
---|
| 120 | ((child_state & PROCESS_TERM_WAIT) == 0) ) |
---|
[421] | 121 | { |
---|
[433] | 122 | // get pointer on main thread and PID from child owner process |
---|
[436] | 123 | child_pid = (pid_t) hal_remote_lw (XPTR( child_cxy , &child_ptr->pid )); |
---|
| 124 | child_thread = (thread_t *)hal_remote_lpt(XPTR( child_cxy , |
---|
| 125 | &child_ptr->th_tbl[0] )); |
---|
[421] | 126 | |
---|
[433] | 127 | // set the PROCESS_FLAG_WAIT in owner child descriptor |
---|
| 128 | hal_remote_atomic_or( XPTR( child_cxy , &child_ptr->term_state ), |
---|
[435] | 129 | PROCESS_TERM_WAIT ); |
---|
[433] | 130 | |
---|
| 131 | // set the THREAD_FLAG_REQ_DELETE in child main thread |
---|
| 132 | hal_remote_atomic_or( XPTR( child_cxy , &child_thread->flags ) , |
---|
| 133 | THREAD_FLAG_REQ_DELETE ); |
---|
| 134 | |
---|
[435] | 135 | // release lock protecting children list |
---|
| 136 | remote_spinlock_unlock( children_lock_xp ); |
---|
| 137 | |
---|
[438] | 138 | #if DEBUG_SYS_WAIT |
---|
[421] | 139 | tm_end = hal_get_cycles(); |
---|
[438] | 140 | if( DEBUG_SYS_WAIT < tm_end ) |
---|
[435] | 141 | printk("\n[DBG] %s : thread %x exit / parent %x / child %x / cycle %d\n", |
---|
| 142 | __FUNCTION__, this, process->pid, child_pid, (uint32_t)tm_end ); |
---|
[421] | 143 | #endif |
---|
[436] | 144 | // return child termination state to parent process |
---|
[433] | 145 | hal_copy_to_uspace( status , &child_state , sizeof(int) ); |
---|
| 146 | return child_pid; |
---|
[421] | 147 | } |
---|
[436] | 148 | } // end loop on children |
---|
[421] | 149 | |
---|
[435] | 150 | // release lock protecting children list |
---|
[433] | 151 | remote_spinlock_unlock( children_lock_xp ); |
---|
[421] | 152 | |
---|
[433] | 153 | // deschedule without blocking |
---|
| 154 | sched_yield( "parent wait children termination" ); |
---|
[421] | 155 | |
---|
[435] | 156 | } // end while |
---|
| 157 | |
---|
[421] | 158 | // never executed |
---|
| 159 | return -1; |
---|
| 160 | |
---|
| 161 | } // end sys_wait() |
---|