Changes in kernel/generic/src/mm/frame.c [905721b:566da7f8] in mainline
- File:
-
- 1 edited
-
kernel/generic/src/mm/frame.c (modified) (58 diffs)
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/mm/frame.c
r905721b r566da7f8 38 38 * 39 39 * This file contains the physical frame allocator and memory zone management. 40 * The frame allocator is built on top of the buddy allocator. 41 * 42 * @see buddy.c 40 * The frame allocator is built on top of the two-level bitmap structure. 41 * 43 42 */ 44 43 … … 55 54 #include <arch.h> 56 55 #include <print.h> 56 #include <log.h> 57 57 #include <align.h> 58 58 #include <mm/slab.h> … … 92 92 } 93 93 94 NO_TRACE static inline size_t make_frame_index(zone_t *zone, frame_t *frame)95 {96 return (frame - zone->frames);97 }98 99 94 /** Initialize frame structure. 100 95 * … … 104 99 NO_TRACE static void frame_initialize(frame_t *frame) 105 100 { 106 frame->refcount = 1;107 frame-> buddy_order = 0;101 frame->refcount = 0; 102 frame->parent = NULL; 108 103 } 109 104 … … 127 122 { 128 123 if (zones.count + 1 == ZONES_MAX) { 129 printf("Maximum zone count %u exceeded!\n", ZONES_MAX); 124 log(LF_OTHER, LVL_ERROR, "Maximum zone count %u exceeded!", 125 ZONES_MAX); 130 126 return (size_t) -1; 131 127 } … … 147 143 (!iswithin(zones.info[i].base, zones.info[i].count, 148 144 base, count))) { 149 printf("Zone (%p, %p) overlaps " 150 "with previous zone (%p %p)!\n", 145 log(LF_OTHER, LVL_WARN, 146 "Zone (%p, %p) overlaps " 147 "with previous zone (%p %p)!", 151 148 (void *) PFN2ADDR(base), (void *) PFN2ADDR(count), 152 149 (void *) PFN2ADDR(zones.info[i].base), … … 161 158 162 159 /* Move other zones up */ 163 size_t j; 164 for (j = zones.count; j > i; j--) { 160 for (size_t j = zones.count; j > i; j--) 165 161 zones.info[j] = zones.info[j - 1]; 166 if (zones.info[j].buddy_system != NULL)167 zones.info[j].buddy_system->data =168 (void *) &zones.info[j];169 }170 162 171 163 zones.count++; … … 237 229 } 238 230 239 /** @return True if zone can allocate specified order */ 240 NO_TRACE static bool zone_can_alloc(zone_t *zone, uint8_t order) 241 { 231 /** @return True if zone can allocate specified number of frames */ 232 NO_TRACE static bool zone_can_alloc(zone_t *zone, size_t count, 233 pfn_t constraint) 234 { 235 /* 236 * The function bitmap_allocate_range() does not modify 237 * the bitmap if the last argument is NULL. 238 */ 239 242 240 return ((zone->flags & ZONE_AVAILABLE) && 243 buddy_system_can_alloc(zone->buddy_system, order)); 244 } 245 246 /** Find a zone that can allocate order frames. 241 bitmap_allocate_range(&zone->bitmap, count, zone->base, 242 FRAME_LOWPRIO, constraint, NULL)); 243 } 244 245 /** Find a zone that can allocate specified number of frames 246 * 247 * This function searches among all zones. Assume interrupts are 248 * disabled and zones lock is locked. 249 * 250 * @param count Number of free frames we are trying to find. 251 * @param flags Required flags of the zone. 252 * @param constraint Indication of bits that cannot be set in the 253 * physical frame number of the first allocated frame. 254 * @param hint Preferred zone. 255 * 256 * @return Zone that can allocate specified number of frames. 257 * @return -1 if no zone can satisfy the request. 258 * 259 */ 260 NO_TRACE static size_t find_free_zone_all(size_t count, zone_flags_t flags, 261 pfn_t constraint, size_t hint) 262 { 263 for (size_t pos = 0; pos < zones.count; pos++) { 264 size_t i = (pos + hint) % zones.count; 265 266 /* Check whether the zone meets the search criteria. */ 267 if (!ZONE_FLAGS_MATCH(zones.info[i].flags, flags)) 268 continue; 269 270 /* Check if the zone can satisfy the allocation request. */ 271 if (zone_can_alloc(&zones.info[i], count, constraint)) 272 return i; 273 } 274 275 return (size_t) -1; 276 } 277 278 /** Check if frame range priority memory 279 * 280 * @param pfn Starting frame. 281 * @param count Number of frames. 282 * 283 * @return True if the range contains only priority memory. 284 * 285 */ 286 NO_TRACE static bool is_high_priority(pfn_t base, size_t count) 287 { 288 return (base + count <= FRAME_LOWPRIO); 289 } 290 291 /** Find a zone that can allocate specified number of frames 292 * 293 * This function ignores zones that contain only high-priority 294 * memory. Assume interrupts are disabled and zones lock is locked. 295 * 296 * @param count Number of free frames we are trying to find. 297 * @param flags Required flags of the zone. 298 * @param constraint Indication of bits that cannot be set in the 299 * physical frame number of the first allocated frame. 300 * @param hint Preferred zone. 301 * 302 * @return Zone that can allocate specified number of frames. 303 * @return -1 if no low-priority zone can satisfy the request. 304 * 305 */ 306 NO_TRACE static size_t find_free_zone_lowprio(size_t count, zone_flags_t flags, 307 pfn_t constraint, size_t hint) 308 { 309 for (size_t pos = 0; pos < zones.count; pos++) { 310 size_t i = (pos + hint) % zones.count; 311 312 /* Skip zones containing only high-priority memory. */ 313 if (is_high_priority(zones.info[i].base, zones.info[i].count)) 314 continue; 315 316 /* Check whether the zone meets the search criteria. */ 317 if (!ZONE_FLAGS_MATCH(zones.info[i].flags, flags)) 318 continue; 319 320 /* Check if the zone can satisfy the allocation request. */ 321 if (zone_can_alloc(&zones.info[i], count, constraint)) 322 return i; 323 } 324 325 return (size_t) -1; 326 } 327 328 /** Find a zone that can allocate specified number of frames 247 329 * 248 330 * Assume interrupts are disabled and zones lock is 249 331 * locked. 250 332 * 251 * @param order Size (2^order) of free space we are trying to find. 252 * @param flags Required flags of the target zone. 253 * @param hind Preferred zone. 254 * 255 */ 256 NO_TRACE static size_t find_free_zone(uint8_t order, zone_flags_t flags, 257 size_t hint) 333 * @param count Number of free frames we are trying to find. 334 * @param flags Required flags of the target zone. 335 * @param constraint Indication of bits that cannot be set in the 336 * physical frame number of the first allocated frame. 337 * @param hint Preferred zone. 338 * 339 * @return Zone that can allocate specified number of frames. 340 * @return -1 if no zone can satisfy the request. 341 * 342 */ 343 NO_TRACE static size_t find_free_zone(size_t count, zone_flags_t flags, 344 pfn_t constraint, size_t hint) 258 345 { 259 346 if (hint >= zones.count) 260 347 hint = 0; 261 348 262 size_t i = hint; 263 do { 264 /* 265 * Check whether the zone meets the search criteria. 266 */ 267 if (ZONE_FLAGS_MATCH(zones.info[i].flags, flags)) { 268 /* 269 * Check if the zone has 2^order frames area available. 270 */ 271 if (zone_can_alloc(&zones.info[i], order)) 272 return i; 273 } 274 275 i++; 276 if (i >= zones.count) 277 i = 0; 278 279 } while (i != hint); 280 281 return (size_t) -1; 282 } 283 284 /**************************/ 285 /* Buddy system functions */ 286 /**************************/ 287 288 /** Buddy system find_block implementation. 289 * 290 * Find block that is parent of current list. 291 * That means go to lower addresses, until such block is found 292 * 293 * @param order Order of parent must be different then this 294 * parameter!! 295 * 296 */ 297 NO_TRACE static link_t *zone_buddy_find_block(buddy_system_t *buddy, 298 link_t *child, uint8_t order) 299 { 300 frame_t *frame = list_get_instance(child, frame_t, buddy_link); 301 zone_t *zone = (zone_t *) buddy->data; 302 303 size_t index = frame_index(zone, frame); 304 do { 305 if (zone->frames[index].buddy_order != order) 306 return &zone->frames[index].buddy_link; 307 } while (index-- > 0); 308 309 return NULL; 310 } 311 312 /** Buddy system find_buddy implementation. 313 * 314 * @param buddy Buddy system. 315 * @param block Block for which buddy should be found. 316 * 317 * @return Buddy for given block if found. 318 * 319 */ 320 NO_TRACE static link_t *zone_buddy_find_buddy(buddy_system_t *buddy, 321 link_t *block) 322 { 323 frame_t *frame = list_get_instance(block, frame_t, buddy_link); 324 zone_t *zone = (zone_t *) buddy->data; 325 ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame), 326 frame->buddy_order)); 327 328 bool is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame); 329 330 size_t index; 331 if (is_left) { 332 index = (frame_index(zone, frame)) + 333 (1 << frame->buddy_order); 334 } else { /* is_right */ 335 index = (frame_index(zone, frame)) - 336 (1 << frame->buddy_order); 337 } 338 339 if (frame_index_valid(zone, index)) { 340 if ((zone->frames[index].buddy_order == frame->buddy_order) && 341 (zone->frames[index].refcount == 0)) { 342 return &zone->frames[index].buddy_link; 343 } 344 } 345 346 return NULL; 347 } 348 349 /** Buddy system bisect implementation. 350 * 351 * @param buddy Buddy system. 352 * @param block Block to bisect. 353 * 354 * @return Right block. 355 * 356 */ 357 NO_TRACE static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block) 358 { 359 frame_t *frame_l = list_get_instance(block, frame_t, buddy_link); 360 frame_t *frame_r = (frame_l + (1 << (frame_l->buddy_order - 1))); 361 362 return &frame_r->buddy_link; 363 } 364 365 /** Buddy system coalesce implementation. 366 * 367 * @param buddy Buddy system. 368 * @param block_1 First block. 369 * @param block_2 First block's buddy. 370 * 371 * @return Coalesced block (actually block that represents lower 372 * address). 373 * 374 */ 375 NO_TRACE static link_t *zone_buddy_coalesce(buddy_system_t *buddy, 376 link_t *block_1, link_t *block_2) 377 { 378 frame_t *frame1 = list_get_instance(block_1, frame_t, buddy_link); 379 frame_t *frame2 = list_get_instance(block_2, frame_t, buddy_link); 380 381 return ((frame1 < frame2) ? block_1 : block_2); 382 } 383 384 /** Buddy system set_order implementation. 385 * 386 * @param buddy Buddy system. 387 * @param block Buddy system block. 388 * @param order Order to set. 389 * 390 */ 391 NO_TRACE static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block, 392 uint8_t order) 393 { 394 list_get_instance(block, frame_t, buddy_link)->buddy_order = order; 395 } 396 397 /** Buddy system get_order implementation. 398 * 399 * @param buddy Buddy system. 400 * @param block Buddy system block. 401 * 402 * @return Order of block. 403 * 404 */ 405 NO_TRACE static uint8_t zone_buddy_get_order(buddy_system_t *buddy, 406 link_t *block) 407 { 408 return list_get_instance(block, frame_t, buddy_link)->buddy_order; 409 } 410 411 /** Buddy system mark_busy implementation. 412 * 413 * @param buddy Buddy system. 414 * @param block Buddy system block. 415 * 416 */ 417 NO_TRACE static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t *block) 418 { 419 list_get_instance(block, frame_t, buddy_link)->refcount = 1; 420 } 421 422 /** Buddy system mark_available implementation. 423 * 424 * @param buddy Buddy system. 425 * @param block Buddy system block. 426 * 427 */ 428 NO_TRACE static void zone_buddy_mark_available(buddy_system_t *buddy, 429 link_t *block) 430 { 431 list_get_instance(block, frame_t, buddy_link)->refcount = 0; 432 } 433 434 static buddy_system_operations_t zone_buddy_system_operations = { 435 .find_buddy = zone_buddy_find_buddy, 436 .bisect = zone_buddy_bisect, 437 .coalesce = zone_buddy_coalesce, 438 .set_order = zone_buddy_set_order, 439 .get_order = zone_buddy_get_order, 440 .mark_busy = zone_buddy_mark_busy, 441 .mark_available = zone_buddy_mark_available, 442 .find_block = zone_buddy_find_block 443 }; 349 /* 350 * Prefer zones with low-priority memory over 351 * zones with high-priority memory. 352 */ 353 354 size_t znum = find_free_zone_lowprio(count, flags, constraint, hint); 355 if (znum != (size_t) -1) 356 return znum; 357 358 /* Take all zones into account */ 359 return find_free_zone_all(count, flags, constraint, hint); 360 } 444 361 445 362 /******************/ … … 447 364 /******************/ 448 365 366 /** Return frame from zone. */ 367 NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t index) 368 { 369 ASSERT(index < zone->count); 370 371 return &zone->frames[index]; 372 } 373 449 374 /** Allocate frame in particular zone. 450 375 * … … 452 377 * Panics if allocation is impossible. 453 378 * 454 * @param zone Zone to allocate from. 455 * @param order Allocate exactly 2^order frames. 379 * @param zone Zone to allocate from. 380 * @param count Number of frames to allocate 381 * @param constraint Indication of bits that cannot be set in the 382 * physical frame number of the first allocated frame. 456 383 * 457 384 * @return Frame index in zone. 458 385 * 459 386 */ 460 NO_TRACE static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order) 387 NO_TRACE static size_t zone_frame_alloc(zone_t *zone, size_t count, 388 pfn_t constraint) 461 389 { 462 390 ASSERT(zone->flags & ZONE_AVAILABLE); 463 391 464 /* Allocate frames from zone buddy system */ 465 link_t *link = buddy_system_alloc(zone->buddy_system, order); 466 467 ASSERT(link); 392 /* Allocate frames from zone */ 393 size_t index = (size_t) -1; 394 int avail = bitmap_allocate_range(&zone->bitmap, count, zone->base, 395 FRAME_LOWPRIO, constraint, &index); 396 397 ASSERT(avail); 398 ASSERT(index != (size_t) -1); 399 400 /* Update frame reference count */ 401 for (size_t i = 0; i < count; i++) { 402 frame_t *frame = zone_get_frame(zone, index + i); 403 404 ASSERT(frame->refcount == 0); 405 frame->refcount = 1; 406 } 468 407 469 408 /* Update zone information. */ 470 zone->free_count -= (1 << order); 471 zone->busy_count += (1 << order); 472 473 /* Frame will be actually a first frame of the block. */ 474 frame_t *frame = list_get_instance(link, frame_t, buddy_link); 475 476 /* Get frame address */ 477 return make_frame_index(zone, frame); 409 zone->free_count -= count; 410 zone->busy_count += count; 411 412 return index; 478 413 } 479 414 … … 482 417 * Assume zone is locked and is available for deallocation. 483 418 * 484 * @param zone 485 * @param frame_idx Frame index relative to zone.486 * 487 * @return 488 * 489 */ 490 NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t frame_idx)419 * @param zone Pointer to zone from which the frame is to be freed. 420 * @param index Frame index relative to zone. 421 * 422 * @return Number of freed frames. 423 * 424 */ 425 NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t index) 491 426 { 492 427 ASSERT(zone->flags & ZONE_AVAILABLE); 493 428 494 frame_t *frame = &zone->frames[frame_idx]; 495 size_t size = 0; 496 497 ASSERT(frame->refcount); 429 frame_t *frame = zone_get_frame(zone, index); 430 431 ASSERT(frame->refcount > 0); 498 432 499 433 if (!--frame->refcount) { 500 size = 1 << frame->buddy_order;501 buddy_system_free(zone->buddy_system, &frame->buddy_link);434 bitmap_set(&zone->bitmap, index, 0); 435 502 436 /* Update zone information. */ 503 zone->free_count += size; 504 zone->busy_count -= size; 505 } 506 507 return size; 508 } 509 510 /** Return frame from zone. */ 511 NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx) 512 { 513 ASSERT(frame_idx < zone->count); 514 return &zone->frames[frame_idx]; 437 zone->free_count++; 438 zone->busy_count--; 439 440 return 1; 441 } 442 443 return 0; 515 444 } 516 445 517 446 /** Mark frame in zone unavailable to allocation. */ 518 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)447 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t index) 519 448 { 520 449 ASSERT(zone->flags & ZONE_AVAILABLE); 521 450 522 frame_t *frame = zone_get_frame(zone, frame_idx);523 if (frame->refcount )451 frame_t *frame = zone_get_frame(zone, index); 452 if (frame->refcount > 0) 524 453 return; 525 454 526 link_t *link __attribute__ ((unused)); 527 528 link = buddy_system_alloc_block(zone->buddy_system, 529 &frame->buddy_link); 530 531 ASSERT(link); 455 frame->refcount = 1; 456 bitmap_set_range(&zone->bitmap, index, 1); 457 532 458 zone->free_count--; 533 459 reserve_force_alloc(1); … … 536 462 /** Merge two zones. 537 463 * 538 * Expect buddy to point to space at least zone_conf_size large.539 464 * Assume z1 & z2 are locked and compatible and zones lock is 540 465 * locked. 541 466 * 542 * @param z1 First zone to merge.543 * @param z2 Second zone to merge.544 * @param old_z1 Original dateof the first zone.545 * @param buddy Merged zone buddy.467 * @param z1 First zone to merge. 468 * @param z2 Second zone to merge. 469 * @param old_z1 Original data of the first zone. 470 * @param confdata Merged zone configuration data. 546 471 * 547 472 */ 548 473 NO_TRACE static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1, 549 buddy_system_t *buddy)474 void *confdata) 550 475 { 551 476 ASSERT(zones.info[z1].flags & ZONE_AVAILABLE); … … 562 487 zones.info[z1].free_count += zones.info[z2].free_count; 563 488 zones.info[z1].busy_count += zones.info[z2].busy_count; 564 zones.info[z1].buddy_system = buddy; 565 566 uint8_t order = fnzb(zones.info[z1].count); 567 buddy_system_create(zones.info[z1].buddy_system, order, 568 &zone_buddy_system_operations, (void *) &zones.info[z1]); 569 570 zones.info[z1].frames = 571 (frame_t *) ((uint8_t *) zones.info[z1].buddy_system 572 + buddy_conf_size(order)); 573 574 /* This marks all frames busy */ 575 size_t i; 576 for (i = 0; i < zones.info[z1].count; i++) 577 frame_initialize(&zones.info[z1].frames[i]); 578 579 /* Copy frames from both zones to preserve full frame orders, 580 * parents etc. Set all free frames with refcount = 0 to 1, because 581 * we add all free frames to buddy allocator later again, clearing 582 * order to 0. Don't set busy frames with refcount = 0, as they 583 * will not be reallocated during merge and it would make later 584 * problems with allocation/free. 489 490 bitmap_initialize(&zones.info[z1].bitmap, zones.info[z1].count, 491 confdata + (sizeof(frame_t) * zones.info[z1].count)); 492 bitmap_clear_range(&zones.info[z1].bitmap, 0, zones.info[z1].count); 493 494 zones.info[z1].frames = (frame_t *) confdata; 495 496 /* 497 * Copy frames and bits from both zones to preserve parents, etc. 585 498 */ 586 for (i = 0; i < old_z1->count; i++) 499 500 for (size_t i = 0; i < old_z1->count; i++) { 501 bitmap_set(&zones.info[z1].bitmap, i, 502 bitmap_get(&old_z1->bitmap, i)); 587 503 zones.info[z1].frames[i] = old_z1->frames[i]; 588 589 for (i = 0; i < zones.info[z2].count; i++) 590 zones.info[z1].frames[base_diff + i] 591 = zones.info[z2].frames[i]; 592 593 i = 0; 594 while (i < zones.info[z1].count) { 595 if (zones.info[z1].frames[i].refcount) { 596 /* Skip busy frames */ 597 i += 1 << zones.info[z1].frames[i].buddy_order; 598 } else { 599 /* Free frames, set refcount = 1 600 * (all free frames have refcount == 0, we need not 601 * to check the order) 602 */ 603 zones.info[z1].frames[i].refcount = 1; 604 zones.info[z1].frames[i].buddy_order = 0; 605 i++; 606 } 607 } 608 609 /* Add free blocks from the original zone z1 */ 610 while (zone_can_alloc(old_z1, 0)) { 611 /* Allocate from the original zone */ 612 pfn_t frame_idx = zone_frame_alloc(old_z1, 0); 613 614 /* Free the frame from the merged zone */ 615 frame_t *frame = &zones.info[z1].frames[frame_idx]; 616 frame->refcount = 0; 617 buddy_system_free(zones.info[z1].buddy_system, &frame->buddy_link); 618 } 619 620 /* Add free blocks from the original zone z2 */ 621 while (zone_can_alloc(&zones.info[z2], 0)) { 622 /* Allocate from the original zone */ 623 pfn_t frame_idx = zone_frame_alloc(&zones.info[z2], 0); 624 625 /* Free the frame from the merged zone */ 626 frame_t *frame = &zones.info[z1].frames[base_diff + frame_idx]; 627 frame->refcount = 0; 628 buddy_system_free(zones.info[z1].buddy_system, &frame->buddy_link); 504 } 505 506 for (size_t i = 0; i < zones.info[z2].count; i++) { 507 bitmap_set(&zones.info[z1].bitmap, base_diff + i, 508 bitmap_get(&zones.info[z2].bitmap, i)); 509 zones.info[z1].frames[base_diff + i] = 510 zones.info[z2].frames[i]; 629 511 } 630 512 } … … 649 531 size_t cframes = SIZE2FRAMES(zone_conf_size(count)); 650 532 651 if ((pfn < zones.info[znum].base) 652 ||(pfn >= zones.info[znum].base + zones.info[znum].count))533 if ((pfn < zones.info[znum].base) || 534 (pfn >= zones.info[znum].base + zones.info[znum].count)) 653 535 return; 654 536 655 frame_t *frame __attribute__ ((unused)); 656 657 frame = &zones.info[znum].frames[pfn - zones.info[znum].base]; 658 ASSERT(!frame->buddy_order); 659 660 size_t i; 661 for (i = 0; i < cframes; i++) { 662 zones.info[znum].busy_count++; 537 for (size_t i = 0; i < cframes; i++) 663 538 (void) zone_frame_free(&zones.info[znum], 664 539 pfn - zones.info[znum].base + i); 665 }666 }667 668 /** Reduce allocated block to count of order 0 frames.669 *670 * The allocated block needs 2^order frames. Reduce all frames671 * in the block to order 0 and free the unneeded frames. This means that672 * when freeing the previously allocated block starting with frame_idx,673 * you have to free every frame.674 *675 * @param znum Zone.676 * @param frame_idx Index the first frame of the block.677 * @param count Allocated frames in block.678 *679 */680 NO_TRACE static void zone_reduce_region(size_t znum, pfn_t frame_idx,681 size_t count)682 {683 ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);684 ASSERT(frame_idx + count < zones.info[znum].count);685 686 uint8_t order = zones.info[znum].frames[frame_idx].buddy_order;687 ASSERT((size_t) (1 << order) >= count);688 689 /* Reduce all blocks to order 0 */690 size_t i;691 for (i = 0; i < (size_t) (1 << order); i++) {692 frame_t *frame = &zones.info[znum].frames[i + frame_idx];693 frame->buddy_order = 0;694 if (!frame->refcount)695 frame->refcount = 1;696 ASSERT(frame->refcount == 1);697 }698 699 /* Free unneeded frames */700 for (i = count; i < (size_t) (1 << order); i++)701 (void) zone_frame_free(&zones.info[znum], i + frame_idx);702 540 } 703 541 … … 719 557 bool ret = true; 720 558 721 /* We can join only 2 zones with none existing inbetween, 559 /* 560 * We can join only 2 zones with none existing inbetween, 722 561 * the zones have to be available and with the same 723 562 * set of flags … … 733 572 + zones.info[z2].count)); 734 573 735 uint8_t order;736 if (cframes == 1)737 order = 0;738 else739 order = fnzb(cframes - 1) + 1;740 741 574 /* Allocate merged zone data inside one of the zones */ 742 575 pfn_t pfn; 743 if (zone_can_alloc(&zones.info[z1], order)) { 744 pfn = zones.info[z1].base + zone_frame_alloc(&zones.info[z1], order); 745 } else if (zone_can_alloc(&zones.info[z2], order)) { 746 pfn = zones.info[z2].base + zone_frame_alloc(&zones.info[z2], order); 576 if (zone_can_alloc(&zones.info[z1], cframes, 0)) { 577 pfn = zones.info[z1].base + 578 zone_frame_alloc(&zones.info[z1], cframes, 0); 579 } else if (zone_can_alloc(&zones.info[z2], cframes, 0)) { 580 pfn = zones.info[z2].base + 581 zone_frame_alloc(&zones.info[z2], cframes, 0); 747 582 } else { 748 583 ret = false; … … 752 587 /* Preserve original data from z1 */ 753 588 zone_t old_z1 = zones.info[z1]; 754 old_z1.buddy_system->data = (void *) &old_z1;755 589 756 590 /* Do zone merging */ 757 buddy_system_t *buddy = (buddy_system_t *) PA2KA(PFN2ADDR(pfn)); 758 zone_merge_internal(z1, z2, &old_z1, buddy); 759 760 /* Free unneeded config frames */ 761 zone_reduce_region(z1, pfn - zones.info[z1].base, cframes); 591 zone_merge_internal(z1, z2, &old_z1, (void *) PA2KA(PFN2ADDR(pfn))); 762 592 763 593 /* Subtract zone information from busy frames */ … … 772 602 773 603 /* Move zones down */ 774 size_t i; 775 for (i = z2 + 1; i < zones.count; i++) { 604 for (size_t i = z2 + 1; i < zones.count; i++) 776 605 zones.info[i - 1] = zones.info[i]; 777 if (zones.info[i - 1].buddy_system != NULL)778 zones.info[i - 1].buddy_system->data =779 (void *) &zones.info[i - 1];780 }781 606 782 607 zones.count--; … … 797 622 void zone_merge_all(void) 798 623 { 799 size_t i = 0; 624 size_t i = 1; 625 800 626 while (i < zones.count) { 801 if (!zone_merge(i , i + 1))627 if (!zone_merge(i - 1, i)) 802 628 i++; 803 629 } … … 806 632 /** Create new frame zone. 807 633 * 808 * @param zone Zone to construct.809 * @param buddy Address of buddy system configuration information.810 * @param start Physical address of the first frame within thezone.811 * @param count Count of frames in zone.812 * @param flags Zone flags.634 * @param zone Zone to construct. 635 * @param start Physical address of the first frame within the zone. 636 * @param count Count of frames in zone. 637 * @param flags Zone flags. 638 * @param confdata Configuration data of the zone. 813 639 * 814 640 * @return Initialized zone. 815 641 * 816 642 */ 817 NO_TRACE static void zone_construct(zone_t *zone, buddy_system_t *buddy,818 pfn_t start, size_t count, zone_flags_t flags)643 NO_TRACE static void zone_construct(zone_t *zone, pfn_t start, size_t count, 644 zone_flags_t flags, void *confdata) 819 645 { 820 646 zone->base = start; … … 823 649 zone->free_count = count; 824 650 zone->busy_count = 0; 825 zone->buddy_system = buddy;826 651 827 652 if (flags & ZONE_AVAILABLE) { 828 653 /* 829 * Compute order for buddy system and initialize 654 * Initialize frame bitmap (located after the array of 655 * frame_t structures in the configuration space). 830 656 */ 831 uint8_t order = fnzb(count);832 b uddy_system_create(zone->buddy_system, order,833 &zone_buddy_system_operations, (void *) zone);834 835 /* Allocate frames _after_ the confframe */836 837 /* Check sizes */838 zone->frames = (frame_t *) ((uint8_t *) zone->buddy_system +839 buddy_conf_size(order));840 841 size_t i;842 for ( i = 0; i < count; i++)657 658 bitmap_initialize(&zone->bitmap, count, confdata + 659 (sizeof(frame_t) * count)); 660 bitmap_clear_range(&zone->bitmap, 0, count); 661 662 /* 663 * Initialize the array of frame_t structures. 664 */ 665 666 zone->frames = (frame_t *) confdata; 667 668 for (size_t i = 0; i < count; i++) 843 669 frame_initialize(&zone->frames[i]); 844 845 /* Stuffing frames */ 846 for (i = 0; i < count; i++) { 847 zone->frames[i].refcount = 0; 848 buddy_system_free(zone->buddy_system, &zone->frames[i].buddy_link); 849 } 850 } else 670 } else { 671 bitmap_initialize(&zone->bitmap, 0, NULL); 851 672 zone->frames = NULL; 673 } 852 674 } 853 675 … … 861 683 size_t zone_conf_size(size_t count) 862 684 { 863 return (count * sizeof(frame_t) + b uddy_conf_size(fnzb(count)));685 return (count * sizeof(frame_t) + bitmap_size(count)); 864 686 } 865 687 … … 867 689 pfn_t zone_external_conf_alloc(size_t count) 868 690 { 869 size_t size = zone_conf_size(count); 870 size_t order = ispwr2(size) ? fnzb(size) : (fnzb(size) + 1); 871 872 return ADDR2PFN((uintptr_t) frame_alloc(order - FRAME_WIDTH, 873 FRAME_LOWMEM | FRAME_ATOMIC)); 691 size_t frames = SIZE2FRAMES(zone_conf_size(count)); 692 693 return ADDR2PFN((uintptr_t) 694 frame_alloc(frames, FRAME_LOWMEM | FRAME_ATOMIC, 0)); 874 695 } 875 696 … … 879 700 * @param count Size of zone in frames. 880 701 * @param confframe Where configuration frames are supposed to be. 881 * Automatically checks ,that we will not disturb the702 * Automatically checks that we will not disturb the 882 703 * kernel and possibly init. If confframe is given 883 704 * _outside_ this zone, it is expected, that the area is … … 896 717 897 718 if (flags & ZONE_AVAILABLE) { /* Create available zone */ 898 /* Theoretically we could have NULL here, practically make sure 719 /* 720 * Theoretically we could have NULL here, practically make sure 899 721 * nobody tries to do that. If some platform requires, remove 900 722 * the assert 901 723 */ 902 724 ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL)); 903 725 904 726 /* Update the known end of physical memory. */ 905 727 config.physmem_end = max(config.physmem_end, PFN2ADDR(start + count)); 906 728 907 /* If confframe is supposed to be inside our zone, then make sure 729 /* 730 * If confframe is supposed to be inside our zone, then make sure 908 731 * it does not span kernel & init 909 732 */ 910 733 size_t confcount = SIZE2FRAMES(zone_conf_size(count)); 734 911 735 if ((confframe >= start) && (confframe < start + count)) { 912 736 for (; confframe < start + count; confframe++) { … … 921 745 922 746 bool overlap = false; 923 size_t i; 924 for (i = 0; i < init.cnt; i++) 747 for (size_t i = 0; i < init.cnt; i++) { 925 748 if (overlaps(addr, PFN2ADDR(confcount), 926 749 init.tasks[i].paddr, … … 929 752 break; 930 753 } 754 } 755 931 756 if (overlap) 932 757 continue; … … 945 770 } 946 771 947 buddy_system_t *buddy = (buddy_system_t*) PA2KA(PFN2ADDR(confframe));948 zone_construct(&zones.info[znum], buddy, start, count, flags);772 void *confdata = (void *) PA2KA(PFN2ADDR(confframe)); 773 zone_construct(&zones.info[znum], start, count, flags, confdata); 949 774 950 775 /* If confdata in zone, mark as unavailable */ 951 776 if ((confframe >= start) && (confframe < start + count)) { 952 size_t i; 953 for (i = confframe; i < confframe + confcount; i++) 777 for (size_t i = confframe; i < confframe + confcount; i++) 954 778 zone_mark_unavailable(&zones.info[znum], 955 779 i - zones.info[znum].base); … … 967 791 return (size_t) -1; 968 792 } 969 zone_construct(&zones.info[znum], NULL, start, count, flags); 793 794 zone_construct(&zones.info[znum], start, count, flags, NULL); 970 795 971 796 irq_spinlock_unlock(&zones.lock, true); … … 1009 834 } 1010 835 1011 /** Allocate power-of-two frames of physical memory. 1012 * 1013 * @param order Allocate exactly 2^order frames. 1014 * @param flags Flags for host zone selection and address processing. 1015 * @param pzone Preferred zone. 836 /** Allocate frames of physical memory. 837 * 838 * @param count Number of continuous frames to allocate. 839 * @param flags Flags for host zone selection and address processing. 840 * @param constraint Indication of physical address bits that cannot be 841 * set in the address of the first allocated frame. 842 * @param pzone Preferred zone. 1016 843 * 1017 844 * @return Physical address of the allocated frame. 1018 845 * 1019 846 */ 1020 void *frame_alloc_generic(uint8_t order, frame_flags_t flags, size_t *pzone) 1021 { 1022 size_t size = ((size_t) 1) << order; 847 uintptr_t frame_alloc_generic(size_t count, frame_flags_t flags, 848 uintptr_t constraint, size_t *pzone) 849 { 850 ASSERT(count > 0); 851 1023 852 size_t hint = pzone ? (*pzone) : 0; 853 pfn_t frame_constraint = ADDR2PFN(constraint); 1024 854 1025 855 /* 1026 856 * If not told otherwise, we must first reserve the memory. 1027 857 */ 1028 if (!(flags & FRAME_NO_RESERVE)) 1029 reserve_force_alloc( size);1030 858 if (!(flags & FRAME_NO_RESERVE)) 859 reserve_force_alloc(count); 860 1031 861 loop: 1032 862 irq_spinlock_lock(&zones.lock, true); … … 1035 865 * First, find suitable frame zone. 1036 866 */ 1037 size_t znum = find_free_zone(order, 1038 FRAME_TO_ZONE_FLAGS(flags), hint); 1039 1040 /* If no memory, reclaim some slab memory, 1041 if it does not help, reclaim all */ 867 size_t znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags), 868 frame_constraint, hint); 869 870 /* 871 * If no memory, reclaim some slab memory, 872 * if it does not help, reclaim all. 873 */ 1042 874 if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) { 1043 875 irq_spinlock_unlock(&zones.lock, true); … … 1046 878 1047 879 if (freed > 0) 1048 znum = find_free_zone( order,1049 FRAME_TO_ZONE_FLAGS(flags), hint);880 znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags), 881 frame_constraint, hint); 1050 882 1051 883 if (znum == (size_t) -1) { … … 1055 887 1056 888 if (freed > 0) 1057 znum = find_free_zone( order,1058 FRAME_TO_ZONE_FLAGS(flags), hint);889 znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags), 890 frame_constraint, hint); 1059 891 } 1060 892 } … … 1063 895 if (flags & FRAME_ATOMIC) { 1064 896 irq_spinlock_unlock(&zones.lock, true); 897 1065 898 if (!(flags & FRAME_NO_RESERVE)) 1066 reserve_free(size); 1067 return NULL; 899 reserve_free(count); 900 901 return 0; 1068 902 } 1069 903 1070 #ifdef CONFIG_DEBUG1071 904 size_t avail = frame_total_free_get_internal(); 1072 #endif1073 905 1074 906 irq_spinlock_unlock(&zones.lock, true); 1075 907 1076 908 if (!THREAD) 1077 panic("Cannot wait for memory to become available."); 909 panic("Cannot wait for %zu frames to become available " 910 "(%zu available).", count, avail); 1078 911 1079 912 /* … … 1082 915 1083 916 #ifdef CONFIG_DEBUG 1084 printf("Thread %" PRIu64 " waiting for %zu frames, " 1085 "%zu available.\n", THREAD->tid, size, avail); 917 log(LF_OTHER, LVL_DEBUG, 918 "Thread %" PRIu64 " waiting for %zu frames " 919 "%zu available.", THREAD->tid, count, avail); 1086 920 #endif 1087 921 1088 922 /* 1089 * Since the mem_avail_mtx is an active mutex, we need to disable interrupts1090 * to prevent deadlock with TLB shootdown.923 * Since the mem_avail_mtx is an active mutex, we need to 924 * disable interrupts to prevent deadlock with TLB shootdown. 1091 925 */ 1092 926 ipl_t ipl = interrupts_disable(); … … 1094 928 1095 929 if (mem_avail_req > 0) 1096 mem_avail_req = min(mem_avail_req, size);930 mem_avail_req = min(mem_avail_req, count); 1097 931 else 1098 mem_avail_req = size; 932 mem_avail_req = count; 933 1099 934 size_t gen = mem_avail_gen; 1100 935 … … 1106 941 1107 942 #ifdef CONFIG_DEBUG 1108 printf("Thread %" PRIu64 " woken up.\n", THREAD->tid); 943 log(LF_OTHER, LVL_DEBUG, "Thread %" PRIu64 " woken up.", 944 THREAD->tid); 1109 945 #endif 1110 946 … … 1112 948 } 1113 949 1114 pfn_t pfn = zone_frame_alloc(&zones.info[znum], order)1115 + zones.info[znum].base;950 pfn_t pfn = zone_frame_alloc(&zones.info[znum], count, 951 frame_constraint) + zones.info[znum].base; 1116 952 1117 953 irq_spinlock_unlock(&zones.lock, true); … … 1120 956 *pzone = znum; 1121 957 1122 if (flags & FRAME_KA) 1123 return (void *) PA2KA(PFN2ADDR(pfn)); 1124 1125 return (void *) PFN2ADDR(pfn); 1126 } 1127 1128 void *frame_alloc(uint8_t order, frame_flags_t flags) 1129 { 1130 return frame_alloc_generic(order, flags, NULL); 1131 } 1132 1133 void *frame_alloc_noreserve(uint8_t order, frame_flags_t flags) 1134 { 1135 return frame_alloc_generic(order, flags | FRAME_NO_RESERVE, NULL); 1136 } 1137 1138 /** Free a frame. 1139 * 1140 * Find respective frame structure for supplied physical frame address. 1141 * Decrement frame reference count. If it drops to zero, move the frame 1142 * structure to free list. 1143 * 1144 * @param frame Physical Address of of the frame to be freed. 958 return PFN2ADDR(pfn); 959 } 960 961 uintptr_t frame_alloc(size_t count, frame_flags_t flags, uintptr_t constraint) 962 { 963 return frame_alloc_generic(count, flags, constraint, NULL); 964 } 965 966 /** Free frames of physical memory. 967 * 968 * Find respective frame structures for supplied physical frames. 969 * Decrement each frame reference count. If it drops to zero, mark 970 * the frames as available. 971 * 972 * @param start Physical Address of the first frame to be freed. 973 * @param count Number of frames to free. 1145 974 * @param flags Flags to control memory reservation. 1146 975 * 1147 976 */ 1148 void frame_free_generic(uintptr_t frame, frame_flags_t flags)1149 { 1150 size_t size;977 void frame_free_generic(uintptr_t start, size_t count, frame_flags_t flags) 978 { 979 size_t freed = 0; 1151 980 1152 981 irq_spinlock_lock(&zones.lock, true); 1153 982 1154 /* 1155 * First, find host frame zone for addr. 1156 */ 1157 pfn_t pfn = ADDR2PFN(frame); 1158 size_t znum = find_zone(pfn, 1, 0); 1159 1160 ASSERT(znum != (size_t) -1); 1161 1162 size = zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base); 983 for (size_t i = 0; i < count; i++) { 984 /* 985 * First, find host frame zone for addr. 986 */ 987 pfn_t pfn = ADDR2PFN(start) + i; 988 size_t znum = find_zone(pfn, 1, 0); 989 990 ASSERT(znum != (size_t) -1); 991 992 freed += zone_frame_free(&zones.info[znum], 993 pfn - zones.info[znum].base); 994 } 1163 995 1164 996 irq_spinlock_unlock(&zones.lock, true); … … 1166 998 /* 1167 999 * Signal that some memory has been freed. 1000 * Since the mem_avail_mtx is an active mutex, 1001 * we need to disable interruptsto prevent deadlock 1002 * with TLB shootdown. 1168 1003 */ 1169 1170 1171 /* 1172 * Since the mem_avail_mtx is an active mutex, we need to disable interrupts 1173 * to prevent deadlock with TLB shootdown. 1174 */ 1004 1175 1005 ipl_t ipl = interrupts_disable(); 1176 1006 mutex_lock(&mem_avail_mtx); 1007 1177 1008 if (mem_avail_req > 0) 1178 mem_avail_req -= min(mem_avail_req, size);1009 mem_avail_req -= min(mem_avail_req, freed); 1179 1010 1180 1011 if (mem_avail_req == 0) { … … 1182 1013 condvar_broadcast(&mem_avail_cv); 1183 1014 } 1015 1184 1016 mutex_unlock(&mem_avail_mtx); 1185 1017 interrupts_restore(ipl); 1186 1018 1187 1019 if (!(flags & FRAME_NO_RESERVE)) 1188 reserve_free( size);1189 } 1190 1191 void frame_free(uintptr_t frame )1192 { 1193 frame_free_generic(frame, 0);1194 } 1195 1196 void frame_free_noreserve(uintptr_t frame )1197 { 1198 frame_free_generic(frame, FRAME_NO_RESERVE);1020 reserve_free(freed); 1021 } 1022 1023 void frame_free(uintptr_t frame, size_t count) 1024 { 1025 frame_free_generic(frame, count, 0); 1026 } 1027 1028 void frame_free_noreserve(uintptr_t frame, size_t count) 1029 { 1030 frame_free_generic(frame, count, FRAME_NO_RESERVE); 1199 1031 } 1200 1032 … … 1230 1062 irq_spinlock_lock(&zones.lock, true); 1231 1063 1232 size_t i; 1233 for (i = 0; i < count; i++) { 1064 for (size_t i = 0; i < count; i++) { 1234 1065 size_t znum = find_zone(start + i, 1, 0); 1066 1235 1067 if (znum == (size_t) -1) /* PFN not found */ 1236 1068 continue; … … 1257 1089 /* Tell the architecture to create some memory */ 1258 1090 frame_low_arch_init(); 1091 1259 1092 if (config.cpu_active == 1) { 1260 1093 frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)), … … 1263 1096 SIZE2FRAMES(config.stack_size)); 1264 1097 1265 size_t i; 1266 for (i = 0; i < init.cnt; i++) { 1267 pfn_t pfn = ADDR2PFN(init.tasks[i].paddr); 1268 frame_mark_unavailable(pfn, 1098 for (size_t i = 0; i < init.cnt; i++) 1099 frame_mark_unavailable(ADDR2PFN(init.tasks[i].paddr), 1269 1100 SIZE2FRAMES(init.tasks[i].size)); 1270 }1271 1101 1272 1102 if (ballocs.size) … … 1274 1104 SIZE2FRAMES(ballocs.size)); 1275 1105 1276 /* Black list first frame, as allocating NULL would 1106 /* 1107 * Blacklist first frame, as allocating NULL would 1277 1108 * fail in some places 1278 1109 */ 1279 1110 frame_mark_unavailable(0, 1); 1280 1111 } 1112 1281 1113 frame_high_arch_init(); 1282 1114 } … … 1284 1116 /** Adjust bounds of physical memory region according to low/high memory split. 1285 1117 * 1286 * @param low[in] If true, the adjustment is performed to make the region 1287 * fit in the low memory. Otherwise the adjustment is 1288 * performed to make the region fit in the high memory. 1289 * @param basep[inout] Pointer to a variable which contains the region's base 1290 * address and which may receive the adjusted base address. 1291 * @param sizep[inout] Pointer to a variable which contains the region's size 1292 * and which may receive the adjusted size. 1293 * @retun True if the region still exists even after the 1294 * adjustment, false otherwise. 1118 * @param low[in] If true, the adjustment is performed to make the region 1119 * fit in the low memory. Otherwise the adjustment is 1120 * performed to make the region fit in the high memory. 1121 * @param basep[inout] Pointer to a variable which contains the region's base 1122 * address and which may receive the adjusted base address. 1123 * @param sizep[inout] Pointer to a variable which contains the region's size 1124 * and which may receive the adjusted size. 1125 * 1126 * @return True if the region still exists even after the adjustment. 1127 * @return False otherwise. 1128 * 1295 1129 */ 1296 1130 bool frame_adjust_zone_bounds(bool low, uintptr_t *basep, size_t *sizep) 1297 1131 { 1298 1132 uintptr_t limit = KA2PA(config.identity_base) + config.identity_size; 1299 1133 1300 1134 if (low) { 1301 1135 if (*basep > limit) 1302 1136 return false; 1137 1303 1138 if (*basep + *sizep > limit) 1304 1139 *sizep = limit - *basep; … … 1306 1141 if (*basep + *sizep <= limit) 1307 1142 return false; 1143 1308 1144 if (*basep <= limit) { 1309 1145 *sizep -= limit - *basep; … … 1311 1147 } 1312 1148 } 1149 1313 1150 return true; 1314 1151 } … … 1322 1159 1323 1160 uint64_t total = 0; 1324 size_t i;1325 for ( i = 0; i < zones.count; i++)1161 1162 for (size_t i = 0; i < zones.count; i++) 1326 1163 total += (uint64_t) FRAMES2SIZE(zones.info[i].count); 1327 1164 … … 1346 1183 *free = 0; 1347 1184 1348 size_t i; 1349 for (i = 0; i < zones.count; i++) { 1185 for (size_t i = 0; i < zones.count; i++) { 1350 1186 *total += (uint64_t) FRAMES2SIZE(zones.info[i].count); 1351 1187 … … 1375 1211 /* 1376 1212 * Because printing may require allocation of memory, we may not hold 1377 * the frame allocator locks when printing zone statistics. 1213 * the frame allocator locks when printing zone statistics. Therefore, 1378 1214 * we simply gather the statistics under the protection of the locks and 1379 1215 * print the statistics when the locks have been released. … … 1384 1220 */ 1385 1221 1386 size_t i; 1387 for (i = 0;; i++) { 1222 size_t free_lowmem = 0; 1223 size_t free_highmem = 0; 1224 size_t free_highprio = 0; 1225 1226 for (size_t i = 0;; i++) { 1388 1227 irq_spinlock_lock(&zones.lock, true); 1389 1228 … … 1393 1232 } 1394 1233 1395 uintptr_t base = PFN2ADDR(zones.info[i].base); 1234 pfn_t fbase = zones.info[i].base; 1235 uintptr_t base = PFN2ADDR(fbase); 1396 1236 size_t count = zones.info[i].count; 1397 1237 zone_flags_t flags = zones.info[i].flags; … … 1399 1239 size_t busy_count = zones.info[i].busy_count; 1400 1240 1241 bool available = ((flags & ZONE_AVAILABLE) != 0); 1242 bool lowmem = ((flags & ZONE_LOWMEM) != 0); 1243 bool highmem = ((flags & ZONE_HIGHMEM) != 0); 1244 bool highprio = is_high_priority(fbase, count); 1245 1246 if (available) { 1247 if (lowmem) 1248 free_lowmem += free_count; 1249 1250 if (highmem) 1251 free_highmem += free_count; 1252 1253 if (highprio) { 1254 free_highprio += free_count; 1255 } else { 1256 /* 1257 * Walk all frames of the zone and examine 1258 * all high priority memory to get accurate 1259 * statistics. 1260 */ 1261 1262 for (size_t index = 0; index < count; index++) { 1263 if (is_high_priority(fbase + index, 0)) { 1264 if (!bitmap_get(&zones.info[i].bitmap, index)) 1265 free_highprio++; 1266 } else 1267 break; 1268 } 1269 } 1270 } 1271 1401 1272 irq_spinlock_unlock(&zones.lock, true); 1402 1403 bool available = ((flags & ZONE_AVAILABLE) != 0);1404 1273 1405 1274 printf("%-4zu", i); … … 1426 1295 printf("\n"); 1427 1296 } 1297 1298 printf("\n"); 1299 1300 uint64_t size; 1301 const char *size_suffix; 1302 1303 bin_order_suffix(FRAMES2SIZE(free_lowmem), &size, &size_suffix, 1304 false); 1305 printf("Available low memory: %zu frames (%" PRIu64 " %s)\n", 1306 free_lowmem, size, size_suffix); 1307 1308 bin_order_suffix(FRAMES2SIZE(free_highmem), &size, &size_suffix, 1309 false); 1310 printf("Available high memory: %zu frames (%" PRIu64 " %s)\n", 1311 free_highmem, size, size_suffix); 1312 1313 bin_order_suffix(FRAMES2SIZE(free_highprio), &size, &size_suffix, 1314 false); 1315 printf("Available high priority: %zu frames (%" PRIu64 " %s)\n", 1316 free_highprio, size, size_suffix); 1428 1317 } 1429 1318 … … 1438 1327 size_t znum = (size_t) -1; 1439 1328 1440 size_t i; 1441 for (i = 0; i < zones.count; i++) { 1329 for (size_t i = 0; i < zones.count; i++) { 1442 1330 if ((i == num) || (PFN2ADDR(zones.info[i].base) == num)) { 1443 1331 znum = i; … … 1452 1340 } 1453 1341 1454 uintptr_t base = PFN2ADDR(zones.info[i].base); 1455 zone_flags_t flags = zones.info[i].flags; 1456 size_t count = zones.info[i].count; 1457 size_t free_count = zones.info[i].free_count; 1458 size_t busy_count = zones.info[i].busy_count; 1342 size_t free_lowmem = 0; 1343 size_t free_highmem = 0; 1344 size_t free_highprio = 0; 1345 1346 pfn_t fbase = zones.info[znum].base; 1347 uintptr_t base = PFN2ADDR(fbase); 1348 zone_flags_t flags = zones.info[znum].flags; 1349 size_t count = zones.info[znum].count; 1350 size_t free_count = zones.info[znum].free_count; 1351 size_t busy_count = zones.info[znum].busy_count; 1352 1353 bool available = ((flags & ZONE_AVAILABLE) != 0); 1354 bool lowmem = ((flags & ZONE_LOWMEM) != 0); 1355 bool highmem = ((flags & ZONE_HIGHMEM) != 0); 1356 bool highprio = is_high_priority(fbase, count); 1357 1358 if (available) { 1359 if (lowmem) 1360 free_lowmem = free_count; 1361 1362 if (highmem) 1363 free_highmem = free_count; 1364 1365 if (highprio) { 1366 free_highprio = free_count; 1367 } else { 1368 /* 1369 * Walk all frames of the zone and examine 1370 * all high priority memory to get accurate 1371 * statistics. 1372 */ 1373 1374 for (size_t index = 0; index < count; index++) { 1375 if (is_high_priority(fbase + index, 0)) { 1376 if (!bitmap_get(&zones.info[znum].bitmap, index)) 1377 free_highprio++; 1378 } else 1379 break; 1380 } 1381 } 1382 } 1459 1383 1460 1384 irq_spinlock_unlock(&zones.lock, true); 1461 1462 bool available = ((flags & ZONE_AVAILABLE) != 0);1463 1385 1464 1386 uint64_t size; 1465 1387 const char *size_suffix; 1388 1466 1389 bin_order_suffix(FRAMES2SIZE(count), &size, &size_suffix, false); 1467 1390 1468 printf("Zone number: %zu\n", znum);1469 printf("Zone base address: %p\n", (void *) base);1470 printf("Zone size: %zu frames (%" PRIu64 " %s)\n", count,1391 printf("Zone number: %zu\n", znum); 1392 printf("Zone base address: %p\n", (void *) base); 1393 printf("Zone size: %zu frames (%" PRIu64 " %s)\n", count, 1471 1394 size, size_suffix); 1472 printf("Zone flags: %c%c%c%c%c\n",1395 printf("Zone flags: %c%c%c%c%c\n", 1473 1396 available ? 'A' : '-', 1474 1397 (flags & ZONE_RESERVED) ? 'R' : '-', … … 1480 1403 bin_order_suffix(FRAMES2SIZE(busy_count), &size, &size_suffix, 1481 1404 false); 1482 printf("Allocated space: %zu frames (%" PRIu64 " %s)\n",1405 printf("Allocated space: %zu frames (%" PRIu64 " %s)\n", 1483 1406 busy_count, size, size_suffix); 1407 1484 1408 bin_order_suffix(FRAMES2SIZE(free_count), &size, &size_suffix, 1485 1409 false); 1486 printf("Available space: %zu frames (%" PRIu64 " %s)\n",1410 printf("Available space: %zu frames (%" PRIu64 " %s)\n", 1487 1411 free_count, size, size_suffix); 1412 1413 bin_order_suffix(FRAMES2SIZE(free_lowmem), &size, &size_suffix, 1414 false); 1415 printf("Available low memory: %zu frames (%" PRIu64 " %s)\n", 1416 free_lowmem, size, size_suffix); 1417 1418 bin_order_suffix(FRAMES2SIZE(free_highmem), &size, &size_suffix, 1419 false); 1420 printf("Available high memory: %zu frames (%" PRIu64 " %s)\n", 1421 free_highmem, size, size_suffix); 1422 1423 bin_order_suffix(FRAMES2SIZE(free_highprio), &size, &size_suffix, 1424 false); 1425 printf("Available high priority: %zu frames (%" PRIu64 " %s)\n", 1426 free_highprio, size, size_suffix); 1488 1427 } 1489 1428 }
Note:
See TracChangeset
for help on using the changeset viewer.
