source: trunk/kernel/mm/ppm.h @ 621

Last change on this file since 621 was 611, checked in by alain, 6 years ago

Introduce sigificant modifs in VFS to support the <ls> command,
and the . and .. directories entries.
File size: 12.9 KB
Line 
1/*
2 * ppm.h - Per-cluster Physical Pages Manager definition.
3 *
4 * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
5 *          Alain Greiner    (2016,2017,2018)
6 *
7 * Copyright (c) UPMC Sorbonne Universites
8 *
9 * This file is part of ALMOS-MKH.
10 *
11 * ALMOS-kernel is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2.0 of the License.
14 *
15 * ALMOS-kernel is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with ALMOS-kernel; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25#ifndef _PPM_H_
26#define _PPM_H_
27
28#include <hal_kernel_types.h>
29#include <list.h>
30#include <busylock.h>
31#include <remote_queuelock.h>
32#include <boot_info.h>
33#include <page.h>
34
35
36/*****************************************************************************************
37 * This structure defines the Physical Pages Manager in a cluster.
38 * In each cluster, the physical memory bank starts at local physical address 0 and
39 * contains an integer number of pages, defined by the <pages_nr> field in the
40 * boot_info structure. It is split in three parts:
41 *
42 * - the "kernel_code" section contains the kernel code, loaded by the boot-loader.
43 *   It starts at PPN = 0 and the size is defined by the <pages_offset> field in the
44 *   boot_info structure.
45 * - the "pages_tbl" section contains the physical page descriptors array. It starts
46 *   at PPN = pages_offset, and it contains one entry per small physical page in cluster.
47 *   It is created and initialized by the hal_ppm_create() function.
48 * - The "kernel_heap" section contains all physical pages that are are not in the
49 *   kernel_code and pages_tbl sections, and that have not been reserved by the
50 *   architecture specific bootloader. The reserved pages are defined in the boot_info
51 *   structure.
52 *
53 * The main service provided by the PMM is the dynamic allocation of physical pages
54 * from the "kernel_heap" section. This low-level allocator implements the buddy
55 * algorithm: an allocated block is an integer number n of small pages, where n
56 * is a power of 2, and ln(n) is called order.
57 * This allocator being shared by the local threads, the free_page lists rooted
58 * in the PPM descriptor are protected by a local busylock, because it is used
59 * by the idle_thread during kernel_init().
60 *
61 * Another service is to register the dirty pages in a specific dirty_list, that is
62 * also rooted in the PPM, in order to be able to save all dirty pages on disk.
63 * This dirty list is protected by a specific remote_queuelock, because it can be
64 * modified by a remote thread, but it contains only local pages.
65 ****************************************************************************************/
66
67typedef struct ppm_s
68{
69        busylock_t          free_lock;          /*! lock protecting free_pages[] lists      */
70        list_entry_t        free_pages_root[CONFIG_PPM_MAX_ORDER];  /*! roots of free lists */
71        uint32_t            free_pages_nr[CONFIG_PPM_MAX_ORDER];    /*! free pages number   */
72        page_t            * pages_tbl;          /*! pointer on page descriptors array       */
73        uint32_t            pages_nr;           /*! total number of small physical page     */
74    remote_queuelock_t  dirty_lock;         /*! lock protecting dirty pages list        */
75    list_entry_t        dirty_root;         /*! root of dirty pages list                */
76    void              * vaddr_base;         /*! pointer on local physical memory base   */
77}
78ppm_t;
79
80/************** functions to allocate / release physical pages  *************************/
81
82/*****************************************************************************************
83 * This is the low-level physical pages allocation function.
84 * It allocates N contiguous physical pages. N is a power of 2.
85 * In normal use, it should not be called directly, as the recommended way to get
86 * physical pages is to call the generic allocator defined in kmem.h.
87 *****************************************************************************************
88 * @ order        : ln2( number of 4 Kbytes pages)
89 * @ returns a pointer on the page descriptor if success / NULL otherwise
90 ****************************************************************************************/
91page_t * ppm_alloc_pages( uint32_t order );
92
93/*****************************************************************************************
94 * This is the low-level physical pages release function. It takes the lock protecting
95 * the free_list before register the released page in the relevant free_list.
96 * In normal use, you do not need to call it directly, as the recommended way to free
97 * physical pages is to call the generic allocator defined in kmem.h.
98 *****************************************************************************************
99 * @ page         : pointer to the page descriptor to be released
100 ****************************************************************************************/
101void ppm_free_pages( page_t * page );
102
103/*****************************************************************************************
104 * This function does the same as the ppm_free_page() function, without taking the lock.
105 * It is used by the hal_ppm_init() function to initialize the pages_tbl[] array, when
106 * there is no concurrent access issue.
107 *****************************************************************************************
108 * @ page         : pointer to the page descriptor to be released
109 ****************************************************************************************/
110void ppm_free_pages_nolock( page_t * page );
111
112/*****************************************************************************************
113 * This function check if a page descriptor pointer is valid.
114 *****************************************************************************************
115 * @ page         : pointer on a page descriptor
116 * @ returns true if valid / false otherwise.
117 ****************************************************************************************/
118inline bool_t ppm_page_is_valid( page_t * page );
119
120
121/************** functions to translate [ page <->  base <-> ppn ] ***********************/
122
123/*****************************************************************************************
124 * Get extended pointer on page base from extended pointer on page descriptor.
125 *****************************************************************************************
126 * @ page_xp    : extended pointer to page descriptor
127 * @ returns extended pointer on page base.
128 ****************************************************************************************/
129inline xptr_t ppm_page2base( xptr_t page_xp );
130
131/*****************************************************************************************
132 * Get extended pointer on page descriptor from extended pointer on page base.
133 *****************************************************************************************
134 * @ base_xp   : extended pointer to page base.
135 * @ returns extended pointer on page descriptor
136 ****************************************************************************************/
137inline xptr_t ppm_base2page( xptr_t base_xp );
138
139/*****************************************************************************************
140 * Get extended pointer on page base from global PPN.
141 *****************************************************************************************
142 * @ ppn    : global physical page number.
143 * @ returns extended pointer on page base.
144 ****************************************************************************************/
145inline xptr_t ppm_ppn2base( ppn_t ppn );
146
147/*****************************************************************************************
148 * Get global PPN from extended pointer on page base.
149 *****************************************************************************************
150 * @ base_xp   : extended pointer to page base.
151 * @ returns global physical page number.
152 ****************************************************************************************/
153inline ppn_t ppm_base2ppn( xptr_t base_xp );
154
155/*****************************************************************************************
156 * Get global PPN from extended pointer on page descriptor.
157 *****************************************************************************************
158 * @ page_xp   : pointer to page descriptor
159 * @ returns global physical page number.
160 ****************************************************************************************/
161inline ppn_t ppm_page2ppn( xptr_t page_xp );
162
163/*****************************************************************************************
164 * Get extended pointer on page descriptor from global PPN.
165 *****************************************************************************************
166 * @ ppn       : global physical page number
167 * @ returns extended pointer on page descriptor.
168 ****************************************************************************************/
169inline xptr_t ppm_ppn2page( ppn_t ppn );
170
171
172/*********** debug  functions  **********************************************************/
173
174/*****************************************************************************************
175 * This function prints the PPM allocator status in the calling thread cluster.
176 *****************************************************************************************
177 * string   : character string printed in header
178 ****************************************************************************************/
179void ppm_print( char * string );
180
181/*****************************************************************************************
182 * This function checks PPM allocator consistency.
183 *****************************************************************************************
184 * @ ppm      : pointer on PPM allocator.
185 * @ return 0 if PPM is OK / return -1 if PPM not consistent.
186 ****************************************************************************************/
187error_t ppm_assert_order( ppm_t * ppm );
188
189
190/*********** functions to handle dirty pages  *******************************************/
191
192/*****************************************************************************************
193 * This function registers a page identified by the <page_xp> argument as dirty.
194 * It can be called by a thread running in any cluster.
195 * - it takes the queuelock protecting the PPM dirty_list.
196 * - it takes the busylock protecting the page flags.
197 * - it test the PG_DIRTY flag in the page descriptor.
198 *   . if page already dirty => do nothing
199 *   . it page not dirty => set the PG_DIRTY flag and register page in PPM dirty list.
200 * - it releases the busylock protcting the page flags.
201 * - it releases the queuelock protecting the PPM dirty_list.
202 *****************************************************************************************
203 * @ page_xp  : extended pointer on page descriptor.
204 * @ returns true if page was not dirty / returns false if page was dirty
205 ****************************************************************************************/
206bool_t ppm_page_do_dirty( xptr_t page_xp );
207
208/*****************************************************************************************
209 * This function unregisters a page identified by the <page_xp> argument as dirty.
210 * It can be called by a thread running in any cluster.
211 * - it takes the queuelock protecting the PPM dirty_list.
212 * - it takes the busylock protecting the page flags.
213 * - it test the PG_DIRTY flag in the page descriptor.
214 *   . if page not dirty => do nothing
215 *   . it page dirty => reset the PG_DIRTY flag and remove page from PPM dirty list.
216 * - it releases the busylock protcting the page flags.
217 * - it releases the queuelock protecting the PPM dirty_list.
218 *****************************************************************************************
219 * @ page_xp  : extended pointer on page descriptor.
220 * @ returns true if page was dirty / returns false if page was not dirty
221 ****************************************************************************************/
222bool_t ppm_page_undo_dirty( xptr_t page_xp );
223
224/*****************************************************************************************
225 * This function synchronizes (i.e. update the IOC device) all dirty pages in a cluster.
226 * - it takes the queuelock protecting the PPM dirty_list.
227 * - it scans the PPM dirty list, and for each page:
228 *   . it takes the lock protecting the page.
229 *   . it removes the page from the PPM dirty_list.
230 *   . it reset the PG_DIRTY flag.
231 *   . it releases the lock protecting the page.
232 * - it releases the queuelock protecting the PPM dirty_list.
233 $ The PPM dirty_list is empty when the sync operation completes.
234 ****************************************************************************************/
235void ppm_sync_dirty_pages( void );
236
237#endif  /* _PPM_H_ */
Note: See TracBrowser for help on using the repository browser.