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

Last change on this file since 338 was 315, checked in by alain, 7 years ago

Redefine the fuctions ppm_base2page() / ppm_page2base() / ppm_page2ppn() / ppm_ppn2page() / ppm_base2ppn() / ppm_ppn2base(),
to use explicitely extended pointers.
File size: 9.4 KB
RevLine 
[1]1/*
2 * ppm.h - Per-cluster Physical Pages Manager Interface
[18]3 *
[1]4 * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
5 *          Alain Greiner    (2016)
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_types.h>
29#include <list.h>
30#include <spinlock.h>
31#include <boot_info.h>
32#include <page.h>
33
34
35/*****************************************************************************************
36 * This structure defines the Physical Memory Manager in a cluster.
[50]37 * In all clusters, the physical memory bank starts at local physical address 0.
38 * The size of this local physical memory is defined by the <pages_nr> field in the
39 * boot_info structure. It is split in three parts:
40 * - the "kernel_code" section contains the kernel code, loaded by the boot-loader.
41 *   It starts at PPN = 0 and the size is defined by the <pages_offset> field in the
42 *   boot_info structure.
43 * - the "pages_tbl" section contains the physical page descriptors array. It starts
44 *   at PPN = pages_offset, and it contains one entry per small physical page in cluster.
45 *   It is created and initialized by the hal_ppm_create() function. "the
46 * - The "kernel_heap" section contains all physical pages that are are not in the
47 *   in the kernel_code and pages_tbl sections, and that have not been reserved by the
48 *   architecture specific bootloader. The reserved pages are defined in the boot_info
49 *   structure.
[160]50 *
[50]51 * The main service provided by the PMM is the dynamic allocation of physical pages
52 * from the "kernel_heap" section.
[18]53 * This low-level allocator implements the buddy algorithm: an allocated block is
[50]54 * an integer number n of 4 Kbytes pages, and n (called order) is a power of 2.
[1]55 ****************************************************************************************/
[50]56
[1]57typedef struct ppm_s
58{
[50]59        spinlock_t     free_lock;               /*! lock protecting free_pages[] lists      */
[1]60        list_entry_t   free_pages_root[CONFIG_PPM_MAX_ORDER];  /*! roots of free lists      */
61        uint32_t       free_pages_nr[CONFIG_PPM_MAX_ORDER];    /*! numbers of free pages    */
62        page_t       * pages_tbl;               /*! pointer on page descriptors array       */
[50]63        uint32_t       pages_nr;                /*! total number of small physical page     */
64    spinlock_t     dirty_lock;              /*! lock protecting the dirty pages list    */
[1]65    list_entry_t   dirty_root;              /*! root of dirty pages list                */
[160]66    void         * vaddr_base;              /*! pointer on local physical memory base   */
[1]67}
68ppm_t;
69
70/*****************************************************************************************
71 * This is the low-level physical pages allocation function.
72 * It allocates N contiguous physical pages. N is a power of 2.
[18]73 * In normal use, you don't need to call it directly, as the recommended way to get
[1]74 * physical pages is to call the generic allocator defined in kmem.h.
[7]75 *****************************************************************************************
[1]76 * @ order        : ln2( number of 4 Kbytes pages)
77 * @ returns a pointer on the page descriptor if success / NULL otherwise
[50]78 **************************************************************************************à))**/
[1]79page_t * ppm_alloc_pages( uint32_t order );
80
81/*****************************************************************************************
[53]82 * This is the low-level physical pages release function. It takes the lock protecting
83 * the free_list before register the released page in the relevant free_list.
[18]84 * In normal use, you do not need to call it directly, as the recommended way to free
[1]85 * physical pages is to call the generic allocator defined in kmem.h.
[7]86 *****************************************************************************************
[1]87 * @ page         : pointer to the page descriptor to be released
88 ****************************************************************************************/
89void ppm_free_pages( page_t * page );
90
91/*****************************************************************************************
[53]92 * This function does the same as the ppm_free_page() function, without taking the lock.
93 * It is used by the hal_ppm_init() function to initialize the pages_tbl[] array, when
94 * there is no concurrent access issue.
95 *****************************************************************************************
96 * @ page         : pointer to the page descriptor to be released
97 ****************************************************************************************/
98void ppm_free_pages_nolock( page_t * page );
99
100/*****************************************************************************************
[50]101 * This function check if a page descriptor pointer is valid.
[7]102 *****************************************************************************************
[1]103 * @ page         : pointer on a page descriptor
104 * @ returns true if valid / false otherwise.
105 ****************************************************************************************/
106inline bool_t ppm_page_is_valid( page_t * page );
107
[315]108
109
[1]110/*****************************************************************************************
[315]111 * Get extended pointer on page base from extended pointer on page descriptor.
[7]112 *****************************************************************************************
[315]113 * @ page_xp    : extended pointer to page descriptor
114 * @ returns extended pointer on page base.
[1]115 ****************************************************************************************/
[315]116inline xptr_t ppm_page2base( xptr_t page_xp );
[1]117
118/*****************************************************************************************
[315]119 * Get extended pointer on page descriptor from extended pointer on page base.
[7]120 *****************************************************************************************
[315]121 * @ base_xp   : extended pointer to page base.
122 * @ returns extended pointer on page descriptor
[1]123 ****************************************************************************************/
[315]124inline xptr_t ppm_base2page( xptr_t base_xp );
[1]125
[315]126
127
[1]128/*****************************************************************************************
[315]129 * Get extended pointer on page base from Global PPN.
130 *****************************************************************************************
131 * @ ppn    : global physical page number.
132 * @ returns extended pointer on page base.
133 ****************************************************************************************/
134inline xptr_t ppm_ppn2base( ppn_t ppn );
135
136/*****************************************************************************************
137 * Get global PPN from extended pointer on page base.
138 *****************************************************************************************
139 * @ base_xp   : extended pointer to page base.
140 * @ returns global physical page number.
141 ****************************************************************************************/
142inline ppn_t ppm_base2ppn( xptr_t base_xp );
143
144
145
146/*****************************************************************************************
147 * Get global PPN from extended pointer on page descriptor.
148 *****************************************************************************************
149 * @ page_xp   : pointer to page descriptor
150 * @ returns global physical page number.
151 ****************************************************************************************/
152inline ppn_t ppm_page2ppn( xptr_t page_xp );
153
154/*****************************************************************************************
155 * Get extended pointer on page descriptor from global PPN.
156 *****************************************************************************************
157 * @ ppn       : global physical page number
158 * @ returns extended pointer on page descriptor.
159 ****************************************************************************************/
160inline xptr_t ppm_ppn2page( ppn_t ppn );
161
162
163
164/*****************************************************************************************
[1]165 * This function prints the PPM allocator status.
[7]166 *****************************************************************************************
[1]167 * @ ppm      : pointer on PPM allocator.
[7]168 * @ string   : define context of display.
[1]169 ****************************************************************************************/
[7]170void ppm_print( ppm_t * ppm,
171                char  * string );
[1]172
173/*****************************************************************************************
174 * This function checks PPM allocator consistency.
[7]175 *****************************************************************************************
[1]176 * @ ppm      : pointer on PPM allocator.
[53]177 * @ return 0 if PPM is OK / return -1 if PPM not consistent.
[1]178 ****************************************************************************************/
[53]179error_t ppm_assert_order( ppm_t * ppm );
[1]180
181#endif  /* _PPM_H_ */
Note: See TracBrowser for help on using the repository browser.