[1] | 1 | /* |
---|
[23] | 2 | * sys_exec.c - Kernel function implementing the "exec" system call. |
---|
[302] | 3 | * |
---|
[23] | 4 | * Authors Alain Greiner (2016,2017) |
---|
[1] | 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 | |
---|
[14] | 24 | #include <kernel_config.h> |
---|
[1] | 25 | #include <hal_types.h> |
---|
[23] | 26 | #include <hal_uspace.h> |
---|
[1] | 27 | #include <errno.h> |
---|
| 28 | #include <printk.h> |
---|
| 29 | #include <core.h> |
---|
| 30 | #include <vfs.h> |
---|
| 31 | #include <cluster.h> |
---|
| 32 | #include <process.h> |
---|
| 33 | #include <thread.h> |
---|
| 34 | #include <vmm.h> |
---|
| 35 | #include <ppm.h> |
---|
| 36 | #include <rpc.h> |
---|
| 37 | |
---|
| 38 | |
---|
[302] | 39 | ////////////////////////////////////////////////i////////////////////////////////////// |
---|
[1] | 40 | // This static function is called twice by the sys_exec() function : |
---|
| 41 | // - to register the main() arguments (args) in the exec_info structure. |
---|
| 42 | // - to register the environment variables (envs) in the exec_info structure. |
---|
| 43 | // In both cases the input is an array of string pointers in user space, |
---|
[302] | 44 | // and a set of strings in user space. |
---|
[1] | 45 | // We allocate one physical page to store a kernel copy of the array of pointers, |
---|
| 46 | // we allocate one or several physical pages to store the strings themselve, |
---|
| 47 | // and register these buffers and the number of strings in the exec_info structure. |
---|
[302] | 48 | // The max number of strings is 1024 (for both args and envs). The numbers of pages |
---|
[1] | 49 | // to store the (args) and (envs) strings are configuration parameters. |
---|
[302] | 50 | /////////////////////////////////////////////////////////////////////////////////////// |
---|
[407] | 51 | // @ exec_info : pointer on the exec_info structure. |
---|
| 52 | // @ is_args : true if called for (args) / false if called for (envs). |
---|
| 53 | // @ u_pointers : array of pointers on the strings (in user space). |
---|
[302] | 54 | // @ return 0 if success / non-zero if too many strings or no more memory. |
---|
[1] | 55 | /////////////////////////////////////////////////////////////////////////////////////// |
---|
| 56 | static error_t process_exec_get_strings( exec_info_t * exec_info, |
---|
| 57 | bool_t is_args, |
---|
[302] | 58 | char ** u_pointers ) |
---|
[1] | 59 | { |
---|
| 60 | uint32_t index; // string index |
---|
| 61 | uint32_t found_null; // NULL pointer found in array of pointers |
---|
| 62 | uint32_t length; // string length |
---|
| 63 | kmem_req_t req; // kmem request |
---|
| 64 | page_t * page; // page descriptor |
---|
[315] | 65 | xptr_t base_xp; // extended pointer on page base |
---|
[1] | 66 | uint32_t order; // ln2( number of pages to store strings ) |
---|
[23] | 67 | char ** k_pointers; // base of kernel array of pointers |
---|
| 68 | char * k_buf_ptr; // pointer on first empty slot in kernel strings buffer |
---|
| 69 | char * k_buf_base; // base address of the kernel strings buffer |
---|
[1] | 70 | |
---|
| 71 | // compute ln2( number of pages for kernel strings buffer ) |
---|
[23] | 72 | if( is_args ) order = bits_log2( CONFIG_VMM_ARGS_SIZE ); |
---|
| 73 | else order = bits_log2( CONFIG_VMM_ENVS_SIZE ); |
---|
[1] | 74 | |
---|
[302] | 75 | req.type = KMEM_PAGE; |
---|
| 76 | req.flags = AF_KERNEL | AF_ZERO; |
---|
[1] | 77 | |
---|
| 78 | // allocate one physical page for kernel array of pointers |
---|
| 79 | req.type = 0; |
---|
| 80 | page = kmem_alloc( &req ); |
---|
[23] | 81 | |
---|
| 82 | if( page == NULL ) return ENOMEM; |
---|
| 83 | |
---|
[315] | 84 | base_xp = ppm_page2base( XPTR( local_cxy , page ) ); |
---|
| 85 | k_pointers = (char **)GET_PTR( base_xp ); |
---|
[302] | 86 | |
---|
[1] | 87 | // allocate several physical pages to store the strings themselve |
---|
| 88 | req.type = order; |
---|
| 89 | page = kmem_alloc( &req ); |
---|
[23] | 90 | |
---|
| 91 | if( page == NULL ) return ENOMEM; |
---|
| 92 | |
---|
[315] | 93 | base_xp = ppm_page2base( XPTR( local_cxy , page ) ); |
---|
| 94 | k_buf_base = (char *)GET_PTR( base_xp ); |
---|
[302] | 95 | |
---|
| 96 | // copy the array of pointers to kernel buffer |
---|
| 97 | hal_copy_from_uspace( k_pointers, |
---|
[1] | 98 | u_pointers, |
---|
| 99 | CONFIG_PPM_PAGE_SIZE ); |
---|
| 100 | |
---|
[23] | 101 | // scan kernel array of pointers to copy the strings |
---|
[1] | 102 | found_null = 0; |
---|
[23] | 103 | k_buf_ptr = k_buf_base; |
---|
[1] | 104 | for( index = 0 ; index < 1024 ; index++ ) |
---|
| 105 | { |
---|
[302] | 106 | if( k_pointers[index] == NULL ) |
---|
[1] | 107 | { |
---|
| 108 | found_null = 1; |
---|
| 109 | break; |
---|
| 110 | } |
---|
| 111 | |
---|
| 112 | // compute string length |
---|
[302] | 113 | length = hal_strlen_from_uspace( k_pointers[index] ); |
---|
| 114 | |
---|
[1] | 115 | // copy the user string to kernel buffer |
---|
[23] | 116 | hal_copy_from_uspace( k_buf_ptr, |
---|
| 117 | k_pointers[index], |
---|
[1] | 118 | length ); |
---|
| 119 | |
---|
| 120 | // update k_pointer[index] entry |
---|
[23] | 121 | k_pointers[index] = k_buf_ptr; |
---|
[1] | 122 | |
---|
| 123 | // increment pointer on kernel strings buffer |
---|
[23] | 124 | k_buf_ptr += (length + 1); |
---|
[1] | 125 | } |
---|
| 126 | |
---|
[302] | 127 | // update into exec_info structure |
---|
[1] | 128 | if( found_null && is_args ) |
---|
| 129 | { |
---|
| 130 | exec_info->args_pointers = k_pointers; |
---|
[23] | 131 | exec_info->args_buf_base = k_buf_base; |
---|
[1] | 132 | exec_info->args_nr = index; |
---|
| 133 | } |
---|
| 134 | else if( found_null && !is_args ) |
---|
| 135 | { |
---|
| 136 | exec_info->envs_pointers = k_pointers; |
---|
[23] | 137 | exec_info->envs_buf_base = k_buf_base; |
---|
| 138 | exec_info->envs_buf_free = k_buf_ptr; |
---|
[1] | 139 | exec_info->envs_nr = index; |
---|
| 140 | } |
---|
[302] | 141 | else |
---|
[1] | 142 | { |
---|
| 143 | return EINVAL; |
---|
| 144 | } |
---|
| 145 | |
---|
| 146 | return 0; |
---|
| 147 | } // end process_exec_get_strings() |
---|
| 148 | |
---|
| 149 | ///////////////////////////////////////////////////////////////////////////////////////// |
---|
| 150 | // Implementation note: |
---|
| 151 | // This function build an exec_info_t structure containing all informations |
---|
| 152 | // required to create the new process descriptor and the associated thread. |
---|
[407] | 153 | // It calls the process_exec_get_strings() functions to copy the main() arguments and |
---|
| 154 | // the environment variables from user buffers to the exec_info_t structure, allocate |
---|
| 155 | // and call the process_make_exec() function. |
---|
| 156 | // Finally, it destroys the calling thread and process. |
---|
| 157 | // TODO : the args & envs arguments are not supported yet : both must be NULL |
---|
[1] | 158 | ///////////////////////////////////////////////////////////////////////////////////////// |
---|
[407] | 159 | int sys_exec( char * pathname, // .elf file pathname |
---|
[23] | 160 | char ** args, // process arguments |
---|
| 161 | char ** envs ) // environment variables |
---|
[1] | 162 | { |
---|
[407] | 163 | exec_info_t exec_info; // structure to pass to process_make_exec() |
---|
| 164 | error_t error; |
---|
[1] | 165 | |
---|
[407] | 166 | uint64_t tm_start; |
---|
| 167 | uint64_t tm_end; |
---|
| 168 | |
---|
| 169 | tm_start = hal_get_cycles(); |
---|
| 170 | |
---|
| 171 | // get pointers on parent process and thread |
---|
[23] | 172 | thread_t * this = CURRENT_THREAD; |
---|
[302] | 173 | process_t * process = this->process; |
---|
[407] | 174 | pid_t pid = process->pid; |
---|
[23] | 175 | |
---|
[407] | 176 | exec_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / cycle %d\n", |
---|
| 177 | __FUNCTION__, local_cxy, this->core->lid, pid, (uint32_t)hal_get_cycles() ); |
---|
[23] | 178 | |
---|
[407] | 179 | sched_display( 0 ); |
---|
[1] | 180 | |
---|
[407] | 181 | // check pathname length |
---|
| 182 | if( hal_strlen_from_uspace( pathname ) >= CONFIG_VFS_MAX_PATH_LENGTH ) |
---|
[23] | 183 | { |
---|
[407] | 184 | printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ ); |
---|
| 185 | this->errno = ENFILE; |
---|
[23] | 186 | return -1; |
---|
| 187 | } |
---|
| 188 | |
---|
[407] | 189 | // copy pathname in exec_info structure (kernel space) |
---|
| 190 | hal_strcpy_from_uspace( exec_info.path , pathname , CONFIG_VFS_MAX_PATH_LENGTH ); |
---|
| 191 | // check args argument |
---|
| 192 | assert( (args == NULL) , __FUNCTION__ , |
---|
| 193 | "args not supported yet\n" ); |
---|
[23] | 194 | |
---|
[407] | 195 | // check envs argument |
---|
| 196 | assert( (envs == NULL) , __FUNCTION__ , |
---|
| 197 | "args not supported yet\n" ); |
---|
[23] | 198 | |
---|
[1] | 199 | // compute client_cxy (local cluster) and server_cxy (target cluster) |
---|
[407] | 200 | cxy_t cxy_server = CXY_FROM_PID( pid ); |
---|
[1] | 201 | cxy_t cxy_client = local_cxy; |
---|
| 202 | |
---|
[407] | 203 | // register parent process in exec_info |
---|
[101] | 204 | exec_info.parent_xp = process->ref_xp; |
---|
[1] | 205 | |
---|
[407] | 206 | // new process keep the parent process PID |
---|
| 207 | exec_info.keep_pid = true; |
---|
[1] | 208 | |
---|
[407] | 209 | // check and store args in exec_info structure if required |
---|
| 210 | if( args != NULL ) |
---|
[1] | 211 | { |
---|
[407] | 212 | if( process_exec_get_strings( &exec_info , true , args ) ) |
---|
| 213 | { |
---|
| 214 | printk("\n[ERROR] in %s : cannot access args\n", __FUNCTION__ ); |
---|
| 215 | this->errno = error; |
---|
| 216 | return -1; |
---|
| 217 | } |
---|
[23] | 218 | } |
---|
[1] | 219 | |
---|
[407] | 220 | // check and store envs in exec_info structure if required |
---|
| 221 | if( envs != NULL ) |
---|
[23] | 222 | { |
---|
[407] | 223 | if( process_exec_get_strings( &exec_info , false , envs ) ) |
---|
| 224 | { |
---|
| 225 | printk("\n[ERROR] in %s : cannot access envs\n", __FUNCTION__ ); |
---|
| 226 | this->errno = error; |
---|
| 227 | return -1; |
---|
| 228 | } |
---|
[1] | 229 | } |
---|
[23] | 230 | |
---|
[407] | 231 | // call process_make_exec (local or remote) |
---|
| 232 | if( cxy_server == cxy_client ) |
---|
[1] | 233 | { |
---|
[407] | 234 | error = process_make_exec( &exec_info ); |
---|
[23] | 235 | } |
---|
[407] | 236 | else |
---|
| 237 | { |
---|
| 238 | rpc_process_exec_client( cxy_server , &exec_info , &error ); |
---|
| 239 | } |
---|
[302] | 240 | |
---|
[23] | 241 | if( error ) |
---|
| 242 | { |
---|
[407] | 243 | printk("\n[ERROR] in %s : cannot create new process %x in cluster %x\n", |
---|
| 244 | __FUNCTION__, pid, cxy_server ); |
---|
[23] | 245 | this->errno = error; |
---|
| 246 | return -1; |
---|
[1] | 247 | } |
---|
| 248 | |
---|
[407] | 249 | // FIXME delete the local process descriptor |
---|
| 250 | // process_kill( process ); |
---|
[23] | 251 | |
---|
[407] | 252 | tm_end = hal_get_cycles(); |
---|
[1] | 253 | |
---|
[407] | 254 | exec_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x / cycle %d\n" |
---|
| 255 | " pathname = %s / cost = %d\n", |
---|
| 256 | __FUNCTION__, local_cxy, this->core->lid, pid, (uint32_t)tm_start, |
---|
| 257 | exec_info.path , (uint32_t)(tm_end - tm_start) ); |
---|
| 258 | |
---|
[1] | 259 | return 0; |
---|
[23] | 260 | |
---|
[1] | 261 | } // end sys_exec() |
---|
| 262 | |
---|