Changes in kernel/generic/src/mm/as.c [fc47885:30718cc2] in mainline
- File:
-
- 1 edited
-
kernel/generic/src/mm/as.c (modified) (54 diffs)
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/mm/as.c
rfc47885 r30718cc2 71 71 #include <memstr.h> 72 72 #include <macros.h> 73 #include <bitops.h> 73 74 #include <arch.h> 74 75 #include <errno.h> … … 288 289 /** Check area conflicts with other areas. 289 290 * 290 * @param as 291 * @param vaStarting virtual address of the area being tested.292 * @param size Size ofthe area being tested.293 * @param avoid _areaDo not touch this area.291 * @param as Address space. 292 * @param addr Starting virtual address of the area being tested. 293 * @param count Number of pages in the area being tested. 294 * @param avoid Do not touch this area. 294 295 * 295 296 * @return True if there is no conflict, false otherwise. 296 297 * 297 298 */ 298 NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size, 299 as_area_t *avoid_area) 300 { 299 NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t addr, 300 size_t count, as_area_t *avoid) 301 { 302 ASSERT((addr % PAGE_SIZE) == 0); 301 303 ASSERT(mutex_locked(&as->lock)); 302 304 … … 304 306 * We don't want any area to have conflicts with NULL page. 305 307 */ 306 if (overlaps( va, size, (uintptr_t) NULL, PAGE_SIZE))308 if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE)) 307 309 return false; 308 310 … … 316 318 btree_node_t *leaf; 317 319 as_area_t *area = 318 (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);320 (as_area_t *) btree_search(&as->as_area_btree, addr, &leaf); 319 321 if (area) { 320 if (area != avoid _area)322 if (area != avoid) 321 323 return false; 322 324 } … … 328 330 area = (as_area_t *) node->value[node->keys - 1]; 329 331 330 mutex_lock(&area->lock); 331 332 if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) { 332 if (area != avoid) { 333 mutex_lock(&area->lock); 334 335 if (overlaps(addr, count << PAGE_WIDTH, 336 area->base, area->pages << PAGE_WIDTH)) { 337 mutex_unlock(&area->lock); 338 return false; 339 } 340 333 341 mutex_unlock(&area->lock); 334 return false; 335 } 336 337 mutex_unlock(&area->lock); 342 } 338 343 } 339 344 … … 342 347 area = (as_area_t *) node->value[0]; 343 348 344 mutex_lock(&area->lock); 345 346 if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) { 349 if (area != avoid) { 350 mutex_lock(&area->lock); 351 352 if (overlaps(addr, count << PAGE_WIDTH, 353 area->base, area->pages << PAGE_WIDTH)) { 354 mutex_unlock(&area->lock); 355 return false; 356 } 357 347 358 mutex_unlock(&area->lock); 348 return false; 349 } 350 351 mutex_unlock(&area->lock); 359 } 352 360 } 353 361 … … 357 365 area = (as_area_t *) leaf->value[i]; 358 366 359 if (area == avoid _area)367 if (area == avoid) 360 368 continue; 361 369 362 370 mutex_lock(&area->lock); 363 371 364 if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) { 372 if (overlaps(addr, count << PAGE_WIDTH, 373 area->base, area->pages << PAGE_WIDTH)) { 365 374 mutex_unlock(&area->lock); 366 375 return false; … … 375 384 */ 376 385 if (!KERNEL_ADDRESS_SPACE_SHADOWED) { 377 return !overlaps( va, size,386 return !overlaps(addr, count << PAGE_WIDTH, 378 387 KERNEL_ADDRESS_SPACE_START, 379 388 KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START); … … 402 411 mem_backend_data_t *backend_data) 403 412 { 404 if ( base % PAGE_SIZE)413 if ((base % PAGE_SIZE) != 0) 405 414 return NULL; 406 415 407 if ( !size)416 if (size == 0) 408 417 return NULL; 418 419 size_t pages = SIZE2FRAMES(size); 409 420 410 421 /* Writeable executable areas are not supported. */ … … 414 425 mutex_lock(&as->lock); 415 426 416 if (!check_area_conflicts(as, base, size, NULL)) {427 if (!check_area_conflicts(as, base, pages, NULL)) { 417 428 mutex_unlock(&as->lock); 418 429 return NULL; … … 426 437 area->flags = flags; 427 438 area->attributes = attrs; 428 area->pages = SIZE2FRAMES(size);439 area->pages = pages; 429 440 area->resident = 0; 430 441 area->base = base; … … 480 491 mutex_lock(&area->lock); 481 492 482 if ((area->base <= va) && (va < area->base + area->pages * PAGE_SIZE)) 493 if ((area->base <= va) && 494 (va < area->base + (area->pages << PAGE_WIDTH))) 483 495 return area; 484 496 … … 496 508 mutex_lock(&area->lock); 497 509 498 if (va < area->base + area->pages * PAGE_SIZE)510 if (va < area->base + (area->pages << PAGE_WIDTH)) 499 511 return area; 500 512 … … 561 573 562 574 if (pages < area->pages) { 563 uintptr_t start_free = area->base + pages * PAGE_SIZE;575 uintptr_t start_free = area->base + (pages << PAGE_WIDTH); 564 576 565 577 /* … … 574 586 */ 575 587 ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid, 576 area->base + pages * PAGE_SIZE, area->pages - pages);588 area->base + (pages << PAGE_WIDTH), area->pages - pages); 577 589 578 590 /* … … 597 609 size_t i = 0; 598 610 599 if (overlaps(ptr, size * PAGE_SIZE, area->base,600 pages * PAGE_SIZE)) {611 if (overlaps(ptr, size << PAGE_WIDTH, area->base, 612 pages << PAGE_WIDTH)) { 601 613 602 if (ptr + size * PAGE_SIZE<= start_free) {614 if (ptr + (size << PAGE_WIDTH) <= start_free) { 603 615 /* 604 616 * The whole interval fits … … 632 644 for (; i < size; i++) { 633 645 pte_t *pte = page_mapping_find(as, ptr + 634 i * PAGE_SIZE);646 (i << PAGE_WIDTH)); 635 647 636 648 ASSERT(pte); … … 641 653 (area->backend->frame_free)) { 642 654 area->backend->frame_free(area, 643 ptr + i * PAGE_SIZE,655 ptr + (i << PAGE_WIDTH), 644 656 PTE_GET_FRAME(pte)); 645 657 } 646 658 647 659 page_mapping_remove(as, ptr + 648 i * PAGE_SIZE);660 (i << PAGE_WIDTH)); 649 661 } 650 662 } … … 655 667 */ 656 668 657 tlb_invalidate_pages(as->asid, area->base + pages * PAGE_SIZE,669 tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH), 658 670 area->pages - pages); 659 671 … … 662 674 */ 663 675 as_invalidate_translation_cache(as, area->base + 664 pages * PAGE_SIZE, area->pages - pages);676 (pages << PAGE_WIDTH), area->pages - pages); 665 677 tlb_shootdown_finalize(ipl); 666 678 … … 671 683 * Check for overlaps with other address space areas. 672 684 */ 673 if (!check_area_conflicts(as, address, pages * PAGE_SIZE, 674 area)) { 685 if (!check_area_conflicts(as, address, pages, area)) { 675 686 mutex_unlock(&area->lock); 676 687 mutex_unlock(&as->lock); … … 771 782 772 783 for (size = 0; size < (size_t) node->value[i]; size++) { 773 pte_t *pte = page_mapping_find(as, ptr + size * PAGE_SIZE); 784 pte_t *pte = 785 page_mapping_find(as, ptr + (size << PAGE_WIDTH)); 774 786 775 787 ASSERT(pte); … … 780 792 (area->backend->frame_free)) { 781 793 area->backend->frame_free(area, 782 ptr + size * PAGE_SIZE, PTE_GET_FRAME(pte));794 ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte)); 783 795 } 784 796 785 page_mapping_remove(as, ptr + size * PAGE_SIZE);797 page_mapping_remove(as, ptr + (size << PAGE_WIDTH)); 786 798 } 787 799 } … … 870 882 } 871 883 872 size_t src_size = src_area->pages * PAGE_SIZE;884 size_t src_size = src_area->pages << PAGE_WIDTH; 873 885 unsigned int src_flags = src_area->flags; 874 886 mem_backend_t *src_backend = src_area->backend; … … 1076 1088 1077 1089 for (size = 0; size < (size_t) node->value[i]; size++) { 1078 pte_t *pte = page_mapping_find(as, ptr + size * PAGE_SIZE); 1090 pte_t *pte = 1091 page_mapping_find(as, ptr + (size << PAGE_WIDTH)); 1079 1092 1080 1093 ASSERT(pte); … … 1085 1098 1086 1099 /* Remove old mapping */ 1087 page_mapping_remove(as, ptr + size * PAGE_SIZE);1100 page_mapping_remove(as, ptr + (size << PAGE_WIDTH)); 1088 1101 } 1089 1102 } … … 1131 1144 1132 1145 /* Insert the new mapping */ 1133 page_mapping_insert(as, ptr + size * PAGE_SIZE,1146 page_mapping_insert(as, ptr + (size << PAGE_WIDTH), 1134 1147 old_frame[frame_idx++], page_flags); 1135 1148 … … 1453 1466 1454 1467 if (src_area) { 1455 size = src_area->pages * PAGE_SIZE;1468 size = src_area->pages << PAGE_WIDTH; 1456 1469 mutex_unlock(&src_area->lock); 1457 1470 } else … … 1508 1521 if (page >= right_pg) { 1509 1522 /* Do nothing. */ 1510 } else if (overlaps(page, count * PAGE_SIZE, left_pg,1511 left_cnt * PAGE_SIZE)) {1523 } else if (overlaps(page, count << PAGE_WIDTH, left_pg, 1524 left_cnt << PAGE_WIDTH)) { 1512 1525 /* The interval intersects with the left interval. */ 1513 1526 return false; 1514 } else if (overlaps(page, count * PAGE_SIZE, right_pg,1515 right_cnt * PAGE_SIZE)) {1527 } else if (overlaps(page, count << PAGE_WIDTH, right_pg, 1528 right_cnt << PAGE_WIDTH)) { 1516 1529 /* The interval intersects with the right interval. */ 1517 1530 return false; 1518 } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&1519 (page + count * PAGE_SIZE== right_pg)) {1531 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) && 1532 (page + (count << PAGE_WIDTH) == right_pg)) { 1520 1533 /* 1521 1534 * The interval can be added by merging the two already … … 1525 1538 btree_remove(&area->used_space, right_pg, leaf); 1526 1539 goto success; 1527 } else if (page == left_pg + left_cnt * PAGE_SIZE) {1540 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) { 1528 1541 /* 1529 1542 * The interval can be added by simply growing the left … … 1532 1545 node->value[node->keys - 1] += count; 1533 1546 goto success; 1534 } else if (page + count * PAGE_SIZE== right_pg) {1547 } else if (page + (count << PAGE_WIDTH) == right_pg) { 1535 1548 /* 1536 1549 * The interval can be addded by simply moving base of … … 1559 1572 */ 1560 1573 1561 if (overlaps(page, count * PAGE_SIZE, right_pg,1562 right_cnt * PAGE_SIZE)) {1574 if (overlaps(page, count << PAGE_WIDTH, right_pg, 1575 right_cnt << PAGE_WIDTH)) { 1563 1576 /* The interval intersects with the right interval. */ 1564 1577 return false; 1565 } else if (page + count * PAGE_SIZE== right_pg) {1578 } else if (page + (count << PAGE_WIDTH) == right_pg) { 1566 1579 /* 1567 1580 * The interval can be added by moving the base of the … … 1598 1611 if (page < left_pg) { 1599 1612 /* Do nothing. */ 1600 } else if (overlaps(page, count * PAGE_SIZE, left_pg,1601 left_cnt * PAGE_SIZE)) {1613 } else if (overlaps(page, count << PAGE_WIDTH, left_pg, 1614 left_cnt << PAGE_WIDTH)) { 1602 1615 /* The interval intersects with the left interval. */ 1603 1616 return false; 1604 } else if (overlaps(page, count * PAGE_SIZE, right_pg,1605 right_cnt * PAGE_SIZE)) {1617 } else if (overlaps(page, count << PAGE_WIDTH, right_pg, 1618 right_cnt << PAGE_WIDTH)) { 1606 1619 /* The interval intersects with the right interval. */ 1607 1620 return false; 1608 } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&1609 (page + count * PAGE_SIZE== right_pg)) {1621 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) && 1622 (page + (count << PAGE_WIDTH) == right_pg)) { 1610 1623 /* 1611 1624 * The interval can be added by merging the two already … … 1615 1628 btree_remove(&area->used_space, right_pg, node); 1616 1629 goto success; 1617 } else if (page == left_pg + left_cnt * PAGE_SIZE) {1630 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) { 1618 1631 /* 1619 1632 * The interval can be added by simply growing the left … … 1622 1635 leaf->value[leaf->keys - 1] += count; 1623 1636 goto success; 1624 } else if (page + count * PAGE_SIZE== right_pg) {1637 } else if (page + (count << PAGE_WIDTH) == right_pg) { 1625 1638 /* 1626 1639 * The interval can be addded by simply moving base of … … 1649 1662 */ 1650 1663 1651 if (overlaps(page, count * PAGE_SIZE, left_pg,1652 left_cnt * PAGE_SIZE)) {1664 if (overlaps(page, count << PAGE_WIDTH, left_pg, 1665 left_cnt << PAGE_WIDTH)) { 1653 1666 /* The interval intersects with the left interval. */ 1654 1667 return false; 1655 } else if (left_pg + left_cnt * PAGE_SIZE== page) {1668 } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) { 1656 1669 /* 1657 1670 * The interval can be added by growing the left … … 1688 1701 */ 1689 1702 1690 if (overlaps(page, count * PAGE_SIZE, left_pg,1691 left_cnt * PAGE_SIZE)) {1703 if (overlaps(page, count << PAGE_WIDTH, left_pg, 1704 left_cnt << PAGE_WIDTH)) { 1692 1705 /* 1693 1706 * The interval intersects with the left … … 1695 1708 */ 1696 1709 return false; 1697 } else if (overlaps(page, count * PAGE_SIZE, right_pg,1698 right_cnt * PAGE_SIZE)) {1710 } else if (overlaps(page, count << PAGE_WIDTH, right_pg, 1711 right_cnt << PAGE_WIDTH)) { 1699 1712 /* 1700 1713 * The interval intersects with the right … … 1702 1715 */ 1703 1716 return false; 1704 } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&1705 (page + count * PAGE_SIZE== right_pg)) {1717 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) && 1718 (page + (count << PAGE_WIDTH) == right_pg)) { 1706 1719 /* 1707 1720 * The interval can be added by merging the two … … 1711 1724 btree_remove(&area->used_space, right_pg, leaf); 1712 1725 goto success; 1713 } else if (page == left_pg + left_cnt * PAGE_SIZE) {1726 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) { 1714 1727 /* 1715 1728 * The interval can be added by simply growing … … 1718 1731 leaf->value[i - 1] += count; 1719 1732 goto success; 1720 } else if (page + count * PAGE_SIZE== right_pg) {1733 } else if (page + (count << PAGE_WIDTH) == right_pg) { 1721 1734 /* 1722 1735 * The interval can be addded by simply moving … … 1784 1797 for (i = 0; i < leaf->keys; i++) { 1785 1798 if (leaf->key[i] == page) { 1786 leaf->key[i] += count * PAGE_SIZE;1799 leaf->key[i] += count << PAGE_WIDTH; 1787 1800 leaf->value[i] -= count; 1788 1801 goto success; … … 1799 1812 size_t left_cnt = (size_t) node->value[node->keys - 1]; 1800 1813 1801 if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,1802 count * PAGE_SIZE)) {1803 if (page + count * PAGE_SIZE==1804 left_pg + left_cnt * PAGE_SIZE) {1814 if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page, 1815 count << PAGE_WIDTH)) { 1816 if (page + (count << PAGE_WIDTH) == 1817 left_pg + (left_cnt << PAGE_WIDTH)) { 1805 1818 /* 1806 1819 * The interval is contained in the rightmost … … 1811 1824 node->value[node->keys - 1] -= count; 1812 1825 goto success; 1813 } else if (page + count * PAGE_SIZE<1814 left_pg + left_cnt*PAGE_SIZE) {1826 } else if (page + (count << PAGE_WIDTH) < 1827 left_pg + (left_cnt << PAGE_WIDTH)) { 1815 1828 /* 1816 1829 * The interval is contained in the rightmost … … 1820 1833 * new interval. 1821 1834 */ 1822 size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -1823 (page + count*PAGE_SIZE)) >> PAGE_WIDTH;1835 size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) - 1836 (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH; 1824 1837 node->value[node->keys - 1] -= count + new_cnt; 1825 1838 btree_insert(&area->used_space, page + 1826 count * PAGE_SIZE, (void *) new_cnt, leaf);1839 (count << PAGE_WIDTH), (void *) new_cnt, leaf); 1827 1840 goto success; 1828 1841 } … … 1837 1850 size_t left_cnt = (size_t) leaf->value[leaf->keys - 1]; 1838 1851 1839 if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,1840 count * PAGE_SIZE)) {1841 if (page + count * PAGE_SIZE==1842 left_pg + left_cnt * PAGE_SIZE) {1852 if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page, 1853 count << PAGE_WIDTH)) { 1854 if (page + (count << PAGE_WIDTH) == 1855 left_pg + (left_cnt << PAGE_WIDTH)) { 1843 1856 /* 1844 1857 * The interval is contained in the rightmost … … 1848 1861 leaf->value[leaf->keys - 1] -= count; 1849 1862 goto success; 1850 } else if (page + count * PAGE_SIZE< left_pg +1851 left_cnt * PAGE_SIZE) {1863 } else if (page + (count << PAGE_WIDTH) < left_pg + 1864 (left_cnt << PAGE_WIDTH)) { 1852 1865 /* 1853 1866 * The interval is contained in the rightmost … … 1857 1870 * interval. 1858 1871 */ 1859 size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -1860 (page + count * PAGE_SIZE)) >> PAGE_WIDTH;1872 size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) - 1873 (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH; 1861 1874 leaf->value[leaf->keys - 1] -= count + new_cnt; 1862 1875 btree_insert(&area->used_space, page + 1863 count * PAGE_SIZE, (void *) new_cnt, leaf);1876 (count << PAGE_WIDTH), (void *) new_cnt, leaf); 1864 1877 goto success; 1865 1878 } … … 1883 1896 * to (i - 1) and i. 1884 1897 */ 1885 if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,1886 count * PAGE_SIZE)) {1887 if (page + count * PAGE_SIZE==1888 left_pg + left_cnt*PAGE_SIZE) {1898 if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page, 1899 count << PAGE_WIDTH)) { 1900 if (page + (count << PAGE_WIDTH) == 1901 left_pg + (left_cnt << PAGE_WIDTH)) { 1889 1902 /* 1890 1903 * The interval is contained in the … … 1895 1908 leaf->value[i - 1] -= count; 1896 1909 goto success; 1897 } else if (page + count * PAGE_SIZE<1898 left_pg + left_cnt * PAGE_SIZE) {1910 } else if (page + (count << PAGE_WIDTH) < 1911 left_pg + (left_cnt << PAGE_WIDTH)) { 1899 1912 /* 1900 1913 * The interval is contained in the … … 1905 1918 */ 1906 1919 size_t new_cnt = ((left_pg + 1907 left_cnt * PAGE_SIZE) -1908 (page + count * PAGE_SIZE)) >>1920 (left_cnt << PAGE_WIDTH)) - 1921 (page + (count << PAGE_WIDTH))) >> 1909 1922 PAGE_WIDTH; 1910 1923 leaf->value[i - 1] -= count + new_cnt; 1911 1924 btree_insert(&area->used_space, page + 1912 count * PAGE_SIZE, (void *) new_cnt,1925 (count << PAGE_WIDTH), (void *) new_cnt, 1913 1926 leaf); 1914 1927 goto success; … … 1936 1949 sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags) 1937 1950 { 1938 if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,1951 if (as_area_create(AS, flags, size, address, 1939 1952 AS_AREA_ATTR_NONE, &anon_backend, NULL)) 1940 1953 return (sysarg_t) address; … … 1959 1972 { 1960 1973 return (sysarg_t) as_area_destroy(AS, address); 1974 } 1975 1976 /** Return pointer to unmapped address space area 1977 * 1978 * @param base Lowest address bound. 1979 * @param size Requested size of the allocation. 1980 * 1981 * @return Pointer to the beginning of unmapped address space area. 1982 * 1983 */ 1984 sysarg_t sys_as_get_unmapped_area(uintptr_t base, size_t size) 1985 { 1986 if (size == 0) 1987 return 0; 1988 1989 /* 1990 * Make sure we allocate from page-aligned 1991 * address. Check for possible overflow in 1992 * each step. 1993 */ 1994 1995 size_t pages = SIZE2FRAMES(size); 1996 uintptr_t ret = 0; 1997 1998 /* 1999 * Find the lowest unmapped address aligned on the sz 2000 * boundary, not smaller than base and of the required size. 2001 */ 2002 2003 mutex_lock(&AS->lock); 2004 2005 /* First check the base address itself */ 2006 uintptr_t addr = ALIGN_UP(base, PAGE_SIZE); 2007 if ((addr >= base) && 2008 (check_area_conflicts(AS, addr, pages, NULL))) 2009 ret = addr; 2010 2011 /* Eventually check the addresses behind each area */ 2012 link_t *cur; 2013 for (cur = AS->as_area_btree.leaf_head.next; 2014 (ret == 0) && (cur != &AS->as_area_btree.leaf_head); 2015 cur = cur->next) { 2016 btree_node_t *node = 2017 list_get_instance(cur, btree_node_t, leaf_link); 2018 2019 btree_key_t i; 2020 for (i = 0; (ret == 0) && (i < node->keys); i++) { 2021 as_area_t *area = (as_area_t *) node->value[i]; 2022 2023 mutex_lock(&area->lock); 2024 2025 uintptr_t addr = 2026 ALIGN_UP(area->base + (area->pages << PAGE_WIDTH), 2027 PAGE_SIZE); 2028 2029 if ((addr >= base) && (addr >= area->base) && 2030 (check_area_conflicts(AS, addr, pages, area))) 2031 ret = addr; 2032 2033 mutex_unlock(&area->lock); 2034 } 2035 } 2036 2037 mutex_unlock(&AS->lock); 2038 2039 return (sysarg_t) ret; 1961 2040 } 1962 2041 … … 2027 2106 mutex_lock(&as->lock); 2028 2107 2029 /* print out info about address space areas */2108 /* Print out info about address space areas */ 2030 2109 link_t *cur; 2031 2110 for (cur = as->as_area_btree.leaf_head.next;
Note:
See TracChangeset
for help on using the changeset viewer.
