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