source: trunk/hal/generic/hal_context.h @ 649

Last change on this file since 649 was 625, checked in by alain, 6 years ago

Fix a bug in the vmm_remove_vseg() function: the physical pages
associated to an user DATA vseg were released to the kernel when
the target process descriptor was in the reference cluster.
This physical pages release should be done only when the page
forks counter value is zero.
All other modifications are cosmetic.
File size: 8.4 KB
Line 
1/*
2 * hal_context.h - Generic Thread Context Access API definition.
3 *
4 * Author  Alain Greiner    (2016,2017,2018,2019)
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#ifndef  _HAL_CONTEXT_H_
25#define  _HAL_CONTEXT_H_
26
27//////////////////////////////////////////////////////////////////////////////////////////
28//        Generic Thread Context API definition (implementation in hal_context.c)
29//
30// A thread context is defined by the two (core specific) structures hal_cpu_context_t
31// and hal_fpu_context_t, defined in hal_context.c file, that are accessed with generic
32// void* pointers stored in the thread descriptor.
33// - the "hal_cpu_context_t" struct saves the CPU registers values at context switch.
34// - the "hal_fpu_context_t" struct saves the FPU registers values at FPU switch.
35//////////////////////////////////////////////////////////////////////////////////////////
36
37/**** Forward declarations ****/
38
39struct thread_s;
40
41/****************************************************************************************
42 * This function allocates memory for a CPU context and links it to the thread
43 * identified by the <thread> argument. The context is not initialised.
44 ****************************************************************************************
45 * @ thread  : pointer on the thread descriptor.
46 * @ return 0 if success / return -1 if failure.
47 ***************************************************************************************/
48error_t hal_cpu_context_alloc( struct thread_s * thread );
49
50/****************************************************************************************
51 * This function initializes a CPU context from scratch.
52 ****************************************************************************************
53 * @ thread  : pointer on the thread descriptor.
54 ***************************************************************************************/
55void hal_cpu_context_init( struct thread_s * thread );
56
57/****************************************************************************************
58 * This function is called the sys_fork() function to complete the fork mechanism.
59 * It is called by th local parent thread to initialize the CPU context of the remote
60 * child thread, identified by the <thread_xp> argument.
61 * It makes three actions:
62 * 1) It copies the current values of the CPU registers of the core running the parent
63 *    thread to the remote child CPU context.
64 * 2) It patches four slots of this remote child CPU context:
65 *    - the c0_th   slot is set to the child thread descriptor pointer.
66 *    - the sp_29   slot is set to the child kernel stack pointer.
67 *    - the c0_sr   slot is set to kernel mode with IRQ disabled.
68 *    - the c2_ptpr slot is set to the child process GPT value.
69 * 3) It copies the content of the parent thread kernel_stack, to the child thread
70 *    kernel_stack, because the COW mechanism is not available on architectures where
71 *    the data MMU is de-activated in kernel mode.
72 ****************************************************************************************
73 * @ thread_xp  : extended pointer on the child thread descriptor.
74 ***************************************************************************************/
75void hal_cpu_context_fork( xptr_t    thread_xp );
76
77/****************************************************************************************
78 * This function is used to implement the exec() system call.
79 * 1) It initialize the relevant slots of the the calling thread CPU context.
80 * 2) It call the hal_do_cpu_restore() function to return to user mode and start
81 *    execution of the new process.
82 ****************************************************************************************
83 * @ thread  : pointer on the thread descriptor.
84 ***************************************************************************************/
85void hal_cpu_context_exec( struct thread_s * thread );
86
87/****************************************************************************************
88 * This function display some slots of the CPU context.
89 ****************************************************************************************
90 * @ thread_xp  : extended pointer on the thread descriptor.
91 ***************************************************************************************/
92void hal_cpu_context_display( xptr_t  thread_xp );
93
94/****************************************************************************************
95 * This function releases the physical memory allocated for a thread CPU context.
96 ****************************************************************************************
97 * @ thread  : pointer on the thread descriptor.
98 ***************************************************************************************/
99void hal_cpu_context_destroy( struct thread_s * thread );
100
101
102
103
104
105
106
107/****************************************************************************************
108 * This function allocates memory for a FPU context, reset all entries,
109 * and links it to the thread identified by the <thread> argument.
110 ****************************************************************************************
111 * @ thread  : pointer on the thread descriptor.
112 * @ return 0 if success / return -1 if failure.
113 ***************************************************************************************/
114error_t hal_fpu_context_alloc( struct thread_s * thread );
115
116/****************************************************************************************
117 * This function initializes a FPU context from scratch.
118 ****************************************************************************************
119 * @ thread  : pointer on the thread descriptor.
120 ***************************************************************************************/
121void hal_fpu_context_init( struct thread_s * thread );
122
123/****************************************************************************************
124 * This function copies a FPU context defined by the <src> argument to the FPU context
125 * defined by the <dst> argument. It is used by the fork system call.
126 ****************************************************************************************
127 * @ dst  : pointer on the destination thread descriptor.
128 * @ src  : pointer on the source thread descriptor.
129 ***************************************************************************************/
130void hal_fpu_context_copy( struct thread_s * dst,
131                           struct thread_s * src );
132
133/****************************************************************************************
134 * This function releases the physical memory allocated for a FPU context.
135 ****************************************************************************************
136 * @ thread  : pointer on the thread descriptor.
137 ***************************************************************************************/
138void hal_fpu_context_destroy( struct thread_s * thread );
139
140/****************************************************************************************
141 * This function is used to implement the fork() system call.
142 * It saves in a remote thread FPU context the current FPU registers values.
143 ****************************************************************************************
144 * @ thread_xp  : extended pointer on the remote thread descriptor.
145 ***************************************************************************************/
146void hal_fpu_context_save( xptr_t thread_xp );
147
148/****************************************************************************************
149 * This function restores from the calling thread FPU context the FPU registers values.
150 ****************************************************************************************
151 * @ thread  : pointer on the thread descriptor.
152 ***************************************************************************************/
153void hal_fpu_context_restore( struct thread_s * thread );
154
155#endif  /* _HAL_CONTEXT_H_ */
Note: See TracBrowser for help on using the repository browser.