Changes in kernel/generic/src/mm/frame.c [905721b:9a5abb78] 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 r9a5abb78 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; 394 int avail = bitmap_allocate_range(&zone->bitmap, count, zone->base, 395 FRAME_LOWPRIO, constraint, &index); 396 397 ASSERT(avail); 398 399 /* Update frame reference count */ 400 for (size_t i = 0; i < count; i++) { 401 frame_t *frame = zone_get_frame(zone, index + i); 402 403 ASSERT(frame->refcount == 0); 404 frame->refcount = 1; 405 } 468 406 469 407 /* 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); 408 zone->free_count -= count; 409 zone->busy_count += count; 410 411 return index; 478 412 } 479 413 … … 482 416 * Assume zone is locked and is available for deallocation. 483 417 * 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)418 * @param zone Pointer to zone from which the frame is to be freed. 419 * @param index Frame index relative to zone. 420 * 421 * @return Number of freed frames. 422 * 423 */ 424 NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t index) 491 425 { 492 426 ASSERT(zone->flags & ZONE_AVAILABLE); 493 427 494 frame_t *frame = &zone->frames[frame_idx]; 495 size_t size = 0; 496 497 ASSERT(frame->refcount); 428 frame_t *frame = zone_get_frame(zone, index); 429 430 ASSERT(frame->refcount > 0); 498 431 499 432 if (!--frame->refcount) { 500 size = 1 << frame->buddy_order;501 buddy_system_free(zone->buddy_system, &frame->buddy_link);433 bitmap_set(&zone->bitmap, index, 0); 434 502 435 /* 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]; 436 zone->free_count++; 437 zone->busy_count--; 438 439 return 1; 440 } 441 442 return 0; 515 443 } 516 444 517 445 /** Mark frame in zone unavailable to allocation. */ 518 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)446 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t index) 519 447 { 520 448 ASSERT(zone->flags & ZONE_AVAILABLE); 521 449 522 frame_t *frame = zone_get_frame(zone, frame_idx);523 if (frame->refcount )450 frame_t *frame = zone_get_frame(zone, index); 451 if (frame->refcount > 0) 524 452 return; 525 453 526 link_t *link __attribute__ ((unused)); 527 528 link = buddy_system_alloc_block(zone->buddy_system, 529 &frame->buddy_link); 530 531 ASSERT(link); 454 frame->refcount = 1; 455 bitmap_set_range(&zone->bitmap, index, 1); 456 532 457 zone->free_count--; 533 458 reserve_force_alloc(1); … … 536 461 /** Merge two zones. 537 462 * 538 * Expect buddy to point to space at least zone_conf_size large.539 463 * Assume z1 & z2 are locked and compatible and zones lock is 540 464 * locked. 541 465 * 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.466 * @param z1 First zone to merge. 467 * @param z2 Second zone to merge. 468 * @param old_z1 Original data of the first zone. 469 * @param confdata Merged zone configuration data. 546 470 * 547 471 */ 548 472 NO_TRACE static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1, 549 buddy_system_t *buddy)473 void *confdata) 550 474 { 551 475 ASSERT(zones.info[z1].flags & ZONE_AVAILABLE); … … 562 486 zones.info[z1].free_count += zones.info[z2].free_count; 563 487 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. 488 489 bitmap_initialize(&zones.info[z1].bitmap, zones.info[z1].count, 490 confdata + (sizeof(frame_t) * zones.info[z1].count)); 491 bitmap_clear_range(&zones.info[z1].bitmap, 0, zones.info[z1].count); 492 493 zones.info[z1].frames = (frame_t *) confdata; 494 495 /* 496 * Copy frames and bits from both zones to preserve parents, etc. 585 497 */ 586 for (i = 0; i < old_z1->count; i++) 498 499 for (size_t i = 0; i < old_z1->count; i++) { 500 bitmap_set(&zones.info[z1].bitmap, i, 501 bitmap_get(&old_z1->bitmap, i)); 587 502 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); 503 } 504 505 for (size_t i = 0; i < zones.info[z2].count; i++) { 506 bitmap_set(&zones.info[z1].bitmap, base_diff + i, 507 bitmap_get(&zones.info[z2].bitmap, i)); 508 zones.info[z1].frames[base_diff + i] = 509 zones.info[z2].frames[i]; 629 510 } 630 511 } … … 649 530 size_t cframes = SIZE2FRAMES(zone_conf_size(count)); 650 531 651 if ((pfn < zones.info[znum].base) 652 ||(pfn >= zones.info[znum].base + zones.info[znum].count))532 if ((pfn < zones.info[znum].base) || 533 (pfn >= zones.info[znum].base + zones.info[znum].count)) 653 534 return; 654 535 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++; 536 for (size_t i = 0; i < cframes; i++) 663 537 (void) zone_frame_free(&zones.info[znum], 664 538 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 539 } 703 540 … … 719 556 bool ret = true; 720 557 721 /* We can join only 2 zones with none existing inbetween, 558 /* 559 * We can join only 2 zones with none existing inbetween, 722 560 * the zones have to be available and with the same 723 561 * set of flags … … 733 571 + zones.info[z2].count)); 734 572 735 uint8_t order;736 if (cframes == 1)737 order = 0;738 else739 order = fnzb(cframes - 1) + 1;740 741 573 /* Allocate merged zone data inside one of the zones */ 742 574 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); 575 if (zone_can_alloc(&zones.info[z1], cframes, 0)) { 576 pfn = zones.info[z1].base + 577 zone_frame_alloc(&zones.info[z1], cframes, 0); 578 } else if (zone_can_alloc(&zones.info[z2], cframes, 0)) { 579 pfn = zones.info[z2].base + 580 zone_frame_alloc(&zones.info[z2], cframes, 0); 747 581 } else { 748 582 ret = false; … … 752 586 /* Preserve original data from z1 */ 753 587 zone_t old_z1 = zones.info[z1]; 754 old_z1.buddy_system->data = (void *) &old_z1;755 588 756 589 /* 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); 590 zone_merge_internal(z1, z2, &old_z1, (void *) PA2KA(PFN2ADDR(pfn))); 762 591 763 592 /* Subtract zone information from busy frames */ … … 772 601 773 602 /* Move zones down */ 774 size_t i; 775 for (i = z2 + 1; i < zones.count; i++) { 603 for (size_t i = z2 + 1; i < zones.count; i++) 776 604 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 605 782 606 zones.count--; … … 797 621 void zone_merge_all(void) 798 622 { 799 size_t i = 0; 623 size_t i = 1; 624 800 625 while (i < zones.count) { 801 if (!zone_merge(i , i + 1))626 if (!zone_merge(i - 1, i)) 802 627 i++; 803 628 } … … 806 631 /** Create new frame zone. 807 632 * 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.633 * @param zone Zone to construct. 634 * @param start Physical address of the first frame within the zone. 635 * @param count Count of frames in zone. 636 * @param flags Zone flags. 637 * @param confdata Configuration data of the zone. 813 638 * 814 639 * @return Initialized zone. 815 640 * 816 641 */ 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)642 NO_TRACE static void zone_construct(zone_t *zone, pfn_t start, size_t count, 643 zone_flags_t flags, void *confdata) 819 644 { 820 645 zone->base = start; … … 823 648 zone->free_count = count; 824 649 zone->busy_count = 0; 825 zone->buddy_system = buddy;826 650 827 651 if (flags & ZONE_AVAILABLE) { 828 652 /* 829 * Compute order for buddy system and initialize 653 * Initialize frame bitmap (located after the array of 654 * frame_t structures in the configuration space). 830 655 */ 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++)656 657 bitmap_initialize(&zone->bitmap, count, confdata + 658 (sizeof(frame_t) * count)); 659 bitmap_clear_range(&zone->bitmap, 0, count); 660 661 /* 662 * Initialize the array of frame_t structures. 663 */ 664 665 zone->frames = (frame_t *) confdata; 666 667 for (size_t i = 0; i < count; i++) 843 668 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 669 } else { 670 bitmap_initialize(&zone->bitmap, 0, NULL); 851 671 zone->frames = NULL; 672 } 852 673 } 853 674 … … 861 682 size_t zone_conf_size(size_t count) 862 683 { 863 return (count * sizeof(frame_t) + b uddy_conf_size(fnzb(count)));684 return (count * sizeof(frame_t) + bitmap_size(count)); 864 685 } 865 686 … … 867 688 pfn_t zone_external_conf_alloc(size_t count) 868 689 { 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)); 690 size_t frames = SIZE2FRAMES(zone_conf_size(count)); 691 692 return ADDR2PFN((uintptr_t) 693 frame_alloc(frames, FRAME_LOWMEM | FRAME_ATOMIC, 0)); 874 694 } 875 695 … … 879 699 * @param count Size of zone in frames. 880 700 * @param confframe Where configuration frames are supposed to be. 881 * Automatically checks ,that we will not disturb the701 * Automatically checks that we will not disturb the 882 702 * kernel and possibly init. If confframe is given 883 703 * _outside_ this zone, it is expected, that the area is … … 896 716 897 717 if (flags & ZONE_AVAILABLE) { /* Create available zone */ 898 /* Theoretically we could have NULL here, practically make sure 718 /* 719 * Theoretically we could have NULL here, practically make sure 899 720 * nobody tries to do that. If some platform requires, remove 900 721 * the assert 901 722 */ 902 723 ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL)); 903 724 904 725 /* Update the known end of physical memory. */ 905 726 config.physmem_end = max(config.physmem_end, PFN2ADDR(start + count)); 906 727 907 /* If confframe is supposed to be inside our zone, then make sure 728 /* 729 * If confframe is supposed to be inside our zone, then make sure 908 730 * it does not span kernel & init 909 731 */ 910 732 size_t confcount = SIZE2FRAMES(zone_conf_size(count)); 733 911 734 if ((confframe >= start) && (confframe < start + count)) { 912 735 for (; confframe < start + count; confframe++) { … … 921 744 922 745 bool overlap = false; 923 size_t i; 924 for (i = 0; i < init.cnt; i++) 746 for (size_t i = 0; i < init.cnt; i++) { 925 747 if (overlaps(addr, PFN2ADDR(confcount), 926 748 init.tasks[i].paddr, … … 929 751 break; 930 752 } 753 } 754 931 755 if (overlap) 932 756 continue; … … 945 769 } 946 770 947 buddy_system_t *buddy = (buddy_system_t*) PA2KA(PFN2ADDR(confframe));948 zone_construct(&zones.info[znum], buddy, start, count, flags);771 void *confdata = (void *) PA2KA(PFN2ADDR(confframe)); 772 zone_construct(&zones.info[znum], start, count, flags, confdata); 949 773 950 774 /* If confdata in zone, mark as unavailable */ 951 775 if ((confframe >= start) && (confframe < start + count)) { 952 size_t i; 953 for (i = confframe; i < confframe + confcount; i++) 776 for (size_t i = confframe; i < confframe + confcount; i++) 954 777 zone_mark_unavailable(&zones.info[znum], 955 778 i - zones.info[znum].base); … … 967 790 return (size_t) -1; 968 791 } 969 zone_construct(&zones.info[znum], NULL, start, count, flags); 792 793 zone_construct(&zones.info[znum], start, count, flags, NULL); 970 794 971 795 irq_spinlock_unlock(&zones.lock, true); … … 1009 833 } 1010 834 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. 835 /** Allocate frames of physical memory. 836 * 837 * @param count Number of continuous frames to allocate. 838 * @param flags Flags for host zone selection and address processing. 839 * @param constraint Indication of physical address bits that cannot be 840 * set in the address of the first allocated frame. 841 * @param pzone Preferred zone. 1016 842 * 1017 843 * @return Physical address of the allocated frame. 1018 844 * 1019 845 */ 1020 void *frame_alloc_generic(uint8_t order, frame_flags_t flags, size_t *pzone) 1021 { 1022 size_t size = ((size_t) 1) << order; 846 uintptr_t frame_alloc_generic(size_t count, frame_flags_t flags, 847 uintptr_t constraint, size_t *pzone) 848 { 849 ASSERT(count > 0); 850 1023 851 size_t hint = pzone ? (*pzone) : 0; 852 pfn_t frame_constraint = ADDR2PFN(constraint); 1024 853 1025 854 /* 1026 855 * If not told otherwise, we must first reserve the memory. 1027 856 */ 1028 if (!(flags & FRAME_NO_RESERVE)) 1029 reserve_force_alloc( size);1030 857 if (!(flags & FRAME_NO_RESERVE)) 858 reserve_force_alloc(count); 859 1031 860 loop: 1032 861 irq_spinlock_lock(&zones.lock, true); … … 1035 864 * First, find suitable frame zone. 1036 865 */ 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 */ 866 size_t znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags), 867 frame_constraint, hint); 868 869 /* 870 * If no memory, reclaim some slab memory, 871 * if it does not help, reclaim all. 872 */ 1042 873 if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) { 1043 874 irq_spinlock_unlock(&zones.lock, true); … … 1046 877 1047 878 if (freed > 0) 1048 znum = find_free_zone( order,1049 FRAME_TO_ZONE_FLAGS(flags), hint);879 znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags), 880 frame_constraint, hint); 1050 881 1051 882 if (znum == (size_t) -1) { … … 1055 886 1056 887 if (freed > 0) 1057 znum = find_free_zone( order,1058 FRAME_TO_ZONE_FLAGS(flags), hint);888 znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags), 889 frame_constraint, hint); 1059 890 } 1060 891 } … … 1063 894 if (flags & FRAME_ATOMIC) { 1064 895 irq_spinlock_unlock(&zones.lock, true); 896 1065 897 if (!(flags & FRAME_NO_RESERVE)) 1066 reserve_free(size); 1067 return NULL; 898 reserve_free(count); 899 900 return 0; 1068 901 } 1069 902 1070 #ifdef CONFIG_DEBUG1071 903 size_t avail = frame_total_free_get_internal(); 1072 #endif1073 904 1074 905 irq_spinlock_unlock(&zones.lock, true); 1075 906 1076 907 if (!THREAD) 1077 panic("Cannot wait for memory to become available."); 908 panic("Cannot wait for %zu frames to become available " 909 "(%zu available).", count, avail); 1078 910 1079 911 /* … … 1082 914 1083 915 #ifdef CONFIG_DEBUG 1084 printf("Thread %" PRIu64 " waiting for %zu frames, " 1085 "%zu available.\n", THREAD->tid, size, avail); 916 log(LF_OTHER, LVL_DEBUG, 917 "Thread %" PRIu64 " waiting for %zu frames " 918 "%zu available.", THREAD->tid, count, avail); 1086 919 #endif 1087 920 1088 921 /* 1089 * Since the mem_avail_mtx is an active mutex, we need to disable interrupts1090 * to prevent deadlock with TLB shootdown.922 * Since the mem_avail_mtx is an active mutex, we need to 923 * disable interrupts to prevent deadlock with TLB shootdown. 1091 924 */ 1092 925 ipl_t ipl = interrupts_disable(); … … 1094 927 1095 928 if (mem_avail_req > 0) 1096 mem_avail_req = min(mem_avail_req, size);929 mem_avail_req = min(mem_avail_req, count); 1097 930 else 1098 mem_avail_req = size; 931 mem_avail_req = count; 932 1099 933 size_t gen = mem_avail_gen; 1100 934 … … 1106 940 1107 941 #ifdef CONFIG_DEBUG 1108 printf("Thread %" PRIu64 " woken up.\n", THREAD->tid); 942 log(LF_OTHER, LVL_DEBUG, "Thread %" PRIu64 " woken up.", 943 THREAD->tid); 1109 944 #endif 1110 945 … … 1112 947 } 1113 948 1114 pfn_t pfn = zone_frame_alloc(&zones.info[znum], order)1115 + zones.info[znum].base;949 pfn_t pfn = zone_frame_alloc(&zones.info[znum], count, 950 frame_constraint) + zones.info[znum].base; 1116 951 1117 952 irq_spinlock_unlock(&zones.lock, true); … … 1120 955 *pzone = znum; 1121 956 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. 957 return PFN2ADDR(pfn); 958 } 959 960 uintptr_t frame_alloc(size_t count, frame_flags_t flags, uintptr_t constraint) 961 { 962 return frame_alloc_generic(count, flags, constraint, NULL); 963 } 964 965 /** Free frames of physical memory. 966 * 967 * Find respective frame structures for supplied physical frames. 968 * Decrement each frame reference count. If it drops to zero, mark 969 * the frames as available. 970 * 971 * @param start Physical Address of the first frame to be freed. 972 * @param count Number of frames to free. 1145 973 * @param flags Flags to control memory reservation. 1146 974 * 1147 975 */ 1148 void frame_free_generic(uintptr_t frame, frame_flags_t flags)1149 { 1150 size_t size;976 void frame_free_generic(uintptr_t start, size_t count, frame_flags_t flags) 977 { 978 size_t freed = 0; 1151 979 1152 980 irq_spinlock_lock(&zones.lock, true); 1153 981 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); 982 for (size_t i = 0; i < count; i++) { 983 /* 984 * First, find host frame zone for addr. 985 */ 986 pfn_t pfn = ADDR2PFN(start) + i; 987 size_t znum = find_zone(pfn, 1, 0); 988 989 ASSERT(znum != (size_t) -1); 990 991 freed += zone_frame_free(&zones.info[znum], 992 pfn - zones.info[znum].base); 993 } 1163 994 1164 995 irq_spinlock_unlock(&zones.lock, true); … … 1166 997 /* 1167 998 * Signal that some memory has been freed. 999 * Since the mem_avail_mtx is an active mutex, 1000 * we need to disable interruptsto prevent deadlock 1001 * with TLB shootdown. 1168 1002 */ 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 */ 1003 1175 1004 ipl_t ipl = interrupts_disable(); 1176 1005 mutex_lock(&mem_avail_mtx); 1006 1177 1007 if (mem_avail_req > 0) 1178 mem_avail_req -= min(mem_avail_req, size);1008 mem_avail_req -= min(mem_avail_req, freed); 1179 1009 1180 1010 if (mem_avail_req == 0) { … … 1182 1012 condvar_broadcast(&mem_avail_cv); 1183 1013 } 1014 1184 1015 mutex_unlock(&mem_avail_mtx); 1185 1016 interrupts_restore(ipl); 1186 1017 1187 1018 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);1019 reserve_free(freed); 1020 } 1021 1022 void frame_free(uintptr_t frame, size_t count) 1023 { 1024 frame_free_generic(frame, count, 0); 1025 } 1026 1027 void frame_free_noreserve(uintptr_t frame, size_t count) 1028 { 1029 frame_free_generic(frame, count, FRAME_NO_RESERVE); 1199 1030 } 1200 1031 … … 1230 1061 irq_spinlock_lock(&zones.lock, true); 1231 1062 1232 size_t i; 1233 for (i = 0; i < count; i++) { 1063 for (size_t i = 0; i < count; i++) { 1234 1064 size_t znum = find_zone(start + i, 1, 0); 1065 1235 1066 if (znum == (size_t) -1) /* PFN not found */ 1236 1067 continue; … … 1257 1088 /* Tell the architecture to create some memory */ 1258 1089 frame_low_arch_init(); 1090 1259 1091 if (config.cpu_active == 1) { 1260 1092 frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)), … … 1263 1095 SIZE2FRAMES(config.stack_size)); 1264 1096 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, 1097 for (size_t i = 0; i < init.cnt; i++) 1098 frame_mark_unavailable(ADDR2PFN(init.tasks[i].paddr), 1269 1099 SIZE2FRAMES(init.tasks[i].size)); 1270 }1271 1100 1272 1101 if (ballocs.size) … … 1274 1103 SIZE2FRAMES(ballocs.size)); 1275 1104 1276 /* Black list first frame, as allocating NULL would 1105 /* 1106 * Blacklist first frame, as allocating NULL would 1277 1107 * fail in some places 1278 1108 */ 1279 1109 frame_mark_unavailable(0, 1); 1280 1110 } 1111 1281 1112 frame_high_arch_init(); 1282 1113 } … … 1284 1115 /** Adjust bounds of physical memory region according to low/high memory split. 1285 1116 * 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. 1117 * @param low[in] If true, the adjustment is performed to make the region 1118 * fit in the low memory. Otherwise the adjustment is 1119 * performed to make the region fit in the high memory. 1120 * @param basep[inout] Pointer to a variable which contains the region's base 1121 * address and which may receive the adjusted base address. 1122 * @param sizep[inout] Pointer to a variable which contains the region's size 1123 * and which may receive the adjusted size. 1124 * 1125 * @return True if the region still exists even after the adjustment. 1126 * @return False otherwise. 1127 * 1295 1128 */ 1296 1129 bool frame_adjust_zone_bounds(bool low, uintptr_t *basep, size_t *sizep) 1297 1130 { 1298 1131 uintptr_t limit = KA2PA(config.identity_base) + config.identity_size; 1299 1132 1300 1133 if (low) { 1301 1134 if (*basep > limit) 1302 1135 return false; 1136 1303 1137 if (*basep + *sizep > limit) 1304 1138 *sizep = limit - *basep; … … 1306 1140 if (*basep + *sizep <= limit) 1307 1141 return false; 1142 1308 1143 if (*basep <= limit) { 1309 1144 *sizep -= limit - *basep; … … 1311 1146 } 1312 1147 } 1148 1313 1149 return true; 1314 1150 } … … 1322 1158 1323 1159 uint64_t total = 0; 1324 size_t i;1325 for ( i = 0; i < zones.count; i++)1160 1161 for (size_t i = 0; i < zones.count; i++) 1326 1162 total += (uint64_t) FRAMES2SIZE(zones.info[i].count); 1327 1163 … … 1346 1182 *free = 0; 1347 1183 1348 size_t i; 1349 for (i = 0; i < zones.count; i++) { 1184 for (size_t i = 0; i < zones.count; i++) { 1350 1185 *total += (uint64_t) FRAMES2SIZE(zones.info[i].count); 1351 1186 … … 1375 1210 /* 1376 1211 * Because printing may require allocation of memory, we may not hold 1377 * the frame allocator locks when printing zone statistics. 1212 * the frame allocator locks when printing zone statistics. Therefore, 1378 1213 * we simply gather the statistics under the protection of the locks and 1379 1214 * print the statistics when the locks have been released. … … 1384 1219 */ 1385 1220 1386 size_t i; 1387 for (i = 0;; i++) { 1221 size_t free_lowmem = 0; 1222 size_t free_highmem = 0; 1223 size_t free_highprio = 0; 1224 1225 for (size_t i = 0;; i++) { 1388 1226 irq_spinlock_lock(&zones.lock, true); 1389 1227 … … 1393 1231 } 1394 1232 1395 uintptr_t base = PFN2ADDR(zones.info[i].base); 1233 pfn_t fbase = zones.info[i].base; 1234 uintptr_t base = PFN2ADDR(fbase); 1396 1235 size_t count = zones.info[i].count; 1397 1236 zone_flags_t flags = zones.info[i].flags; … … 1399 1238 size_t busy_count = zones.info[i].busy_count; 1400 1239 1240 bool available = ((flags & ZONE_AVAILABLE) != 0); 1241 bool lowmem = ((flags & ZONE_LOWMEM) != 0); 1242 bool highmem = ((flags & ZONE_HIGHMEM) != 0); 1243 bool highprio = is_high_priority(fbase, count); 1244 1245 if (available) { 1246 if (lowmem) 1247 free_lowmem += free_count; 1248 1249 if (highmem) 1250 free_highmem += free_count; 1251 1252 if (highprio) { 1253 free_highprio += free_count; 1254 } else { 1255 /* 1256 * Walk all frames of the zone and examine 1257 * all high priority memory to get accurate 1258 * statistics. 1259 */ 1260 1261 for (size_t index = 0; index < count; index++) { 1262 if (is_high_priority(fbase + index, 0)) { 1263 if (!bitmap_get(&zones.info[i].bitmap, index)) 1264 free_highprio++; 1265 } else 1266 break; 1267 } 1268 } 1269 } 1270 1401 1271 irq_spinlock_unlock(&zones.lock, true); 1402 1403 bool available = ((flags & ZONE_AVAILABLE) != 0);1404 1272 1405 1273 printf("%-4zu", i); … … 1426 1294 printf("\n"); 1427 1295 } 1296 1297 printf("\n"); 1298 1299 uint64_t size; 1300 const char *size_suffix; 1301 1302 bin_order_suffix(FRAMES2SIZE(free_lowmem), &size, &size_suffix, 1303 false); 1304 printf("Available low memory: %zu frames (%" PRIu64 " %s)\n", 1305 free_lowmem, size, size_suffix); 1306 1307 bin_order_suffix(FRAMES2SIZE(free_highmem), &size, &size_suffix, 1308 false); 1309 printf("Available high memory: %zu frames (%" PRIu64 " %s)\n", 1310 free_highmem, size, size_suffix); 1311 1312 bin_order_suffix(FRAMES2SIZE(free_highprio), &size, &size_suffix, 1313 false); 1314 printf("Available high priority: %zu frames (%" PRIu64 " %s)\n", 1315 free_highprio, size, size_suffix); 1428 1316 } 1429 1317 … … 1438 1326 size_t znum = (size_t) -1; 1439 1327 1440 size_t i; 1441 for (i = 0; i < zones.count; i++) { 1328 for (size_t i = 0; i < zones.count; i++) { 1442 1329 if ((i == num) || (PFN2ADDR(zones.info[i].base) == num)) { 1443 1330 znum = i; … … 1452 1339 } 1453 1340 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; 1341 size_t free_lowmem = 0; 1342 size_t free_highmem = 0; 1343 size_t free_highprio = 0; 1344 1345 pfn_t fbase = zones.info[znum].base; 1346 uintptr_t base = PFN2ADDR(fbase); 1347 zone_flags_t flags = zones.info[znum].flags; 1348 size_t count = zones.info[znum].count; 1349 size_t free_count = zones.info[znum].free_count; 1350 size_t busy_count = zones.info[znum].busy_count; 1351 1352 bool available = ((flags & ZONE_AVAILABLE) != 0); 1353 bool lowmem = ((flags & ZONE_LOWMEM) != 0); 1354 bool highmem = ((flags & ZONE_HIGHMEM) != 0); 1355 bool highprio = is_high_priority(fbase, count); 1356 1357 if (available) { 1358 if (lowmem) 1359 free_lowmem = free_count; 1360 1361 if (highmem) 1362 free_highmem = free_count; 1363 1364 if (highprio) { 1365 free_highprio = free_count; 1366 } else { 1367 /* 1368 * Walk all frames of the zone and examine 1369 * all high priority memory to get accurate 1370 * statistics. 1371 */ 1372 1373 for (size_t index = 0; index < count; index++) { 1374 if (is_high_priority(fbase + index, 0)) { 1375 if (!bitmap_get(&zones.info[znum].bitmap, index)) 1376 free_highprio++; 1377 } else 1378 break; 1379 } 1380 } 1381 } 1459 1382 1460 1383 irq_spinlock_unlock(&zones.lock, true); 1461 1462 bool available = ((flags & ZONE_AVAILABLE) != 0);1463 1384 1464 1385 uint64_t size; 1465 1386 const char *size_suffix; 1387 1466 1388 bin_order_suffix(FRAMES2SIZE(count), &size, &size_suffix, false); 1467 1389 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,1390 printf("Zone number: %zu\n", znum); 1391 printf("Zone base address: %p\n", (void *) base); 1392 printf("Zone size: %zu frames (%" PRIu64 " %s)\n", count, 1471 1393 size, size_suffix); 1472 printf("Zone flags: %c%c%c%c%c\n",1394 printf("Zone flags: %c%c%c%c%c\n", 1473 1395 available ? 'A' : '-', 1474 1396 (flags & ZONE_RESERVED) ? 'R' : '-', … … 1480 1402 bin_order_suffix(FRAMES2SIZE(busy_count), &size, &size_suffix, 1481 1403 false); 1482 printf("Allocated space: %zu frames (%" PRIu64 " %s)\n",1404 printf("Allocated space: %zu frames (%" PRIu64 " %s)\n", 1483 1405 busy_count, size, size_suffix); 1406 1484 1407 bin_order_suffix(FRAMES2SIZE(free_count), &size, &size_suffix, 1485 1408 false); 1486 printf("Available space: %zu frames (%" PRIu64 " %s)\n",1409 printf("Available space: %zu frames (%" PRIu64 " %s)\n", 1487 1410 free_count, size, size_suffix); 1411 1412 bin_order_suffix(FRAMES2SIZE(free_lowmem), &size, &size_suffix, 1413 false); 1414 printf("Available low memory: %zu frames (%" PRIu64 " %s)\n", 1415 free_lowmem, size, size_suffix); 1416 1417 bin_order_suffix(FRAMES2SIZE(free_highmem), &size, &size_suffix, 1418 false); 1419 printf("Available high memory: %zu frames (%" PRIu64 " %s)\n", 1420 free_highmem, size, size_suffix); 1421 1422 bin_order_suffix(FRAMES2SIZE(free_highprio), &size, &size_suffix, 1423 false); 1424 printf("Available high priority: %zu frames (%" PRIu64 " %s)\n", 1425 free_highprio, size, size_suffix); 1488 1426 } 1489 1427 }
Note:
See TracChangeset
for help on using the changeset viewer.
