Diff markup
001 001
002 002
003 003
004 004
005 005
006 006
007 007
008 008
009 009
010 010
011 011
012 012
013 013
014 014
015 015
016 016
017 017
018 018
019 019
020 #include <sos/list.h> 020 #include <sos/list.h>
021 #include <sos/physmem.h> 021 #include <sos/physmem.h>
022 #include <hwcore/paging.h> 022 #include <hwcore/paging.h>
023 #include <sos/assert.h> 023 #include <sos/assert.h>
024 024
025 #include "kmem_vmm.h" 025 #include "kmem_vmm.h"
026 026
027 027
028 struct sos_kmem_range 028 struct sos_kmem_range
029 { 029 {
030 sos_vaddr_t base_vaddr; 030 sos_vaddr_t base_vaddr;
031 sos_count_t nb_pages; 031 sos_count_t nb_pages;
032 032
033 033
034 struct sos_kslab *slab; 034 struct sos_kslab *slab;
035 035
036 struct sos_kmem_range *prev, *next; 036 struct sos_kmem_range *prev, *next;
037 }; 037 };
038 const int sizeof_struct_sos_kmem_range = sizeo 038 const int sizeof_struct_sos_kmem_range = sizeof(struct sos_kmem_range);
039 039
040 040
041 static struct sos_kmem_range *kmem_free_range_ 041 static struct sos_kmem_range *kmem_free_range_list, *kmem_used_range_list;
042 042
043 043
044 static struct sos_kslab_cache *kmem_range_cach 044 static struct sos_kslab_cache *kmem_range_cache;
045 045
046 046
047 047
048 048
049 049
050 static struct sos_kmem_range * 050 static struct sos_kmem_range *
051 get_closest_preceding_kmem_range(struct sos_km 051 get_closest_preceding_kmem_range(struct sos_kmem_range *the_list,
052 sos_vaddr_t v 052 sos_vaddr_t vaddr)
053 { 053 {
054 int nb_elements; 054 int nb_elements;
055 struct sos_kmem_range *a_range, *ret_range; 055 struct sos_kmem_range *a_range, *ret_range;
056 056
057 057
058 058
059 ret_range = NULL; 059 ret_range = NULL;
060 list_foreach(the_list, a_range, nb_elements) 060 list_foreach(the_list, a_range, nb_elements)
061 { 061 {
062 if (vaddr < a_range->base_vaddr) 062 if (vaddr < a_range->base_vaddr)
063 return ret_range; 063 return ret_range;
064 ret_range = a_range; 064 ret_range = a_range;
065 } 065 }
066 066
067 067
068 return ret_range; 068 return ret_range;
069 } 069 }
070 070
071 071
072 072
073 073
074 074
075 075
076 static struct sos_kmem_range *find_suitable_fr 076 static struct sos_kmem_range *find_suitable_free_range(sos_count_t nb_pages)
077 { 077 {
078 int nb_elements; 078 int nb_elements;
079 struct sos_kmem_range *r; 079 struct sos_kmem_range *r;
080 080
081 list_foreach(kmem_free_range_list, r, nb_ele 081 list_foreach(kmem_free_range_list, r, nb_elements)
082 { 082 {
083 if (r->nb_pages >= nb_pages) 083 if (r->nb_pages >= nb_pages)
084 return r; 084 return r;
085 } 085 }
086 086
087 return NULL; 087 return NULL;
088 } 088 }
089 089
090 090
091 091
092 092
093 093
094 094
095 095
096 static struct sos_kmem_range *insert_range(str 096 static struct sos_kmem_range *insert_range(struct sos_kmem_range *the_list,
097 str 097 struct sos_kmem_range *a_range)
098 { 098 {
099 struct sos_kmem_range *prec_used; 099 struct sos_kmem_range *prec_used;
100 100
101 101
102 prec_used = get_closest_preceding_kmem_range 102 prec_used = get_closest_preceding_kmem_range(the_list,
103 103 a_range->base_vaddr);
104 104
105 if (prec_used != NULL) 105 if (prec_used != NULL)
106 list_insert_after(the_list, prec_used, a_r 106 list_insert_after(the_list, prec_used, a_range);
107 else 107 else
108 list_add_head(the_list, a_range); 108 list_add_head(the_list, a_range);
109 109
110 return the_list; 110 return the_list;
111 } 111 }
112 112
113 113
114 114
115 115
116 116
117 117
118 static struct sos_kmem_range *lookup_range(sos 118 static struct sos_kmem_range *lookup_range(sos_vaddr_t vaddr)
119 { 119 {
120 struct sos_kmem_range *range; 120 struct sos_kmem_range *range;
121 121
122 122
123 sos_paddr_t ppage_paddr = SOS_PAGE_ALIGN_INF !! 123 sos_paddr_t ppage_paddr = sos_paging_get_paddr(vaddr);
124 !! 124 if (! ppage_paddr)
125 if (ppage_paddr) <<
126 { 125 {
127 range = sos_physmem_get_kmem_range(ppage 126 range = sos_physmem_get_kmem_range(ppage_paddr);
128 <<
129 127
130 128
131 SOS_ASSERT_FATAL(range != NULL); 129 SOS_ASSERT_FATAL(range != NULL);
132 } 130 }
133 131
134 132
135 133
136 else 134 else
137 { 135 {
138 range = get_closest_preceding_kmem_range 136 range = get_closest_preceding_kmem_range(kmem_used_range_list,
139 137 vaddr);
140 138
141 if (! range) 139 if (! range)
142 return NULL; 140 return NULL;
143 <<
144 <<
145 if ( (vaddr < range->base_vaddr) <<
146 || (vaddr >= (range->base_vaddr + r <<
147 return NULL; <<
148 } 141 }
149 142
150 return range; 143 return range;
151 } 144 }
152 145
153 146
154 147
155 148
156 149
157 150
158 151
159 static struct sos_kmem_range * 152 static struct sos_kmem_range *
160 create_range(sos_bool_t is_free, 153 create_range(sos_bool_t is_free,
161 sos_vaddr_t base_vaddr, 154 sos_vaddr_t base_vaddr,
162 sos_vaddr_t top_vaddr, !! 155 sos_vaddr_t top_addr,
163 struct sos_kslab *associated_slab 156 struct sos_kslab *associated_slab)
164 { 157 {
165 struct sos_kmem_range *range; 158 struct sos_kmem_range *range;
166 <<
167 SOS_ASSERT_FATAL(SOS_IS_PAGE_ALIGNED(base_va <<
168 SOS_ASSERT_FATAL(SOS_IS_PAGE_ALIGNED(top_vad <<
169 <<
170 if ((top_vaddr - base_vaddr) < SOS_PAGE_SIZE <<
171 return NULL; <<
172 <<
173 range = (struct sos_kmem_range*)sos_kmem_cac 159 range = (struct sos_kmem_range*)sos_kmem_cache_alloc(kmem_range_cache,
174 160 SOS_KSLAB_ALLOC_ATOMIC);
175 SOS_ASSERT_FATAL(range != NULL); 161 SOS_ASSERT_FATAL(range != NULL);
176 162
177 range->base_vaddr = base_vaddr; 163 range->base_vaddr = base_vaddr;
178 range->nb_pages = (top_vaddr - base_vaddr) !! 164 range->nb_pages = (top_addr - base_vaddr) / SOS_PAGE_SIZE;
179 165
180 if (is_free) 166 if (is_free)
181 { 167 {
182 list_add_tail(kmem_free_range_list, 168 list_add_tail(kmem_free_range_list,
183 range); 169 range);
184 } 170 }
185 else 171 else
186 { 172 {
187 sos_vaddr_t vaddr; 173 sos_vaddr_t vaddr;
188 range->slab = associated_slab; 174 range->slab = associated_slab;
189 list_add_tail(kmem_used_range_list, 175 list_add_tail(kmem_used_range_list,
190 range); 176 range);
191 177
192 178
193 for (vaddr = base_vaddr ; 179 for (vaddr = base_vaddr ;
194 vaddr < top_vaddr ; !! 180 vaddr < top_addr ;
195 vaddr += SOS_PAGE_SIZE) 181 vaddr += SOS_PAGE_SIZE)
196 { 182 {
197 sos_paddr_t ppage_paddr = sos_paging_g 183 sos_paddr_t ppage_paddr = sos_paging_get_paddr(vaddr);
198 SOS_ASSERT_FATAL((void*)ppage_paddr != 184 SOS_ASSERT_FATAL((void*)ppage_paddr != NULL);
199 sos_physmem_set_kmem_range(ppage_paddr 185 sos_physmem_set_kmem_range(ppage_paddr, range);
200 } 186 }
201 } 187 }
202 188
203 return range; 189 return range;
204 } 190 }
205 191
206 192
207 sos_ret_t !! 193 sos_ret_t sos_kmem_vmm_setup(sos_vaddr_t kernel_core_base,
208 sos_kmem_vmm_subsystem_setup(sos_vaddr_t kerne !! 194 sos_vaddr_t kernel_core_top)
209 sos_vaddr_t kerne <<
210 sos_vaddr_t boots <<
211 sos_vaddr_t boots <<
212 { 195 {
213 struct sos_kslab *first_struct_slab_of_cache 196 struct sos_kslab *first_struct_slab_of_caches,
214 *first_struct_slab_of_ranges; 197 *first_struct_slab_of_ranges;
215 sos_vaddr_t first_slab_of_caches_base, 198 sos_vaddr_t first_slab_of_caches_base,
216 first_slab_of_caches_nb_pages, 199 first_slab_of_caches_nb_pages,
217 first_slab_of_ranges_base, 200 first_slab_of_ranges_base,
218 first_slab_of_ranges_nb_pages; 201 first_slab_of_ranges_nb_pages;
219 struct sos_kmem_range *first_range_of_caches 202 struct sos_kmem_range *first_range_of_caches,
220 *first_range_of_ranges; 203 *first_range_of_ranges;
221 204
222 list_init(kmem_free_range_list); 205 list_init(kmem_free_range_list);
223 list_init(kmem_used_range_list); 206 list_init(kmem_used_range_list);
224 207
225 kmem_range_cache 208 kmem_range_cache
226 = sos_kmem_cache_subsystem_setup_prepare(k !! 209 = sos_kmem_cache_setup_prepare(kernel_core_base,
227 k !! 210 kernel_core_top,
228 s !! 211 sizeof(struct sos_kmem_range),
229 & !! 212 & first_struct_slab_of_caches,
230 & !! 213 & first_slab_of_caches_base,
231 & !! 214 & first_slab_of_caches_nb_pages,
232 & !! 215 & first_struct_slab_of_ranges,
233 & !! 216 & first_slab_of_ranges_base,
234 & !! 217 & first_slab_of_ranges_nb_pages);
235 SOS_ASSERT_FATAL(kmem_range_cache != NULL); 218 SOS_ASSERT_FATAL(kmem_range_cache != NULL);
236 219
237 220
238 create_range(TRUE, 221 create_range(TRUE,
239 SOS_KMEM_VMM_BASE, 222 SOS_KMEM_VMM_BASE,
240 SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO 223 SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO_START),
241 NULL); 224 NULL);
242 225
243 226
244 create_range(FALSE, 227 create_range(FALSE,
245 SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO 228 SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO_START),
246 SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO 229 SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO_END),
247 NULL); 230 NULL);
248 231
249 232
250 create_range(TRUE, 233 create_range(TRUE,
251 SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO 234 SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO_END),
252 SOS_PAGE_ALIGN_INF(kernel_core_ 235 SOS_PAGE_ALIGN_INF(kernel_core_base),
253 NULL); 236 NULL);
254 237
255 !! 238
256 <<
257 create_range(FALSE, 239 create_range(FALSE,
258 SOS_PAGE_ALIGN_INF(kernel_core_ 240 SOS_PAGE_ALIGN_INF(kernel_core_base),
259 bootstrap_stack_bottom_vaddr, <<
260 NULL); <<
261 <<
262 <<
263 <<
264 create_range(FALSE, <<
265 bootstrap_stack_bottom_vaddr, <<
266 bootstrap_stack_top_vaddr, <<
267 NULL); <<
268 <<
269 <<
270 <<
271 create_range(FALSE, <<
272 bootstrap_stack_top_vaddr, <<
273 SOS_PAGE_ALIGN_SUP(kernel_core_ 241 SOS_PAGE_ALIGN_SUP(kernel_core_top),
274 NULL); 242 NULL);
275 243
276 244
277 245
278 SOS_ASSERT_FATAL(SOS_PAGE_ALIGN_SUP(kernel_c 246 SOS_ASSERT_FATAL(SOS_PAGE_ALIGN_SUP(kernel_core_top)
279 == first_slab_of_caches_bas 247 == first_slab_of_caches_base);
280 SOS_ASSERT_FATAL(first_struct_slab_of_caches 248 SOS_ASSERT_FATAL(first_struct_slab_of_caches != NULL);
281 first_range_of_caches 249 first_range_of_caches
282 = create_range(FALSE, 250 = create_range(FALSE,
283 first_slab_of_caches_base, 251 first_slab_of_caches_base,
284 first_slab_of_caches_base 252 first_slab_of_caches_base
285 + first_slab_of_caches_nb_p 253 + first_slab_of_caches_nb_pages*SOS_PAGE_SIZE,
286 first_struct_slab_of_caches 254 first_struct_slab_of_caches);
287 255
288 256
289 257
290 SOS_ASSERT_FATAL((first_slab_of_caches_base 258 SOS_ASSERT_FATAL((first_slab_of_caches_base
291 + first_slab_of_caches_nb_ 259 + first_slab_of_caches_nb_pages*SOS_PAGE_SIZE)
292 == first_slab_of_ranges_bas 260 == first_slab_of_ranges_base);
293 SOS_ASSERT_FATAL(first_struct_slab_of_ranges 261 SOS_ASSERT_FATAL(first_struct_slab_of_ranges != NULL);
294 first_range_of_ranges 262 first_range_of_ranges
295 = create_range(FALSE, 263 = create_range(FALSE,
296 first_slab_of_ranges_base, 264 first_slab_of_ranges_base,
297 first_slab_of_ranges_base 265 first_slab_of_ranges_base
298 + first_slab_of_ranges_nb_p 266 + first_slab_of_ranges_nb_pages*SOS_PAGE_SIZE,
299 first_struct_slab_of_ranges 267 first_struct_slab_of_ranges);
300 268
301 269
302 create_range(TRUE, 270 create_range(TRUE,
303 first_slab_of_ranges_base 271 first_slab_of_ranges_base
304 + first_slab_of_ranges_nb_pages 272 + first_slab_of_ranges_nb_pages*SOS_PAGE_SIZE,
305 SOS_KMEM_VMM_TOP, 273 SOS_KMEM_VMM_TOP,
306 NULL); 274 NULL);
307 275
308 276
309 277
310 278
311 sos_kmem_cache_subsystem_setup_commit(first_ !! 279 sos_kmem_cache_setup_commit(first_struct_slab_of_caches,
312 first_ !! 280 first_range_of_caches,
313 first_ !! 281 first_struct_slab_of_ranges,
314 first_ !! 282 first_range_of_ranges);
315 283
316 return SOS_OK; 284 return SOS_OK;
317 } 285 }
318 286
319 287
320 288
321 289
322 290
323 291
324 292
325 struct sos_kmem_range *sos_kmem_vmm_new_range( 293 struct sos_kmem_range *sos_kmem_vmm_new_range(sos_count_t nb_pages,
326 294 sos_ui32_t flags,
327 295 sos_vaddr_t * range_start)
328 { 296 {
329 struct sos_kmem_range *free_range, *new_rang 297 struct sos_kmem_range *free_range, *new_range;
330 298
331 if (nb_pages <= 0) 299 if (nb_pages <= 0)
332 return NULL; 300 return NULL;
333 301
334 302
335 free_range = find_suitable_free_range(nb_pag 303 free_range = find_suitable_free_range(nb_pages);
336 if (free_range == NULL) 304 if (free_range == NULL)
337 return NULL; 305 return NULL;
338 306
339 307
340 308
341 if(free_range->nb_pages == nb_pages) 309 if(free_range->nb_pages == nb_pages)
342 { 310 {
343 list_delete(kmem_free_range_list, free_r 311 list_delete(kmem_free_range_list, free_range);
344 kmem_used_range_list = insert_range(kmem 312 kmem_used_range_list = insert_range(kmem_used_range_list,
345 free 313 free_range);
346 314
347 new_range = free_range; 315 new_range = free_range;
348 } 316 }
349 317
350 318
351 319
352 320
353 else 321 else
354 { 322 {
355 323
356 new_range = (struct sos_kmem_range*) 324 new_range = (struct sos_kmem_range*)
357 sos_kmem_cache_alloc(kmem_range_cache, 325 sos_kmem_cache_alloc(kmem_range_cache,
358 (flags & SOS_KMEM 326 (flags & SOS_KMEM_VMM_ATOMIC)?
359 SOS_KSLAB_ALLOC_A 327 SOS_KSLAB_ALLOC_ATOMIC:0);
360 if (! new_range) 328 if (! new_range)
361 return NULL; 329 return NULL;
362 330
363 new_range->base_vaddr = free_range->ba 331 new_range->base_vaddr = free_range->base_vaddr;
364 new_range->nb_pages = nb_pages; 332 new_range->nb_pages = nb_pages;
365 free_range->base_vaddr += nb_pages*SOS_P 333 free_range->base_vaddr += nb_pages*SOS_PAGE_SIZE;
366 free_range->nb_pages -= nb_pages; 334 free_range->nb_pages -= nb_pages;
367 335
368 336
369 337
370 kmem_used_range_list = insert_range(kmem 338 kmem_used_range_list = insert_range(kmem_used_range_list,
371 new_ 339 new_range);
372 } 340 }
373 341
374 342
375 new_range->slab = NULL; 343 new_range->slab = NULL;
376 344
377 345
378 if (flags & SOS_KMEM_VMM_MAP) 346 if (flags & SOS_KMEM_VMM_MAP)
379 { 347 {
380 int i; 348 int i;
381 for (i = 0 ; i < nb_pages ; i ++) 349 for (i = 0 ; i < nb_pages ; i ++)
382 { 350 {
383 351
384 sos_paddr_t ppage_paddr 352 sos_paddr_t ppage_paddr
385 = sos_physmem_ref_physpage_new(! ( 353 = sos_physmem_ref_physpage_new(! (flags & SOS_KMEM_VMM_ATOMIC));
386 354
387 355
388 if (ppage_paddr) 356 if (ppage_paddr)
389 { 357 {
390 if (sos_paging_map(ppage_paddr, 358 if (sos_paging_map(ppage_paddr,
391 new_range->ba 359 new_range->base_vaddr
392 + i * SOS_P 360 + i * SOS_PAGE_SIZE,
393 FALSE 361 FALSE ,
394 ((flags & SOS 362 ((flags & SOS_KMEM_VMM_ATOMIC)?
395 SOS_VM_MAP_A 363 SOS_VM_MAP_ATOMIC:0)
396 | SOS_VM_MAP_ 364 | SOS_VM_MAP_PROT_READ
397 | SOS_VM_MAP_ 365 | SOS_VM_MAP_PROT_WRITE))
398 { 366 {
399 367
400 sos_physmem_unref_physpage(p 368 sos_physmem_unref_physpage(ppage_paddr);
401 ppage_paddr = (sos_paddr_t)N 369 ppage_paddr = (sos_paddr_t)NULL;
402 } 370 }
403 else 371 else
404 { 372 {
405 373
406 374
407 sos_physmem_unref_physpage(p 375 sos_physmem_unref_physpage(ppage_paddr);
408 } 376 }
409 } 377 }
410 378
411 379
412 if (! ppage_paddr) 380 if (! ppage_paddr)
413 { 381 {
414 sos_kmem_vmm_del_range(new_range 382 sos_kmem_vmm_del_range(new_range);
415 return NULL; 383 return NULL;
416 } 384 }
417 385
418 386
419 sos_physmem_set_kmem_range(ppage_pad 387 sos_physmem_set_kmem_range(ppage_paddr, new_range);
420 } 388 }
421 } 389 }
422 !! 390
>> 391
>> 392
>> 393 else
>> 394 SOS_ASSERT_FATAL(! "No demand paging yet");
423 395
424 if (range_start) 396 if (range_start)
425 *range_start = new_range->base_vaddr; 397 *range_start = new_range->base_vaddr;
426 398
427 return new_range; 399 return new_range;
428 } 400 }
429 401
430 402
431 sos_ret_t sos_kmem_vmm_del_range(struct sos_km !! 403 sos_vaddr_t sos_kmem_vmm_del_range(struct sos_kmem_range *range)
432 { 404 {
433 int i; 405 int i;
434 struct sos_kmem_range *ranges_to_free; 406 struct sos_kmem_range *ranges_to_free;
435 list_init(ranges_to_free); 407 list_init(ranges_to_free);
436 408
437 SOS_ASSERT_FATAL(range != NULL); 409 SOS_ASSERT_FATAL(range != NULL);
438 SOS_ASSERT_FATAL(range->slab == NULL); 410 SOS_ASSERT_FATAL(range->slab == NULL);
439 411
440 412
441 list_delete(kmem_used_range_list, range); 413 list_delete(kmem_used_range_list, range);
442 414
443 415
444 416
445 417
446 418
447 419
448 420
449 421
450 422
451 423
452 424
453 425
454 426
455 427
456 428
457 429
458 430
459 do 431 do
460 { 432 {
461 433
462 kmem_free_range_list = insert_range(kmem 434 kmem_free_range_list = insert_range(kmem_free_range_list, range);
463 435
464 436
465 for (i = 0 ; i < range->nb_pages ; i ++) 437 for (i = 0 ; i < range->nb_pages ; i ++)
466 { 438 {
467 439
468 sos_paging_unmap(range->base_vaddr + 440 sos_paging_unmap(range->base_vaddr + i*SOS_PAGE_SIZE);
469 } 441 }
470 442
471 443
472 444
473 445
474 446
475 447
476 448
477 if (range->prev->base_vaddr + range->pre 449 if (range->prev->base_vaddr + range->prev->nb_pages*SOS_PAGE_SIZE
478 == range->base_vaddr) 450 == range->base_vaddr)
479 { 451 {
480 struct sos_kmem_range *empty_range_o 452 struct sos_kmem_range *empty_range_of_ranges = NULL;
481 struct sos_kmem_range *prec_free = r 453 struct sos_kmem_range *prec_free = range->prev;
482 454
483 455
484 prec_free->nb_pages += range->nb_pag 456 prec_free->nb_pages += range->nb_pages;
485 list_delete(kmem_free_range_list, ra 457 list_delete(kmem_free_range_list, range);
486 458
487 459
488 460
489 empty_range_of_ranges = 461 empty_range_of_ranges =
490 sos_kmem_cache_release_struct_rang 462 sos_kmem_cache_release_struct_range(range);
491 463
492 464
493 465
494 466
495 467
496 if (empty_range_of_ranges != NULL) 468 if (empty_range_of_ranges != NULL)
497 { 469 {
498 list_delete(kmem_used_range_list 470 list_delete(kmem_used_range_list, empty_range_of_ranges);
499 list_add_tail(ranges_to_free, em 471 list_add_tail(ranges_to_free, empty_range_of_ranges);
500 } 472 }
501 473
502 474
503 range = prec_free; 475 range = prec_free;
504 } 476 }
505 477
506 478
507 479
508 if (range->base_vaddr + range->nb_pages* 480 if (range->base_vaddr + range->nb_pages*SOS_PAGE_SIZE
509 == range->next->base_vaddr) 481 == range->next->base_vaddr)
510 { 482 {
511 struct sos_kmem_range *empty_range_o 483 struct sos_kmem_range *empty_range_of_ranges = NULL;
512 struct sos_kmem_range *next_range = 484 struct sos_kmem_range *next_range = range->next;
513 485
514 486
515 range->nb_pages += next_range->nb_pa 487 range->nb_pages += next_range->nb_pages;
516 list_delete(kmem_free_range_list, ne 488 list_delete(kmem_free_range_list, next_range);
517 489
518 490
519 491
520 empty_range_of_ranges = 492 empty_range_of_ranges =
521 sos_kmem_cache_release_struct_rang 493 sos_kmem_cache_release_struct_range(next_range);
522 494
523 495
524 496
525 497
526 498
527 499
528 if (empty_range_of_ranges != NULL) 500 if (empty_range_of_ranges != NULL)
529 { 501 {
530 list_delete(kmem_used_range_list 502 list_delete(kmem_used_range_list, empty_range_of_ranges);
531 list_add_tail(ranges_to_free, em 503 list_add_tail(ranges_to_free, empty_range_of_ranges);
532 } 504 }
533 } 505 }
534 506
535 507
536 508
537 509
538 if (list_is_empty(ranges_to_free)) 510 if (list_is_empty(ranges_to_free))
539 range = NULL; 511 range = NULL;
540 else 512 else
541 range = list_pop_head(ranges_to_free); 513 range = list_pop_head(ranges_to_free);
542 514
543 } 515 }
544 516
545 while (range != NULL); 517 while (range != NULL);
546 518
547 return SOS_OK; 519 return SOS_OK;
548 } 520 }
549 521
550 522
551 sos_vaddr_t sos_kmem_vmm_alloc(sos_count_t nb_ 523 sos_vaddr_t sos_kmem_vmm_alloc(sos_count_t nb_pages,
552 sos_ui32_t fla 524 sos_ui32_t flags)
553 { 525 {
554 struct sos_kmem_range *range 526 struct sos_kmem_range *range
555 = sos_kmem_vmm_new_range(nb_pages, 527 = sos_kmem_vmm_new_range(nb_pages,
556 flags, 528 flags,
557 NULL); 529 NULL);
558 if (! range) 530 if (! range)
559 return (sos_vaddr_t)NULL; 531 return (sos_vaddr_t)NULL;
560 532
561 return range->base_vaddr; 533 return range->base_vaddr;
562 } 534 }
563 535
564 536
565 sos_ret_t sos_kmem_vmm_free(sos_vaddr_t vaddr) !! 537 sos_vaddr_t sos_kmem_vmm_free(sos_vaddr_t vaddr)
566 { 538 {
567 struct sos_kmem_range *range = lookup_range( 539 struct sos_kmem_range *range = lookup_range(vaddr);
568 540
569 541
570 542
571 if (!range || (range->base_vaddr != vaddr)) 543 if (!range || (range->base_vaddr != vaddr))
572 return -SOS_EINVAL; 544 return -SOS_EINVAL;
573 545
574 546
575 if (range->slab != NULL) 547 if (range->slab != NULL)
576 return -SOS_EBUSY; 548 return -SOS_EBUSY;
577 549
578 return sos_kmem_vmm_del_range(range); 550 return sos_kmem_vmm_del_range(range);
579 } 551 }
580 552
581 553
582 sos_ret_t sos_kmem_vmm_set_slab(struct sos_kme 554 sos_ret_t sos_kmem_vmm_set_slab(struct sos_kmem_range *range,
583 struct sos_ksl 555 struct sos_kslab *slab)
584 { 556 {
585 if (! range) 557 if (! range)
586 return -SOS_EINVAL; 558 return -SOS_EINVAL;
587 559
588 range->slab = slab; 560 range->slab = slab;
589 return SOS_OK; 561 return SOS_OK;
590 } 562 }
591 563
592 struct sos_kslab * sos_kmem_vmm_resolve_slab(s 564 struct sos_kslab * sos_kmem_vmm_resolve_slab(sos_vaddr_t vaddr)
593 { 565 {
594 struct sos_kmem_range *range = lookup_range( 566 struct sos_kmem_range *range = lookup_range(vaddr);
595 if (! range) 567 if (! range)
596 return NULL; 568 return NULL;
597 569
598 return range->slab; 570 return range->slab;
599 } 571 }
600 572
601 <<
602 sos_bool_t sos_kmem_vmm_is_valid_vaddr(sos_vad <<
603 { <<
604 struct sos_kmem_range *range = lookup_range( <<
605 return (range != NULL); <<
606 } <<