Changeset 8f88beb in mainline for kernel/generic/src/mm/as.c
- Timestamp:
- 2012-11-25T21:34:07Z (12 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- e1a27be
- Parents:
- 150a271 (diff), 7462674 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)links above to see all the changes relative to each parent. - File:
-
- 1 edited
-
kernel/generic/src/mm/as.c (modified) (21 diffs)
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/mm/as.c
r150a271 r8f88beb 79 79 #include <syscall/copy.h> 80 80 #include <arch/interrupt.h> 81 #include <interrupt.h> 81 82 82 83 /** … … 285 286 /** Check area conflicts with other areas. 286 287 * 287 * @param as Address space. 288 * @param addr Starting virtual address of the area being tested. 289 * @param count Number of pages in the area being tested. 290 * @param avoid Do not touch this area. 288 * @param as Address space. 289 * @param addr Starting virtual address of the area being tested. 290 * @param count Number of pages in the area being tested. 291 * @param guarded True if the area being tested is protected by guard pages. 292 * @param avoid Do not touch this area. 291 293 * 292 294 * @return True if there is no conflict, false otherwise. … … 294 296 */ 295 297 NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t addr, 296 size_t count, as_area_t *avoid)298 size_t count, bool guarded, as_area_t *avoid) 297 299 { 298 300 ASSERT((addr % PAGE_SIZE) == 0); 299 301 ASSERT(mutex_locked(&as->lock)); 302 303 /* 304 * If the addition of the supposed area address and size overflows, 305 * report conflict. 306 */ 307 if (overflows_into_positive(addr, P2SZ(count))) 308 return false; 300 309 301 310 /* … … 304 313 if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE)) 305 314 return false; 306 315 307 316 /* 308 317 * The leaf node is found in O(log n), where n is proportional to … … 328 337 if (area != avoid) { 329 338 mutex_lock(&area->lock); 330 339 340 /* 341 * If at least one of the two areas are protected 342 * by the AS_AREA_GUARD flag then we must be sure 343 * that they are separated by at least one unmapped 344 * page. 345 */ 346 int const gp = (guarded || 347 (area->flags & AS_AREA_GUARD)) ? 1 : 0; 348 349 /* 350 * The area comes from the left neighbour node, which 351 * means that there already are some areas in the leaf 352 * node, which in turn means that adding gp is safe and 353 * will not cause an integer overflow. 354 */ 331 355 if (overlaps(addr, P2SZ(count), area->base, 356 P2SZ(area->pages + gp))) { 357 mutex_unlock(&area->lock); 358 return false; 359 } 360 361 mutex_unlock(&area->lock); 362 } 363 } 364 365 node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf); 366 if (node) { 367 area = (as_area_t *) node->value[0]; 368 369 if (area != avoid) { 370 int gp; 371 372 mutex_lock(&area->lock); 373 374 gp = (guarded || (area->flags & AS_AREA_GUARD)) ? 1 : 0; 375 if (gp && overflows(addr, P2SZ(count))) { 376 /* 377 * Guard page not needed if the supposed area 378 * is adjacent to the end of the address space. 379 * We already know that the following test is 380 * going to fail... 381 */ 382 gp--; 383 } 384 385 if (overlaps(addr, P2SZ(count + gp), area->base, 332 386 P2SZ(area->pages))) { 333 387 mutex_unlock(&area->lock); … … 339 393 } 340 394 341 node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf);342 if (node) {343 area = (as_area_t *) node->value[0];344 345 if (area != avoid) {346 mutex_lock(&area->lock);347 348 if (overlaps(addr, P2SZ(count), area->base,349 P2SZ(area->pages))) {350 mutex_unlock(&area->lock);351 return false;352 }353 354 mutex_unlock(&area->lock);355 }356 }357 358 395 /* Second, check the leaf node. */ 359 396 btree_key_t i; 360 397 for (i = 0; i < leaf->keys; i++) { 361 398 area = (as_area_t *) leaf->value[i]; 399 int agp; 400 int gp; 362 401 363 402 if (area == avoid) … … 365 404 366 405 mutex_lock(&area->lock); 367 368 if (overlaps(addr, P2SZ(count), area->base, 369 P2SZ(area->pages))) { 406 407 gp = (guarded || (area->flags & AS_AREA_GUARD)) ? 1 : 0; 408 agp = gp; 409 410 /* 411 * Sanitize the two possible unsigned integer overflows. 412 */ 413 if (gp && overflows(addr, P2SZ(count))) 414 gp--; 415 if (agp && overflows(area->base, P2SZ(area->pages))) 416 agp--; 417 418 if (overlaps(addr, P2SZ(count + gp), area->base, 419 P2SZ(area->pages + agp))) { 370 420 mutex_unlock(&area->lock); 371 421 return false; … … 377 427 /* 378 428 * So far, the area does not conflict with other areas. 379 * Check if it doesn't conflict with kerneladdress space.429 * Check if it is contained in the user address space. 380 430 */ 381 431 if (!KERNEL_ADDRESS_SPACE_SHADOWED) { 382 return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START, 383 KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START); 432 return iswithin(USER_ADDRESS_SPACE_START, 433 (USER_ADDRESS_SPACE_END - USER_ADDRESS_SPACE_START) + 1, 434 addr, P2SZ(count)); 384 435 } 385 436 … … 392 443 * this function. 393 444 * 394 * @param as Address space. 395 * @param bound Lowest address bound. 396 * @param size Requested size of the allocation. 445 * @param as Address space. 446 * @param bound Lowest address bound. 447 * @param size Requested size of the allocation. 448 * @param guarded True if the allocation must be protected by guard pages. 397 449 * 398 450 * @return Address of the beginning of unmapped address space area. … … 401 453 */ 402 454 NO_TRACE static uintptr_t as_get_unmapped_area(as_t *as, uintptr_t bound, 403 size_t size )455 size_t size, bool guarded) 404 456 { 405 457 ASSERT(mutex_locked(&as->lock)); … … 423 475 /* First check the bound address itself */ 424 476 uintptr_t addr = ALIGN_UP(bound, PAGE_SIZE); 425 if ((addr >= bound) && 426 (check_area_conflicts(as, addr, pages, NULL))) 427 return addr; 477 if (addr >= bound) { 478 if (guarded) { 479 /* Leave an unmapped page between the lower 480 * bound and the area's start address. 481 */ 482 addr += P2SZ(1); 483 } 484 485 if (check_area_conflicts(as, addr, pages, guarded, NULL)) 486 return addr; 487 } 428 488 429 489 /* Eventually check the addresses behind each area */ … … 439 499 addr = 440 500 ALIGN_UP(area->base + P2SZ(area->pages), PAGE_SIZE); 501 502 if (guarded || area->flags & AS_AREA_GUARD) { 503 /* We must leave an unmapped page 504 * between the two areas. 505 */ 506 addr += P2SZ(1); 507 } 508 441 509 bool avail = 442 510 ((addr >= bound) && (addr >= area->base) && 443 (check_area_conflicts(as, addr, pages, area)));511 (check_area_conflicts(as, addr, pages, guarded, area))); 444 512 445 513 mutex_unlock(&area->lock); … … 481 549 if (size == 0) 482 550 return NULL; 483 551 484 552 size_t pages = SIZE2FRAMES(size); 485 553 … … 487 555 if ((flags & AS_AREA_EXEC) && (flags & AS_AREA_WRITE)) 488 556 return NULL; 557 558 bool const guarded = flags & AS_AREA_GUARD; 489 559 490 560 mutex_lock(&as->lock); 491 561 492 562 if (*base == (uintptr_t) -1) { 493 *base = as_get_unmapped_area(as, bound, size );563 *base = as_get_unmapped_area(as, bound, size, guarded); 494 564 if (*base == (uintptr_t) -1) { 495 565 mutex_unlock(&as->lock); … … 497 567 } 498 568 } 499 500 if (!check_area_conflicts(as, *base, pages, NULL)) { 569 570 if (overflows_into_positive(*base, size)) 571 return NULL; 572 573 if (!check_area_conflicts(as, *base, pages, guarded, NULL)) { 501 574 mutex_unlock(&as->lock); 502 575 return NULL; … … 625 698 return ENOENT; 626 699 } 627 628 if (area->backend == &phys_backend) { 629 /* 630 * Remapping of address space areas associated 631 * with memory mapped devices is not supported. 700 701 if (!area->backend->is_resizable(area)) { 702 /* 703 * The backend does not support resizing for this area. 632 704 */ 633 705 mutex_unlock(&area->lock); … … 776 848 /* 777 849 * Growing the area. 850 */ 851 852 if (overflows_into_positive(address, P2SZ(pages))) 853 return EINVAL; 854 855 /* 778 856 * Check for overlaps with other address space areas. 779 857 */ 780 if (!check_area_conflicts(as, address, pages, area)) { 858 bool const guarded = area->flags & AS_AREA_GUARD; 859 if (!check_area_conflicts(as, address, pages, guarded, area)) { 781 860 mutex_unlock(&area->lock); 782 861 mutex_unlock(&as->lock); … … 979 1058 } 980 1059 981 if ((!src_area->backend) || (!src_area->backend->share)) { 982 /* 983 * There is no backend or the backend does not 984 * know how to share the area. 1060 if (!src_area->backend->is_shareable(src_area)) { 1061 /* 1062 * The backend does not permit sharing of this area. 985 1063 */ 986 1064 mutex_unlock(&src_area->lock); … … 1285 1363 int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate) 1286 1364 { 1365 int rc = AS_PF_FAULT; 1366 1287 1367 if (!THREAD) 1288 return AS_PF_FAULT;1368 goto page_fault; 1289 1369 1290 1370 if (!AS) 1291 return AS_PF_FAULT;1371 goto page_fault; 1292 1372 1293 1373 mutex_lock(&AS->lock); … … 1345 1425 * Resort to the backend page fault handler. 1346 1426 */ 1347 if (area->backend->page_fault(area, page, access) != AS_PF_OK) { 1427 rc = area->backend->page_fault(area, page, access); 1428 if (rc != AS_PF_OK) { 1348 1429 page_table_unlock(AS, false); 1349 1430 mutex_unlock(&area->lock); … … 1366 1447 istate_set_retaddr(istate, 1367 1448 (uintptr_t) &memcpy_to_uspace_failover_address); 1449 } else if (rc == AS_PF_SILENT) { 1450 printf("Killing task %" PRIu64 " due to a " 1451 "failed late reservation request.\n", TASK->taskid); 1452 task_kill_self(true); 1368 1453 } else { 1369 return AS_PF_FAULT; 1454 fault_if_from_uspace(istate, "Page fault: %p.", (void *) page); 1455 panic_memtrap(istate, access, page, NULL); 1370 1456 } 1371 1457
Note:
See TracChangeset
for help on using the changeset viewer.
