source: trunk/hal/generic/hal_gpt.h @ 625

Last change on this file since 625 was 625, checked in by alain, 5 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: 13.5 KB
Line 
1/*
2 * hal_gpt.h - Generic Page Table API definition.
3 *
4 * Authors  Alain Greiner (2016)
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 _GPT_H_
25#define _GPT_H_
26
27#include <hal_kernel_types.h>
28
29/////////////////////////////////////////////////////////////////////////////////////////
30//           Generic Page Table Definition (implementation in hal_gpt.c)
31//
32// It is specified as a simple (one dimensional) array indexed by the VPN (vpn_t type),
33// even if implementations can use a more sophisticated organisation (two-levels or more).
34// - The number of entries (number of pages in a virtual space) is architecture
35//   dependent, and is defined as (CONFIG_USER_SPACE_SIZE / CONFIG_PPM_PAGE_SIZE).
36// - Each entry contains a Physical Page Number (ppn_t type), and a set of attributes,
37//   defined as a 32 bits-vector.
38//
39// Any arch-specific implementation must implement this API.
40/////////////////////////////////////////////////////////////////////////////////////////
41
42/****  Forward declarations  ****/
43
44struct page_s;
45struct process_s;
46
47/****************************************************************************************
48 * These macros define the masks for the Generic Page Table Entry attributes.
49 ***************************************************************************************/
50
51#define GPT_MAPPED      0x0001       /*! PTE is mapped                                 */
52#define GPT_SMALL       0x0002       /*! PTE is a small page                           */
53#define GPT_READABLE    0x0004       /*! PTE is readable                               */
54#define GPT_WRITABLE    0x0008       /*! PTE is writable                               */
55#define GPT_EXECUTABLE  0x0010       /*! PTE is executable                             */
56#define GPT_CACHABLE    0x0020       /*! PTE can be cached                             */
57#define GPT_USER        0x0040       /*! PTE is user accessible                        */
58#define GPT_DIRTY       0x0080       /*! PTE has been written                          */
59#define GPT_ACCESSED    0x0100       /*! PTE has been "recently" accessed              */
60#define GPT_GLOBAL      0x0200       /*! PTE is kept in TLB at context switch          */
61#define GPT_COW         0x0400       /*! PTE must be copied on write                   */
62#define GPT_SWAP        0x0800       /*! PTE swapped on disk (not implemented yet)     */
63#define GPT_LOCKED      0x1000       /*! PTE is protected against concurrent access    */
64
65/****************************************************************************************
66 * This structure defines the Generic Page Table descriptor.
67 ***************************************************************************************/
68
69typedef struct gpt_s
70{
71        void           * ptr;    /*! local pointer on GPT root                             */
72        ppn_t            ppn;    /*! PPN of GPT root                                       */
73}
74gpt_t;
75
76
77/****************************************************************************************
78 * This function allocates physical memory for first level page table (PT1),
79 * and initializes the GPT descriptor, creating an empty GPT.
80 ****************************************************************************************
81 * @ gpt     : pointer on generic page table descriptor.
82 * @ returns 0 if success / returns ENOMEM if error.
83 ***************************************************************************************/
84error_t hal_gpt_create( gpt_t * gpt );
85
86/****************************************************************************************
87 * This function releases all memory dynamically allocated for a generic page table.
88 * For a multi-levels radix tree implementation, it includes all nodes in the tree.
89 * If the calling thread is running in the reference cluster, it checks that user PTE
90 * entries are unmapped, and releases the mapped physical pages.
91 * The kernel pages are not released.
92 ****************************************************************************************
93 * @ gpt     : pointer on generic page table descriptor.
94 ***************************************************************************************/
95void hal_gpt_destroy( gpt_t * gpt);
96
97/****************************************************************************************
98 * This function prints on the kernel terminal the content of a generic page table.
99 ****************************************************************************************
100 * @ process : pointer on local process descriptor.
101 ***************************************************************************************/
102void hal_gpt_display( struct process_s * process );
103
104/****************************************************************************************
105 * This blocking function gets a lock on a PTE (Page Table Entry) identified
106 * by its VPN, and returns only when the PTE has been successfully locked.
107 * If the target PTE is not present, it allocates and maps a physical page.
108 * A big page cannot be locked.
109 ****************************************************************************************
110 * @ gpt     : pointer on the generic page table
111 * @ vpn     : virtual page number of the target PTE.
112 * @ returns 0 if success / return ENOMEM or EINVAL if error.
113 ***************************************************************************************/
114error_t hal_gpt_lock_pte( gpt_t * gpt,
115                          vpn_t   vpn );
116
117/****************************************************************************************
118 * This function releases the lock on a PTE identified by its VPN.
119 ****************************************************************************************
120 * @ gpt     : pointer on the generic page table
121 * @ vpn     : virtual page number of the target PTE.
122 * @ returns 0 if success / returns EINVAL if error.
123 ***************************************************************************************/
124error_t hal_gpt_unlock_pte( gpt_t * gpt,
125                            vpn_t   vpn );
126
127/****************************************************************************************
128 * This function maps in a - local or remote - GPT identified by the <gpt_xp> argument
129 * an entry identified by the <vpn> argument, as defined by <ppn> and <attr> arguments.
130 * It allocates physical memory for the GPT PT2, using a RPC_PMEM_GET_PAGES if required.
131 ****************************************************************************************
132 * @ gpt_xp    : [in] pointer on the page table
133 * @ vpn       : [in] virtual page number
134 * @ attr      : [in] generic attributes
135 * @ ppn       : [in] physical page number
136 * @ returns 0 if success / returns ENOMEM if error
137 ***************************************************************************************/
138error_t hal_gpt_set_pte( xptr_t     gpt_xp,
139                         vpn_t      vpn,
140                         uint32_t   attr,
141                         ppn_t      ppn );
142
143/****************************************************************************************
144 * This function unmaps all pages identified by the <vpn> argument from the local GPT
145 * identified by the <gpt> argument.
146 * It does NOT release the physical memory allocated for the unmapped pages.
147 ****************************************************************************************
148 * @ gpt      : [in] pointer on the local page table
149 * @ vpn      : [in] page index in virtual space
150 ***************************************************************************************/
151void hal_gpt_reset_pte( gpt_t * gpt,
152                        vpn_t   vpn );
153
154/****************************************************************************************
155 * This function returns in the <attr> and <ppn> arguments the current values stored
156 * in a - local or remote - GPT entry, identified by the <gpt> and <vpn> arguments.
157 ****************************************************************************************
158 * @ gpt_xp    : [in]  extended pointer on the page table
159 * @ vpn       : [in]  virtual page number
160 * @ attr      : [out] generic attributes
161 * @ ppn       : [out] physical page number
162 ***************************************************************************************/
163void hal_gpt_get_pte( xptr_t     gpt_xp,
164                      vpn_t      vpn,
165                      uint32_t * attr,
166                      ppn_t    * ppn );
167
168/****************************************************************************************
169 * This function is used to implement the "fork" system call: It copies a remote
170 * source PTE, identified by the <src_gpt_xp> and <src_vpn> arguments, to a local
171 * destination PTE, identified by the <dst_gpt> and <dst_vpn> arguments.
172 * It does nothing if the source PTE is not MAPPED and SMALL.
173 * It optionnally activates the "Copy on Write" mechanism: when the <cow> argument is
174 * true: the GPT_WRITABLE flag is reset, and the GPT_COW flag is set.
175 * A new second level PT2 is allocated for the destination GPT if required.
176 * It returns in the <ppn> and <mapped> arguments the PPN value for the copied PTE,
177 * and a boolean indicating if the PTE is mapped and small, and was actually copied.
178 ****************************************************************************************
179 * @ dst_gpt      : [in]  local pointer on local destination GPT.
180 * @ dst_vpn      : [in]  vpn defining the PTE in the desination GPT.
181 * @ src_gpt_xp   : [in]  extended pointer on remote source GPT.
182 * @ src_vpn      : [in]  vpn defining the PTE in the source GPT.
183 * @ cow          : [in]  activate the COPY-On-Write mechanism if true.
184 * @ ppn          : [out] PPN value (only if mapped is true).
185 * @ mapped       : [out] true if src_gpt[vpn] actually copied to dst_gpt[vpn].
186 * @ return 0 if success / return -1 if no memory for a new PT2.
187 ***************************************************************************************/
188error_t hal_gpt_pte_copy( gpt_t    * dst_gpt,
189                          vpn_t      dst_vpn,
190                          xptr_t     src_gpt_xp,
191                          vpn_t      src_vpn,
192                          bool_t     cow,
193                          ppn_t    * ppn,
194                          bool_t   * mapped );
195
196/****************************************************************************************
197 * This function returns true if the MAPPED and SMALL flags are both set
198 * for a PTE defined by <gpt> and <vpn> arguments.
199 ****************************************************************************************
200 * @ gpt       : [in]  pointer on the page table
201 * @ vpn       : [in]  virtual page number
202 * @ returns true if MAPPED is set.
203 ***************************************************************************************/
204bool_t hal_gpt_pte_is_mapped( gpt_t * gpt,
205                              vpn_t   vpn );
206
207/****************************************************************************************
208 * This function returns true if the MAPPED, SMALL, and COW flags are all set
209 * for a PTE defined by <gpt> and <vpn> arguments.
210 ****************************************************************************************
211 * @ gpt       : [in]  pointer on the page table
212 * @ vpn       : [in]  virtual page number
213 * @ returns true if COW is set.
214 ***************************************************************************************/
215bool_t hal_gpt_pte_is_cow( gpt_t * gpt,
216                           vpn_t   vpn );
217
218/****************************************************************************************
219 * This function atomically set the COW flag and reset the WRITABLE flag for all PTEs
220 * of a remote GPT identified by the <gpt_xp>, <vpn_base>, and <vpn_size arguments.
221 * It does nothing if the remote PTE is not MAPPED and SMALL.
222 ****************************************************************************************
223 * @ gpt_xp    : [in]  extended pointer on the remote GPT.
224 * @ vpn_base  : [in]  first virtual page.
225 * @ vpn_size  : [in]  number of pages.
226 ***************************************************************************************/
227void hal_gpt_set_cow( xptr_t  gpt_xp,
228                      vpn_t   vpn_base,
229                      vpn_t   vpn_size );
230
231/****************************************************************************************
232 * This function is used to maintain coherence amongst the multiple GPT copies.
233 * It modifies an existing entry identified by the <vpn> argument in a remote GPT
234 * identified by the <gpt_xp> argument, using remote accesses.
235 * It cannot fail, because only MAPPED & SMALL entries are modified.
236 ****************************************************************************************
237 * @ gpt_xp    : [in] extended pointer on the page table
238 * @ vpn       : [in] virtual page number
239 * @ attr      : [in] generic attributes
240 * @ ppn       : [in] physical page number
241 ***************************************************************************************/
242void hal_gpt_update_pte( xptr_t     gpt_xp,
243                         vpn_t      vpn,
244                         uint32_t   attr,
245                         ppn_t      ppn );
246
247
248#endif  /* _GPT_H_ */
249
Note: See TracBrowser for help on using the repository browser.