/* * hal_context.h - Generic Thread Context Access API definition. * * Author Alain Greiner (2016,2017,2018,2019) * * Copyright (c) UPMC Sorbonne Universites * * This file is part of ALMOS-MKH. * * ALMOS-MKH is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by * the Free Software Foundation; version 2.0 of the License. * * ALMOS-MKH is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with ALMOS-MKH; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef _HAL_CONTEXT_H_ #define _HAL_CONTEXT_H_ ////////////////////////////////////////////////////////////////////////////////////////// // Generic Thread Context API definition (implementation in hal_context.c) // // A thread context is defined by the two (core specific) structures hal_cpu_context_t // and hal_fpu_context_t, defined in hal_context.c file, that are accessed with generic // void* pointers stored in the thread descriptor. // - the "hal_cpu_context_t" struct saves the CPU registers values at context switch. // - the "hal_fpu_context_t" struct saves the FPU registers values at FPU switch. ////////////////////////////////////////////////////////////////////////////////////////// /**** Forward declarations ****/ struct thread_s; /**************************************************************************************** * This function allocates memory for a CPU context and links it to the thread * identified by the argument. The context is not initialised. **************************************************************************************** * @ thread : pointer on the thread descriptor. * @ return 0 if success / return -1 if failure. ***************************************************************************************/ error_t hal_cpu_context_alloc( struct thread_s * thread ); /**************************************************************************************** * This function initializes the CPU context of the thread identified by the * argument. All slots required to start a new thread must be initialized. **************************************************************************************** * @ thread : pointer on the thread descriptor. ***************************************************************************************/ void hal_cpu_context_init( struct thread_s * thread ); /**************************************************************************************** * This function is called the sys_fork() function to complete the fork mechanism. * It is called by th local parent thread to initialize the CPU context of the remote * child thread, identified by the argument. * It makes three actions: * 1) It copies the current values of the CPU registers of the core running the parent * thread to the remote child CPU context. * 2) It patches four slots of this remote child CPU context: * - the c0_th slot is set to the child thread descriptor pointer. * - the sp_29 slot is set to the child kernel stack pointer. * - the c0_sr slot is set to kernel mode with IRQ disabled. * - the c2_ptpr slot is set to the child process GPT value. * 3) It copies the content of the parent thread kernel_stack, to the child thread * kernel_stack, because the COW mechanism is not available on architectures where * the data MMU is de-activated in kernel mode. **************************************************************************************** * @ thread_xp : extended pointer on the child thread descriptor. ***************************************************************************************/ void hal_cpu_context_fork( xptr_t thread_xp ); /**************************************************************************************** * This function is used to implement the exec() system call. * 1) It initialize the relevant slots of the the calling thread CPU context. * 2) It call the hal_do_cpu_restore() function to return to user mode and start * execution of the new process. **************************************************************************************** * @ thread : pointer on the thread descriptor. ***************************************************************************************/ void hal_cpu_context_exec( struct thread_s * thread ); /**************************************************************************************** * This function display some slots of the CPU context. **************************************************************************************** * @ thread_xp : extended pointer on the thread descriptor. ***************************************************************************************/ void hal_cpu_context_display( xptr_t thread_xp ); /**************************************************************************************** * This function releases the physical memory allocated for a thread CPU context. **************************************************************************************** * @ thread : pointer on the thread descriptor. ***************************************************************************************/ void hal_cpu_context_destroy( struct thread_s * thread ); /**************************************************************************************** * This function allocates memory for a FPU context, reset all entries, * and links it to the thread identified by the argument. **************************************************************************************** * @ thread : pointer on the thread descriptor. * @ return 0 if success / return -1 if failure. ***************************************************************************************/ error_t hal_fpu_context_alloc( struct thread_s * thread ); /**************************************************************************************** * This function initializes a FPU context from scratch. **************************************************************************************** * @ thread : pointer on the thread descriptor. ***************************************************************************************/ void hal_fpu_context_init( struct thread_s * thread ); /**************************************************************************************** * This function copies a FPU context defined by the argument to the FPU context * defined by the argument. It is used by the fork system call. **************************************************************************************** * @ dst : pointer on the destination thread descriptor. * @ src : pointer on the source thread descriptor. ***************************************************************************************/ void hal_fpu_context_copy( struct thread_s * dst, struct thread_s * src ); /**************************************************************************************** * This function releases the physical memory allocated for a FPU context. **************************************************************************************** * @ thread : pointer on the thread descriptor. ***************************************************************************************/ void hal_fpu_context_destroy( struct thread_s * thread ); /**************************************************************************************** * This function is used to implement the fork() system call. * It saves in a remote thread FPU context the current FPU registers values. **************************************************************************************** * @ thread_xp : extended pointer on the remote thread descriptor. ***************************************************************************************/ void hal_fpu_context_save( xptr_t thread_xp ); /**************************************************************************************** * This function restores from the calling thread FPU context the FPU registers values. **************************************************************************************** * @ thread : pointer on the thread descriptor. ***************************************************************************************/ void hal_fpu_context_restore( struct thread_s * thread ); #endif /* _HAL_CONTEXT_H_ */