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_paging_get_pad !! 123 sos_paddr_t ppage_paddr = SOS_PAGE_ALIGN_INF(sos_paging_get_paddr(vaddr));
124 if (! ppage_paddr) !! 124
>> 125 if (ppage_paddr)
125 { 126 {
126 range = sos_physmem_get_kmem_range(ppage 127 range = sos_physmem_get_kmem_range(ppage_paddr);
>> 128
127 129
128 130
129 SOS_ASSERT_FATAL(range != NULL); 131 SOS_ASSERT_FATAL(range != NULL);
130 } 132 }
131 133
132 134
133 135
134 else 136 else
135 { 137 {
136 range = get_closest_preceding_kmem_range 138 range = get_closest_preceding_kmem_range(kmem_used_range_list,
137 139 vaddr);
138 140
139 if (! range) 141 if (! range)
140 return NULL; 142 return NULL;
>> 143
>> 144
>> 145 if ( (vaddr < range->base_vaddr)
>> 146 || (vaddr >= (range->base_vaddr + range->nb_pages*SOS_PAGE_SIZE)) )
>> 147 return NULL;
141 } 148 }
142 149
143 return range; 150 return range;
144 } 151 }
145 152
146 153
147 154
148 155
149 156
150 157
151 158
152 static struct sos_kmem_range * 159 static struct sos_kmem_range *
153 create_range(sos_bool_t is_free, 160 create_range(sos_bool_t is_free,
154 sos_vaddr_t base_vaddr, 161 sos_vaddr_t base_vaddr,
155 sos_vaddr_t top_addr, !! 162 sos_vaddr_t top_vaddr,
156 struct sos_kslab *associated_slab 163 struct sos_kslab *associated_slab)
157 { 164 {
158 struct sos_kmem_range *range; 165 struct sos_kmem_range *range;
>> 166
>> 167 SOS_ASSERT_FATAL(SOS_IS_PAGE_ALIGNED(base_vaddr));
>> 168 SOS_ASSERT_FATAL(SOS_IS_PAGE_ALIGNED(top_vaddr));
>> 169
>> 170 if ((top_vaddr - base_vaddr) < SOS_PAGE_SIZE)
>> 171 return NULL;
>> 172
159 range = (struct sos_kmem_range*)sos_kmem_cac 173 range = (struct sos_kmem_range*)sos_kmem_cache_alloc(kmem_range_cache,
160 174 SOS_KSLAB_ALLOC_ATOMIC);
161 SOS_ASSERT_FATAL(range != NULL); 175 SOS_ASSERT_FATAL(range != NULL);
162 176
163 range->base_vaddr = base_vaddr; 177 range->base_vaddr = base_vaddr;
164 range->nb_pages = (top_addr - base_vaddr) !! 178 range->nb_pages = (top_vaddr - base_vaddr) / SOS_PAGE_SIZE;
165 179
166 if (is_free) 180 if (is_free)
167 { 181 {
168 list_add_tail(kmem_free_range_list, 182 list_add_tail(kmem_free_range_list,
169 range); 183 range);
170 } 184 }
171 else 185 else
172 { 186 {
173 sos_vaddr_t vaddr; 187 sos_vaddr_t vaddr;
174 range->slab = associated_slab; 188 range->slab = associated_slab;
175 list_add_tail(kmem_used_range_list, 189 list_add_tail(kmem_used_range_list,
176 range); 190 range);
177 191
178 192
179 for (vaddr = base_vaddr ; 193 for (vaddr = base_vaddr ;
180 vaddr < top_addr ; !! 194 vaddr < top_vaddr ;
181 vaddr += SOS_PAGE_SIZE) 195 vaddr += SOS_PAGE_SIZE)
182 { 196 {
183 sos_paddr_t ppage_paddr = sos_paging_g 197 sos_paddr_t ppage_paddr = sos_paging_get_paddr(vaddr);
184 SOS_ASSERT_FATAL((void*)ppage_paddr != 198 SOS_ASSERT_FATAL((void*)ppage_paddr != NULL);
185 sos_physmem_set_kmem_range(ppage_paddr 199 sos_physmem_set_kmem_range(ppage_paddr, range);
186 } 200 }
187 } 201 }
188 202
189 return range; 203 return range;
190 } 204 }
191 205
192 206
193 sos_ret_t sos_kmem_vmm_setup(sos_vaddr_t kerne !! 207 sos_ret_t
194 sos_vaddr_t kerne !! 208 sos_kmem_vmm_subsystem_setup(sos_vaddr_t kernel_core_base,
>> 209 sos_vaddr_t kernel_core_top,
>> 210 sos_vaddr_t bootstrap_stack_bottom_vaddr,
>> 211 sos_vaddr_t bootstrap_stack_top_vaddr)
195 { 212 {
196 struct sos_kslab *first_struct_slab_of_cache 213 struct sos_kslab *first_struct_slab_of_caches,
197 *first_struct_slab_of_ranges; 214 *first_struct_slab_of_ranges;
198 sos_vaddr_t first_slab_of_caches_base, 215 sos_vaddr_t first_slab_of_caches_base,
199 first_slab_of_caches_nb_pages, 216 first_slab_of_caches_nb_pages,
200 first_slab_of_ranges_base, 217 first_slab_of_ranges_base,
201 first_slab_of_ranges_nb_pages; 218 first_slab_of_ranges_nb_pages;
202 struct sos_kmem_range *first_range_of_caches 219 struct sos_kmem_range *first_range_of_caches,
203 *first_range_of_ranges; 220 *first_range_of_ranges;
204 221
205 list_init(kmem_free_range_list); 222 list_init(kmem_free_range_list);
206 list_init(kmem_used_range_list); 223 list_init(kmem_used_range_list);
207 224
208 kmem_range_cache 225 kmem_range_cache
209 = sos_kmem_cache_setup_prepare(kernel_core !! 226 = sos_kmem_cache_subsystem_setup_prepare(kernel_core_base,
210 kernel_core !! 227 kernel_core_top,
211 sizeof(stru !! 228 sizeof(struct sos_kmem_range),
212 & first_str !! 229 & first_struct_slab_of_caches,
213 & first_sla !! 230 & first_slab_of_caches_base,
214 & first_sla !! 231 & first_slab_of_caches_nb_pages,
215 & first_str !! 232 & first_struct_slab_of_ranges,
216 & first_sla !! 233 & first_slab_of_ranges_base,
217 & first_sla !! 234 & first_slab_of_ranges_nb_pages);
218 SOS_ASSERT_FATAL(kmem_range_cache != NULL); 235 SOS_ASSERT_FATAL(kmem_range_cache != NULL);
219 236
220 237
221 create_range(TRUE, 238 create_range(TRUE,
222 SOS_KMEM_VMM_BASE, 239 SOS_KMEM_VMM_BASE,
223 SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO 240 SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO_START),
224 NULL); 241 NULL);
225 242
226 243
227 create_range(FALSE, 244 create_range(FALSE,
228 SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO 245 SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO_START),
229 SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO 246 SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO_END),
230 NULL); 247 NULL);
231 248
232 249
233 create_range(TRUE, 250 create_range(TRUE,
234 SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO 251 SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO_END),
235 SOS_PAGE_ALIGN_INF(kernel_core_ 252 SOS_PAGE_ALIGN_INF(kernel_core_base),
236 NULL); 253 NULL);
237 254
238 !! 255
>> 256
239 create_range(FALSE, 257 create_range(FALSE,
240 SOS_PAGE_ALIGN_INF(kernel_core_ 258 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,
241 SOS_PAGE_ALIGN_SUP(kernel_core_ 273 SOS_PAGE_ALIGN_SUP(kernel_core_top),
242 NULL); 274 NULL);
243 275
244 276
245 277
246 SOS_ASSERT_FATAL(SOS_PAGE_ALIGN_SUP(kernel_c 278 SOS_ASSERT_FATAL(SOS_PAGE_ALIGN_SUP(kernel_core_top)
247 == first_slab_of_caches_bas 279 == first_slab_of_caches_base);
248 SOS_ASSERT_FATAL(first_struct_slab_of_caches 280 SOS_ASSERT_FATAL(first_struct_slab_of_caches != NULL);
249 first_range_of_caches 281 first_range_of_caches
250 = create_range(FALSE, 282 = create_range(FALSE,
251 first_slab_of_caches_base, 283 first_slab_of_caches_base,
252 first_slab_of_caches_base 284 first_slab_of_caches_base
253 + first_slab_of_caches_nb_p 285 + first_slab_of_caches_nb_pages*SOS_PAGE_SIZE,
254 first_struct_slab_of_caches 286 first_struct_slab_of_caches);
255 287
256 288
257 289
258 SOS_ASSERT_FATAL((first_slab_of_caches_base 290 SOS_ASSERT_FATAL((first_slab_of_caches_base
259 + first_slab_of_caches_nb_ 291 + first_slab_of_caches_nb_pages*SOS_PAGE_SIZE)
260 == first_slab_of_ranges_bas 292 == first_slab_of_ranges_base);
261 SOS_ASSERT_FATAL(first_struct_slab_of_ranges 293 SOS_ASSERT_FATAL(first_struct_slab_of_ranges != NULL);
262 first_range_of_ranges 294 first_range_of_ranges
263 = create_range(FALSE, 295 = create_range(FALSE,
264 first_slab_of_ranges_base, 296 first_slab_of_ranges_base,
265 first_slab_of_ranges_base 297 first_slab_of_ranges_base
266 + first_slab_of_ranges_nb_p 298 + first_slab_of_ranges_nb_pages*SOS_PAGE_SIZE,
267 first_struct_slab_of_ranges 299 first_struct_slab_of_ranges);
268 300
269 301
270 create_range(TRUE, 302 create_range(TRUE,
271 first_slab_of_ranges_base 303 first_slab_of_ranges_base
272 + first_slab_of_ranges_nb_pages 304 + first_slab_of_ranges_nb_pages*SOS_PAGE_SIZE,
273 SOS_KMEM_VMM_TOP, 305 SOS_KMEM_VMM_TOP,
274 NULL); 306 NULL);
275 307
276 308
277 309
278 310
279 sos_kmem_cache_setup_commit(first_struct_sla !! 311 sos_kmem_cache_subsystem_setup_commit(first_struct_slab_of_caches,
280 first_range_of_c !! 312 first_range_of_caches,
281 first_struct_sla !! 313 first_struct_slab_of_ranges,
282 first_range_of_r !! 314 first_range_of_ranges);
283 315
284 return SOS_OK; 316 return SOS_OK;
285 } 317 }
286 318
287 319
288 320
289 321
290 322
291 323
292 324
293 struct sos_kmem_range *sos_kmem_vmm_new_range( 325 struct sos_kmem_range *sos_kmem_vmm_new_range(sos_count_t nb_pages,
294 326 sos_ui32_t flags,
295 327 sos_vaddr_t * range_start)
296 { 328 {
297 struct sos_kmem_range *free_range, *new_rang 329 struct sos_kmem_range *free_range, *new_range;
298 330
299 if (nb_pages <= 0) 331 if (nb_pages <= 0)
300 return NULL; 332 return NULL;
301 333
302 334
303 free_range = find_suitable_free_range(nb_pag 335 free_range = find_suitable_free_range(nb_pages);
304 if (free_range == NULL) 336 if (free_range == NULL)
305 return NULL; 337 return NULL;
306 338
307 339
308 340
309 if(free_range->nb_pages == nb_pages) 341 if(free_range->nb_pages == nb_pages)
310 { 342 {
311 list_delete(kmem_free_range_list, free_r 343 list_delete(kmem_free_range_list, free_range);
312 kmem_used_range_list = insert_range(kmem 344 kmem_used_range_list = insert_range(kmem_used_range_list,
313 free 345 free_range);
314 346
315 new_range = free_range; 347 new_range = free_range;
316 } 348 }
317 349
318 350
319 351
320 352
321 else 353 else
322 { 354 {
323 355
324 new_range = (struct sos_kmem_range*) 356 new_range = (struct sos_kmem_range*)
325 sos_kmem_cache_alloc(kmem_range_cache, 357 sos_kmem_cache_alloc(kmem_range_cache,
326 (flags & SOS_KMEM 358 (flags & SOS_KMEM_VMM_ATOMIC)?
327 SOS_KSLAB_ALLOC_A 359 SOS_KSLAB_ALLOC_ATOMIC:0);
328 if (! new_range) 360 if (! new_range)
329 return NULL; 361 return NULL;
330 362
331 new_range->base_vaddr = free_range->ba 363 new_range->base_vaddr = free_range->base_vaddr;
332 new_range->nb_pages = nb_pages; 364 new_range->nb_pages = nb_pages;
333 free_range->base_vaddr += nb_pages*SOS_P 365 free_range->base_vaddr += nb_pages*SOS_PAGE_SIZE;
334 free_range->nb_pages -= nb_pages; 366 free_range->nb_pages -= nb_pages;
335 367
336 368
337 369
338 kmem_used_range_list = insert_range(kmem 370 kmem_used_range_list = insert_range(kmem_used_range_list,
339 new_ 371 new_range);
340 } 372 }
341 373
342 374
343 new_range->slab = NULL; 375 new_range->slab = NULL;
344 376
345 377
346 if (flags & SOS_KMEM_VMM_MAP) 378 if (flags & SOS_KMEM_VMM_MAP)
347 { 379 {
348 int i; !! 380 unsigned int i;
349 for (i = 0 ; i < nb_pages ; i ++) 381 for (i = 0 ; i < nb_pages ; i ++)
350 { 382 {
351 383
352 sos_paddr_t ppage_paddr 384 sos_paddr_t ppage_paddr
353 = sos_physmem_ref_physpage_new(! ( 385 = sos_physmem_ref_physpage_new(! (flags & SOS_KMEM_VMM_ATOMIC));
354 386
355 387
356 if (ppage_paddr) 388 if (ppage_paddr)
357 { 389 {
358 if (sos_paging_map(ppage_paddr, 390 if (sos_paging_map(ppage_paddr,
359 new_range->ba 391 new_range->base_vaddr
360 + i * SOS_P 392 + i * SOS_PAGE_SIZE,
361 FALSE 393 FALSE ,
362 ((flags & SOS 394 ((flags & SOS_KMEM_VMM_ATOMIC)?
363 SOS_VM_MAP_A 395 SOS_VM_MAP_ATOMIC:0)
364 | SOS_VM_MAP_ 396 | SOS_VM_MAP_PROT_READ
365 | SOS_VM_MAP_ 397 | SOS_VM_MAP_PROT_WRITE))
366 { 398 {
367 399
368 sos_physmem_unref_physpage(p 400 sos_physmem_unref_physpage(ppage_paddr);
369 ppage_paddr = (sos_paddr_t)N 401 ppage_paddr = (sos_paddr_t)NULL;
370 } 402 }
371 else 403 else
372 { 404 {
373 405
374 406
375 sos_physmem_unref_physpage(p 407 sos_physmem_unref_physpage(ppage_paddr);
376 } 408 }
377 } 409 }
378 410
379 411
380 if (! ppage_paddr) 412 if (! ppage_paddr)
381 { 413 {
382 sos_kmem_vmm_del_range(new_range 414 sos_kmem_vmm_del_range(new_range);
383 return NULL; 415 return NULL;
384 } 416 }
385 417
386 418
387 sos_physmem_set_kmem_range(ppage_pad 419 sos_physmem_set_kmem_range(ppage_paddr, new_range);
388 } 420 }
389 } 421 }
390 !! 422
391 <<
392 <<
393 else <<
394 SOS_ASSERT_FATAL(! "No demand paging yet") <<
395 423
396 if (range_start) 424 if (range_start)
397 *range_start = new_range->base_vaddr; 425 *range_start = new_range->base_vaddr;
398 426
399 return new_range; 427 return new_range;
400 } 428 }
401 429
402 430
403 sos_vaddr_t sos_kmem_vmm_del_range(struct sos_ !! 431 sos_ret_t sos_kmem_vmm_del_range(struct sos_kmem_range *range)
404 { 432 {
405 int i; <<
406 struct sos_kmem_range *ranges_to_free; 433 struct sos_kmem_range *ranges_to_free;
407 list_init(ranges_to_free); 434 list_init(ranges_to_free);
408 435
409 SOS_ASSERT_FATAL(range != NULL); 436 SOS_ASSERT_FATAL(range != NULL);
410 SOS_ASSERT_FATAL(range->slab == NULL); 437 SOS_ASSERT_FATAL(range->slab == NULL);
411 438
412 439
413 list_delete(kmem_used_range_list, range); 440 list_delete(kmem_used_range_list, range);
414 441
415 442
416 443
417 444
418 445
419 446
420 447
421 448
422 449
423 450
424 451
425 452
426 453
427 454
428 455
429 456
430 457
431 do 458 do
432 { 459 {
>> 460 unsigned int i;
>> 461
433 462
434 kmem_free_range_list = insert_range(kmem 463 kmem_free_range_list = insert_range(kmem_free_range_list, range);
435 464
436 465
437 for (i = 0 ; i < range->nb_pages ; i ++) 466 for (i = 0 ; i < range->nb_pages ; i ++)
438 { 467 {
439 468
440 sos_paging_unmap(range->base_vaddr + 469 sos_paging_unmap(range->base_vaddr + i*SOS_PAGE_SIZE);
441 } 470 }
442 471
443 472
444 473
445 474
446 475
447 476
448 477
449 if (range->prev->base_vaddr + range->pre 478 if (range->prev->base_vaddr + range->prev->nb_pages*SOS_PAGE_SIZE
450 == range->base_vaddr) 479 == range->base_vaddr)
451 { 480 {
452 struct sos_kmem_range *empty_range_o 481 struct sos_kmem_range *empty_range_of_ranges = NULL;
453 struct sos_kmem_range *prec_free = r 482 struct sos_kmem_range *prec_free = range->prev;
454 483
455 484
456 prec_free->nb_pages += range->nb_pag 485 prec_free->nb_pages += range->nb_pages;
457 list_delete(kmem_free_range_list, ra 486 list_delete(kmem_free_range_list, range);
458 487
459 488
460 489
461 empty_range_of_ranges = 490 empty_range_of_ranges =
462 sos_kmem_cache_release_struct_rang 491 sos_kmem_cache_release_struct_range(range);
463 492
464 493
465 494
466 495
467 496
468 if (empty_range_of_ranges != NULL) 497 if (empty_range_of_ranges != NULL)
469 { 498 {
470 list_delete(kmem_used_range_list 499 list_delete(kmem_used_range_list, empty_range_of_ranges);
471 list_add_tail(ranges_to_free, em 500 list_add_tail(ranges_to_free, empty_range_of_ranges);
472 } 501 }
473 502
474 503
475 range = prec_free; 504 range = prec_free;
476 } 505 }
477 506
478 507
479 508
480 if (range->base_vaddr + range->nb_pages* 509 if (range->base_vaddr + range->nb_pages*SOS_PAGE_SIZE
481 == range->next->base_vaddr) 510 == range->next->base_vaddr)
482 { 511 {
483 struct sos_kmem_range *empty_range_o 512 struct sos_kmem_range *empty_range_of_ranges = NULL;
484 struct sos_kmem_range *next_range = 513 struct sos_kmem_range *next_range = range->next;
485 514
486 515
487 range->nb_pages += next_range->nb_pa 516 range->nb_pages += next_range->nb_pages;
488 list_delete(kmem_free_range_list, ne 517 list_delete(kmem_free_range_list, next_range);
489 518
490 519
491 520
492 empty_range_of_ranges = 521 empty_range_of_ranges =
493 sos_kmem_cache_release_struct_rang 522 sos_kmem_cache_release_struct_range(next_range);
494 523
495 524
496 525
497 526
498 527
499 528
500 if (empty_range_of_ranges != NULL) 529 if (empty_range_of_ranges != NULL)
501 { 530 {
502 list_delete(kmem_used_range_list 531 list_delete(kmem_used_range_list, empty_range_of_ranges);
503 list_add_tail(ranges_to_free, em 532 list_add_tail(ranges_to_free, empty_range_of_ranges);
504 } 533 }
505 } 534 }
506 535
507 536
508 537
509 538
510 if (list_is_empty(ranges_to_free)) 539 if (list_is_empty(ranges_to_free))
511 range = NULL; 540 range = NULL;
512 else 541 else
513 range = list_pop_head(ranges_to_free); 542 range = list_pop_head(ranges_to_free);
514 543
515 } 544 }
516 545
517 while (range != NULL); 546 while (range != NULL);
518 547
519 return SOS_OK; 548 return SOS_OK;
520 } 549 }
521 550
522 551
523 sos_vaddr_t sos_kmem_vmm_alloc(sos_count_t nb_ 552 sos_vaddr_t sos_kmem_vmm_alloc(sos_count_t nb_pages,
524 sos_ui32_t fla 553 sos_ui32_t flags)
525 { 554 {
526 struct sos_kmem_range *range 555 struct sos_kmem_range *range
527 = sos_kmem_vmm_new_range(nb_pages, 556 = sos_kmem_vmm_new_range(nb_pages,
528 flags, 557 flags,
529 NULL); 558 NULL);
530 if (! range) 559 if (! range)
531 return (sos_vaddr_t)NULL; 560 return (sos_vaddr_t)NULL;
532 561
533 return range->base_vaddr; 562 return range->base_vaddr;
534 } 563 }
535 564
536 565
537 sos_vaddr_t sos_kmem_vmm_free(sos_vaddr_t vadd !! 566 sos_ret_t sos_kmem_vmm_free(sos_vaddr_t vaddr)
538 { 567 {
539 struct sos_kmem_range *range = lookup_range( 568 struct sos_kmem_range *range = lookup_range(vaddr);
540 569
541 570
542 571
543 if (!range || (range->base_vaddr != vaddr)) 572 if (!range || (range->base_vaddr != vaddr))
544 return -SOS_EINVAL; 573 return -SOS_EINVAL;
545 574
546 575
547 if (range->slab != NULL) 576 if (range->slab != NULL)
548 return -SOS_EBUSY; 577 return -SOS_EBUSY;
549 578
550 return sos_kmem_vmm_del_range(range); 579 return sos_kmem_vmm_del_range(range);
551 } 580 }
552 581
553 582
554 sos_ret_t sos_kmem_vmm_set_slab(struct sos_kme 583 sos_ret_t sos_kmem_vmm_set_slab(struct sos_kmem_range *range,
555 struct sos_ksl 584 struct sos_kslab *slab)
556 { 585 {
557 if (! range) 586 if (! range)
558 return -SOS_EINVAL; 587 return -SOS_EINVAL;
559 588
560 range->slab = slab; 589 range->slab = slab;
561 return SOS_OK; 590 return SOS_OK;
562 } 591 }
563 592
564 struct sos_kslab * sos_kmem_vmm_resolve_slab(s 593 struct sos_kslab * sos_kmem_vmm_resolve_slab(sos_vaddr_t vaddr)
565 { 594 {
566 struct sos_kmem_range *range = lookup_range( 595 struct sos_kmem_range *range = lookup_range(vaddr);
567 if (! range) 596 if (! range)
568 return NULL; 597 return NULL;
569 598
570 return range->slab; 599 return range->slab;
571 } 600 }
572 601
>> 602
>> 603 sos_bool_t sos_kmem_vmm_is_valid_vaddr(sos_vaddr_t vaddr)
>> 604 {
>> 605 struct sos_kmem_range *range = lookup_range(vaddr);
>> 606 return (range != NULL);
>> 607 }