Navigation
- Accueil
- Présentation :
- FAQ
- Bugs et errata
- Contributions de lecteurs
- Téléchargements
- LXR (référencement des sources)
- Mailing-list
- Liens et Projets reliés
Site hébergé par :
Site hébergé par :
|
[ source navigation ] [ diff markup ] [ identifier search ] [ general search ] |
|||
|
||||
001 /* Copyright (C) 2004 David Decotigny 001 /* Copyright (C) 2004 David Decotigny >> 002 Copyright (C) 2000 The KOS Team 002 003 003 This program is free software; you can redi 004 This program is free software; you can redistribute it and/or 004 modify it under the terms of the GNU Genera 005 modify it under the terms of the GNU General Public License 005 as published by the Free Software Foundatio 006 as published by the Free Software Foundation; either version 2 006 of the License, or (at your option) any lat 007 of the License, or (at your option) any later version. 007 008 008 This program is distributed in the hope tha 009 This program is distributed in the hope that it will be useful, 009 but WITHOUT ANY WARRANTY; without even the 010 but WITHOUT ANY WARRANTY; without even the implied warranty of 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR 011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 011 GNU General Public License for more details 012 GNU General Public License for more details. 012 013 013 You should have received a copy of the GNU 014 You should have received a copy of the GNU General Public License 014 along with this program; if not, write to t 015 along with this program; if not, write to the Free Software 015 Foundation, Inc., 59 Temple Place - Suite 3 016 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 016 USA. 017 USA. 017 */ 018 */ 018 #include <sos/list.h> 019 #include <sos/list.h> 019 #include <sos/macros.h> 020 #include <sos/macros.h> 020 #include <sos/assert.h> 021 #include <sos/assert.h> 021 #include <sos/klibc.h> 022 #include <sos/klibc.h> 022 023 023 #include "physmem.h" 024 #include "physmem.h" 024 025 025 /** A descriptor for a physical page in SOS */ 026 /** A descriptor for a physical page in SOS */ 026 struct physical_page_descr 027 struct physical_page_descr 027 { 028 { 028 /** The physical base address for the page * 029 /** The physical base address for the page */ 029 sos_paddr_t paddr; 030 sos_paddr_t paddr; 030 031 031 /** The reference count for this physical pa 032 /** The reference count for this physical page. > 0 means that the 032 page is in the used list. */ !! 033 page is in the nonfree list. */ 033 sos_count_t ref_cnt; 034 sos_count_t ref_cnt; 034 035 >> 036 /** >> 037 * An additional counter for user-defined use. The management of this >> 038 * counter is up to the user, however a simple set of rules applies: >> 039 * - it can only be incremented/decremented if the page is referenced >> 040 * - when it reaches 0, no automatic action is taken >> 041 * The first rule means in particular that a page whose reference >> 042 * count reaches 0 (=> will be freed) cannot have a custom_count >> 043 * value > 0 ! The system will be HALTED if this ever happens >> 044 */ >> 045 sos_count_t occupation_cnt; >> 046 >> 047 035 /** Some data associated with the page when 048 /** Some data associated with the page when it is mapped in kernel space */ 036 struct sos_kmem_range *kernel_range; 049 struct sos_kmem_range *kernel_range; 037 050 038 /** The other pages on the list (used, free) !! 051 /** The other pages on the list (nonfree, free) */ 039 struct physical_page_descr *prev, *next; 052 struct physical_page_descr *prev, *next; 040 }; 053 }; 041 054 042 /** These are some markers present in the exec 055 /** These are some markers present in the executable file (see sos.lds) */ 043 extern char __b_kernel, __e_kernel; 056 extern char __b_kernel, __e_kernel; 044 057 045 /** The array of ppage descriptors will be loc 058 /** The array of ppage descriptors will be located at this address */ 046 #define PAGE_DESCR_ARRAY_ADDR \ 059 #define PAGE_DESCR_ARRAY_ADDR \ 047 SOS_PAGE_ALIGN_SUP((sos_paddr_t) (& __e_kern 060 SOS_PAGE_ALIGN_SUP((sos_paddr_t) (& __e_kernel)) 048 static struct physical_page_descr * physical_p 061 static struct physical_page_descr * physical_page_descr_array; 049 062 050 /** The list of physical pages currently avail 063 /** The list of physical pages currently available */ 051 static struct physical_page_descr *free_ppage; 064 static struct physical_page_descr *free_ppage; 052 065 053 /** The list of physical pages currently in us !! 066 /** The list of physical pages currently allocated */ 054 static struct physical_page_descr *used_ppage; !! 067 static struct physical_page_descr *nonfree_ppage; 055 068 056 /** We will store here the interval of valid p 069 /** We will store here the interval of valid physical addresses */ 057 static sos_paddr_t physmem_base, physmem_top; 070 static sos_paddr_t physmem_base, physmem_top; 058 071 059 /** We store the number of pages used/free */ !! 072 /** We store the number of pages nonfree/free */ 060 static sos_count_t physmem_total_pages, physme !! 073 static sos_count_t physmem_total_pages, physmem_nonfree_pages; 061 074 062 sos_ret_t sos_physmem_setup(sos_size_t ram_siz !! 075 sos_ret_t sos_physmem_subsystem_setup(sos_size_t ram_size, 063 /* out */sos_paddr !! 076 /* out */sos_paddr_t *kernel_core_base, 064 /* out */sos_paddr !! 077 /* out */sos_paddr_t *kernel_core_top) 065 { 078 { 066 /* The iterator over the page descriptors */ 079 /* The iterator over the page descriptors */ 067 struct physical_page_descr *ppage_descr; 080 struct physical_page_descr *ppage_descr; 068 081 069 /* The iterator over the physical addresses 082 /* The iterator over the physical addresses */ 070 sos_paddr_t ppage_addr; 083 sos_paddr_t ppage_addr; 071 084 072 /* Make sure ram size is aligned on a page b 085 /* Make sure ram size is aligned on a page boundary */ 073 ram_size = SOS_PAGE_ALIGN_INF(ram_size);/* Y 086 ram_size = SOS_PAGE_ALIGN_INF(ram_size);/* Yes, we may lose at most a page */ 074 087 075 /* Reset the used/free page lists before bui !! 088 /* Reset the nonfree/free page lists before building them */ 076 free_ppage = used_ppage = NULL; !! 089 free_ppage = nonfree_ppage = NULL; 077 physmem_total_pages = physmem_used_pages = 0 !! 090 physmem_total_pages = physmem_nonfree_pages = 0; 078 091 079 /* Make sure that there is enough memory to 092 /* Make sure that there is enough memory to store the array of page 080 descriptors */ 093 descriptors */ 081 *kernel_core_base = SOS_PAGE_ALIGN_INF((sos_ 094 *kernel_core_base = SOS_PAGE_ALIGN_INF((sos_paddr_t)(& __b_kernel)); 082 *kernel_core_top 095 *kernel_core_top 083 = PAGE_DESCR_ARRAY_ADDR 096 = PAGE_DESCR_ARRAY_ADDR 084 + SOS_PAGE_ALIGN_SUP( (ram_size >> SOS_P 097 + SOS_PAGE_ALIGN_SUP( (ram_size >> SOS_PAGE_SHIFT) 085 * sizeof(struct ph 098 * sizeof(struct physical_page_descr)); 086 if (*kernel_core_top > ram_size) 099 if (*kernel_core_top > ram_size) 087 return -SOS_ENOMEM; 100 return -SOS_ENOMEM; 088 101 089 /* Page 0-4kB is not available in order to r 102 /* Page 0-4kB is not available in order to return address 0 as a 090 means to signal "no page available" */ 103 means to signal "no page available" */ 091 physmem_base = SOS_PAGE_SIZE; 104 physmem_base = SOS_PAGE_SIZE; 092 physmem_top = ram_size; 105 physmem_top = ram_size; 093 106 094 /* Setup the page descriptor arrray */ 107 /* Setup the page descriptor arrray */ 095 physical_page_descr_array 108 physical_page_descr_array 096 = (struct physical_page_descr*)PAGE_DESCR_ 109 = (struct physical_page_descr*)PAGE_DESCR_ARRAY_ADDR; 097 110 098 /* Scan the list of physical pages */ 111 /* Scan the list of physical pages */ 099 for (ppage_addr = 0, 112 for (ppage_addr = 0, 100 ppage_descr = physical_page_descr_arr 113 ppage_descr = physical_page_descr_array ; 101 ppage_addr < physmem_top ; 114 ppage_addr < physmem_top ; 102 ppage_addr += SOS_PAGE_SIZE, 115 ppage_addr += SOS_PAGE_SIZE, 103 ppage_descr ++) 116 ppage_descr ++) 104 { 117 { 105 enum { PPAGE_MARK_RESERVED, PPAGE_MARK_F 118 enum { PPAGE_MARK_RESERVED, PPAGE_MARK_FREE, 106 PPAGE_MARK_KERNEL, PPAGE_MARK_HWM 119 PPAGE_MARK_KERNEL, PPAGE_MARK_HWMAP } todo; 107 120 108 memset(ppage_descr, 0x0, sizeof(struct p 121 memset(ppage_descr, 0x0, sizeof(struct physical_page_descr)); 109 122 110 /* Init the page descriptor for this pag 123 /* Init the page descriptor for this page */ 111 ppage_descr->paddr = ppage_addr; 124 ppage_descr->paddr = ppage_addr; 112 125 113 /* Reserved : 0 ... base */ 126 /* Reserved : 0 ... base */ 114 if (ppage_addr < physmem_base) 127 if (ppage_addr < physmem_base) 115 todo = PPAGE_MARK_RESERVED; 128 todo = PPAGE_MARK_RESERVED; 116 129 117 /* Free : base ... BIOS */ 130 /* Free : base ... BIOS */ 118 else if ((ppage_addr >= physmem_base) 131 else if ((ppage_addr >= physmem_base) 119 && (ppage_addr < BIOS_N_VIDEO_S 132 && (ppage_addr < BIOS_N_VIDEO_START)) 120 todo = PPAGE_MARK_FREE; 133 todo = PPAGE_MARK_FREE; 121 134 122 /* Used : BIOS */ 135 /* Used : BIOS */ 123 else if ((ppage_addr >= BIOS_N_VIDEO_STA 136 else if ((ppage_addr >= BIOS_N_VIDEO_START) 124 && (ppage_addr < BIOS_N_VIDEO_E 137 && (ppage_addr < BIOS_N_VIDEO_END)) 125 todo = PPAGE_MARK_HWMAP; 138 todo = PPAGE_MARK_HWMAP; 126 139 127 /* Free : BIOS ... kernel */ 140 /* Free : BIOS ... kernel */ 128 else if ((ppage_addr >= BIOS_N_VIDEO_END 141 else if ((ppage_addr >= BIOS_N_VIDEO_END) 129 && (ppage_addr < (sos_paddr_t) 142 && (ppage_addr < (sos_paddr_t) (& __b_kernel))) 130 todo = PPAGE_MARK_FREE; 143 todo = PPAGE_MARK_FREE; 131 144 132 /* Used : Kernel code/data/bss + physcal 145 /* Used : Kernel code/data/bss + physcal page descr array */ 133 else if ((ppage_addr >= *kernel_core_bas 146 else if ((ppage_addr >= *kernel_core_base) 134 && (ppage_addr < *kernel_core_ 147 && (ppage_addr < *kernel_core_top)) 135 todo = PPAGE_MARK_KERNEL; 148 todo = PPAGE_MARK_KERNEL; 136 149 137 /* Free : first page of descr ... end of 150 /* Free : first page of descr ... end of RAM */ 138 else 151 else 139 todo = PPAGE_MARK_FREE; 152 todo = PPAGE_MARK_FREE; 140 153 141 /* Actually does the insertion in the us !! 154 /* Actually does the insertion in the nonfree/free page lists */ 142 physmem_total_pages ++; 155 physmem_total_pages ++; 143 switch (todo) 156 switch (todo) 144 { 157 { 145 case PPAGE_MARK_FREE: 158 case PPAGE_MARK_FREE: 146 ppage_descr->ref_cnt = 0; 159 ppage_descr->ref_cnt = 0; 147 list_add_head(free_ppage, ppage_desc 160 list_add_head(free_ppage, ppage_descr); 148 break; 161 break; 149 162 150 case PPAGE_MARK_KERNEL: 163 case PPAGE_MARK_KERNEL: 151 case PPAGE_MARK_HWMAP: 164 case PPAGE_MARK_HWMAP: 152 ppage_descr->ref_cnt = 1; 165 ppage_descr->ref_cnt = 1; 153 list_add_head(used_ppage, ppage_desc !! 166 list_add_head(nonfree_ppage, ppage_descr); 154 physmem_used_pages ++; !! 167 physmem_nonfree_pages ++; 155 break; 168 break; 156 169 157 default: 170 default: 158 /* Reserved page: nop */ 171 /* Reserved page: nop */ 159 break; 172 break; 160 } 173 } 161 } 174 } 162 175 163 return SOS_OK; 176 return SOS_OK; 164 } 177 } 165 178 166 179 167 sos_paddr_t sos_physmem_ref_physpage_new(sos_b 180 sos_paddr_t sos_physmem_ref_physpage_new(sos_bool_t can_block) 168 { 181 { 169 struct physical_page_descr *ppage_descr; 182 struct physical_page_descr *ppage_descr; 170 183 171 if (! free_ppage) 184 if (! free_ppage) 172 return (sos_paddr_t)NULL; 185 return (sos_paddr_t)NULL; 173 186 174 /* Retrieve a page in the free list */ 187 /* Retrieve a page in the free list */ 175 ppage_descr = list_pop_head(free_ppage); 188 ppage_descr = list_pop_head(free_ppage); 176 189 177 /* The page is assumed not to be already use !! 190 /* The page is assumed not to be already in the nonfree list */ 178 SOS_ASSERT_FATAL(ppage_descr->ref_cnt == 0); 191 SOS_ASSERT_FATAL(ppage_descr->ref_cnt == 0); 179 192 180 /* Mark the page as used (this of course set !! 193 /* Mark the page as nonfree (this of course sets the ref count to 1) */ 181 ppage_descr->ref_cnt ++; 194 ppage_descr->ref_cnt ++; 182 195 183 /* No associated kernel range by default */ !! 196 /* The page descriptor should be unmodified since previous 184 ppage_descr->kernel_range = NULL; !! 197 deallocation. Otherwise this means that something unauthorized >> 198 overwrote the page descriptor table contents ! */ >> 199 SOS_ASSERT_FATAL(ppage_descr->occupation_cnt == 0); >> 200 SOS_ASSERT_FATAL(ppage_descr->kernel_range == NULL); 185 201 186 /* Put the page in the used list */ !! 202 /* Put the page in the nonfree list */ 187 list_add_tail(used_ppage, ppage_descr); !! 203 list_add_tail(nonfree_ppage, ppage_descr); 188 physmem_used_pages ++; !! 204 physmem_nonfree_pages ++; 189 205 190 return ppage_descr->paddr; 206 return ppage_descr->paddr; 191 } 207 } 192 208 193 209 194 /** 210 /** 195 * Helper function to get the physical page de 211 * Helper function to get the physical page descriptor for the given 196 * physical page address. 212 * physical page address. 197 * 213 * 198 * @return NULL when out-of-bounds or non-page 214 * @return NULL when out-of-bounds or non-page-aligned 199 */ 215 */ 200 inline static struct physical_page_descr * 216 inline static struct physical_page_descr * 201 get_page_descr_at_paddr(sos_paddr_t ppage_padd 217 get_page_descr_at_paddr(sos_paddr_t ppage_paddr) 202 { 218 { 203 /* Don't handle non-page-aligned addresses * 219 /* Don't handle non-page-aligned addresses */ 204 if (ppage_paddr & SOS_PAGE_MASK) 220 if (ppage_paddr & SOS_PAGE_MASK) 205 return NULL; 221 return NULL; 206 222 207 /* Don't support out-of-bounds requests */ 223 /* Don't support out-of-bounds requests */ 208 if ((ppage_paddr < physmem_base) || (ppage_p 224 if ((ppage_paddr < physmem_base) || (ppage_paddr >= physmem_top)) 209 return NULL; 225 return NULL; 210 226 211 return physical_page_descr_array + (ppage_pa 227 return physical_page_descr_array + (ppage_paddr >> SOS_PAGE_SHIFT); 212 } 228 } 213 229 214 230 215 sos_ret_t sos_physmem_ref_physpage_at(sos_padd 231 sos_ret_t sos_physmem_ref_physpage_at(sos_paddr_t ppage_paddr) 216 { 232 { 217 struct physical_page_descr *ppage_descr 233 struct physical_page_descr *ppage_descr 218 = get_page_descr_at_paddr(ppage_paddr); 234 = get_page_descr_at_paddr(ppage_paddr); 219 235 220 if (! ppage_descr) 236 if (! ppage_descr) 221 return -SOS_EINVAL; 237 return -SOS_EINVAL; 222 238 223 /* Increment the reference count for the pag 239 /* Increment the reference count for the page */ 224 ppage_descr->ref_cnt ++; 240 ppage_descr->ref_cnt ++; 225 241 226 /* If the page is newly referenced (ie we ar 242 /* If the page is newly referenced (ie we are the only owners of the 227 page => ref cnt == 1), transfer it in the !! 243 page => ref cnt == 1), transfer it in the nonfree pages list */ 228 if (ppage_descr->ref_cnt == 1) 244 if (ppage_descr->ref_cnt == 1) 229 { 245 { >> 246 /* The page descriptor should be unmodified since previous >> 247 deallocation. Otherwise this means that something unauthorized >> 248 overwrote the page descriptor table contents ! */ >> 249 SOS_ASSERT_FATAL(ppage_descr->occupation_cnt == 0); >> 250 SOS_ASSERT_FATAL(ppage_descr->kernel_range == NULL); >> 251 230 list_delete(free_ppage, ppage_descr); 252 list_delete(free_ppage, ppage_descr); 231 !! 253 list_add_tail(nonfree_ppage, ppage_descr); 232 /* No associated kernel range by default !! 254 physmem_nonfree_pages ++; 233 ppage_descr->kernel_range = NULL; << 234 << 235 list_add_tail(used_ppage, ppage_descr); << 236 physmem_used_pages ++; << 237 255 238 /* The page is newly referenced */ 256 /* The page is newly referenced */ 239 return FALSE; 257 return FALSE; 240 } 258 } 241 !! 259 242 /* The page was already referenced by someon 260 /* The page was already referenced by someone */ 243 return TRUE; 261 return TRUE; 244 } 262 } 245 263 246 264 247 sos_ret_t 265 sos_ret_t 248 sos_physmem_unref_physpage(sos_paddr_t ppage_p 266 sos_physmem_unref_physpage(sos_paddr_t ppage_paddr) 249 { 267 { 250 /* By default the return value indicates tha 268 /* By default the return value indicates that the page is still 251 used */ 269 used */ 252 sos_ret_t retval = FALSE; 270 sos_ret_t retval = FALSE; 253 271 254 struct physical_page_descr *ppage_descr 272 struct physical_page_descr *ppage_descr 255 = get_page_descr_at_paddr(ppage_paddr); 273 = get_page_descr_at_paddr(ppage_paddr); 256 274 257 if (! ppage_descr) 275 if (! ppage_descr) 258 return -SOS_EINVAL; 276 return -SOS_EINVAL; 259 277 260 /* Don't do anything if the page is not in t !! 278 /* Don't do anything if the page is not in the nonfree list */ 261 if (ppage_descr->ref_cnt <= 0) 279 if (ppage_descr->ref_cnt <= 0) 262 return -SOS_EINVAL; 280 return -SOS_EINVAL; 263 281 264 /* Unreference the page, and, when no mappin 282 /* Unreference the page, and, when no mapping is active anymore, put 265 the page in the free list */ 283 the page in the free list */ 266 ppage_descr->ref_cnt--; 284 ppage_descr->ref_cnt--; 267 if (ppage_descr->ref_cnt <= 0) !! 285 if (ppage_descr->ref_cnt == 0) 268 { 286 { >> 287 /* Make sure that the occupation counter is set to 0 */ >> 288 SOS_ASSERT_FATAL(ppage_descr->occupation_cnt == 0); >> 289 269 /* Reset associated kernel range */ 290 /* Reset associated kernel range */ 270 ppage_descr->kernel_range = NULL; 291 ppage_descr->kernel_range = NULL; 271 292 272 /* Transfer the page, considered USED, t !! 293 /* Transfer the page, considered NON-FREE, to the free list */ 273 list_delete(used_ppage, ppage_descr); !! 294 list_delete(nonfree_ppage, ppage_descr); 274 physmem_used_pages --; !! 295 physmem_nonfree_pages --; 275 list_add_head(free_ppage, ppage_descr); 296 list_add_head(free_ppage, ppage_descr); 276 297 277 /* Indicate that the page is now unrefer 298 /* Indicate that the page is now unreferenced */ 278 retval = TRUE; 299 retval = TRUE; 279 } 300 } 280 301 >> 302 /* The page was already referenced by someone */ 281 return retval; 303 return retval; 282 } 304 } 283 305 284 306 >> 307 sos_ret_t sos_physmem_get_physpage_refcount(sos_paddr_t ppage_paddr) >> 308 { >> 309 struct physical_page_descr *ppage_descr >> 310 = get_page_descr_at_paddr(ppage_paddr); >> 311 >> 312 if (! ppage_descr) >> 313 return -SOS_EINVAL; >> 314 >> 315 return ppage_descr->ref_cnt; >> 316 } >> 317 >> 318 >> 319 sos_ret_t sos_physmem_inc_physpage_occupation(sos_paddr_t ppage_paddr) >> 320 { >> 321 struct physical_page_descr *ppage_descr >> 322 = get_page_descr_at_paddr(ppage_paddr); >> 323 >> 324 if (! ppage_descr) >> 325 return -SOS_EINVAL; >> 326 >> 327 /* Don't do anything if the page is not in the nonfree list */ >> 328 SOS_ASSERT_FATAL(ppage_descr->ref_cnt > 0); >> 329 >> 330 ppage_descr->occupation_cnt ++; >> 331 return (ppage_descr->occupation_cnt > 1); >> 332 } >> 333 >> 334 >> 335 sos_ret_t sos_physmem_dec_physpage_occupation(sos_paddr_t ppage_paddr) >> 336 { >> 337 struct physical_page_descr *ppage_descr >> 338 = get_page_descr_at_paddr(ppage_paddr); >> 339 >> 340 if (! ppage_descr) >> 341 return -SOS_EINVAL; >> 342 >> 343 /* Don't do anything if the page is not in the nonfree list */ >> 344 SOS_ASSERT_FATAL(ppage_descr->ref_cnt > 0); >> 345 SOS_ASSERT_FATAL(ppage_descr->occupation_cnt > 0); >> 346 >> 347 ppage_descr->occupation_cnt --; >> 348 return (ppage_descr->occupation_cnt == 0); >> 349 } >> 350 >> 351 285 struct sos_kmem_range* sos_physmem_get_kmem_ra 352 struct sos_kmem_range* sos_physmem_get_kmem_range(sos_paddr_t ppage_paddr) 286 { 353 { 287 struct physical_page_descr *ppage_descr 354 struct physical_page_descr *ppage_descr 288 = get_page_descr_at_paddr(ppage_paddr); 355 = get_page_descr_at_paddr(ppage_paddr); 289 356 290 if (! ppage_descr) 357 if (! ppage_descr) 291 return NULL; 358 return NULL; 292 359 293 return ppage_descr->kernel_range; 360 return ppage_descr->kernel_range; 294 } 361 } 295 362 296 363 297 sos_ret_t sos_physmem_set_kmem_range(sos_paddr 364 sos_ret_t sos_physmem_set_kmem_range(sos_paddr_t ppage_paddr, 298 struct so 365 struct sos_kmem_range *range) 299 { 366 { 300 struct physical_page_descr *ppage_descr 367 struct physical_page_descr *ppage_descr 301 = get_page_descr_at_paddr(ppage_paddr); 368 = get_page_descr_at_paddr(ppage_paddr); 302 369 303 if (! ppage_descr) 370 if (! ppage_descr) 304 return -SOS_EINVAL; 371 return -SOS_EINVAL; 305 372 306 ppage_descr->kernel_range = range; 373 ppage_descr->kernel_range = range; 307 return SOS_OK; 374 return SOS_OK; 308 } 375 } 309 376 310 sos_ret_t sos_physmem_get_state(/* out */sos_c 377 sos_ret_t sos_physmem_get_state(/* out */sos_count_t *total_ppages, 311 /* out */sos_c !! 378 /* out */sos_count_t *nonfree_ppages) 312 { 379 { 313 if (total_ppages) 380 if (total_ppages) 314 *total_ppages = physmem_total_pages; 381 *total_ppages = physmem_total_pages; 315 if (used_ppages) !! 382 if (nonfree_ppages) 316 *used_ppages = physmem_used_pages; !! 383 *nonfree_ppages = physmem_nonfree_pages; 317 return SOS_OK; 384 return SOS_OK; 318 } 385 }
| [ source navigation ] | [ diff markup ] | [ identifier search ] | [ general search ] |