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