Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/mm/as.c

    r75b139f r38dc82d  
    574574 * @param backend_data NULL or a pointer to custom backend data.
    575575 * @param base         Starting virtual address of the area.
    576  *                     If set to AS_AREA_ANY, a suitable mappable area is
    577  *                     found.
    578  * @param bound        Lowest address bound if base is set to AS_AREA_ANY.
     576 *                     If set to -1, a suitable mappable area is found.
     577 * @param bound        Lowest address bound if base is set to -1.
    579578 *                     Otherwise ignored.
    580579 *
     
    586585    mem_backend_data_t *backend_data, uintptr_t *base, uintptr_t bound)
    587586{
    588         if ((*base != (uintptr_t) AS_AREA_ANY) && !IS_ALIGNED(*base, PAGE_SIZE))
     587        if ((*base != (uintptr_t) -1) && !IS_ALIGNED(*base, PAGE_SIZE))
    589588                return NULL;
    590589       
     
    602601        mutex_lock(&as->lock);
    603602       
    604         if (*base == (uintptr_t) AS_AREA_ANY) {
     603        if (*base == (uintptr_t) -1) {
    605604                *base = as_get_unmapped_area(as, bound, size, guarded);
    606605                if (*base == (uintptr_t) -1) {
     
    889888               
    890889                                for (; i < node_size; i++) {
    891                                         pte_t *pte = page_mapping_find(as,
    892                                             ptr + P2SZ(i), false);
     890                                        pte_t pte;
     891                                        bool found = page_mapping_find(as,
     892                                            ptr + P2SZ(i), false, &pte);
    893893                                       
    894                                         ASSERT(pte);
    895                                         ASSERT(PTE_VALID(pte));
    896                                         ASSERT(PTE_PRESENT(pte));
     894                                        ASSERT(found);
     895                                        ASSERT(PTE_VALID(&pte));
     896                                        ASSERT(PTE_PRESENT(&pte));
    897897                                       
    898898                                        if ((area->backend) &&
     
    900900                                                area->backend->frame_free(area,
    901901                                                    ptr + P2SZ(i),
    902                                                     PTE_GET_FRAME(pte));
     902                                                    PTE_GET_FRAME(&pte));
    903903                                        }
    904904                                       
     
    10031003                       
    10041004                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1005                                 pte_t *pte = page_mapping_find(as,
    1006                                      ptr + P2SZ(size), false);
     1005                                pte_t pte;
     1006                                bool found = page_mapping_find(as,
     1007                                     ptr + P2SZ(size), false, &pte);
    10071008                               
    1008                                 ASSERT(pte);
    1009                                 ASSERT(PTE_VALID(pte));
    1010                                 ASSERT(PTE_PRESENT(pte));
     1009                                ASSERT(found);
     1010                                ASSERT(PTE_VALID(&pte));
     1011                                ASSERT(PTE_PRESENT(&pte));
    10111012                               
    10121013                                if ((area->backend) &&
     
    10141015                                        area->backend->frame_free(area,
    10151016                                            ptr + P2SZ(size),
    1016                                             PTE_GET_FRAME(pte));
     1017                                            PTE_GET_FRAME(&pte));
    10171018                                }
    10181019                               
     
    13151316                       
    13161317                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1317                                 pte_t *pte = page_mapping_find(as,
    1318                                     ptr + P2SZ(size), false);
     1318                                pte_t pte;
     1319                                bool found = page_mapping_find(as,
     1320                                    ptr + P2SZ(size), false, &pte);
    13191321                               
    1320                                 ASSERT(pte);
    1321                                 ASSERT(PTE_VALID(pte));
    1322                                 ASSERT(PTE_PRESENT(pte));
     1322                                ASSERT(found);
     1323                                ASSERT(PTE_VALID(&pte));
     1324                                ASSERT(PTE_PRESENT(&pte));
    13231325                               
    1324                                 old_frame[frame_idx++] = PTE_GET_FRAME(pte);
     1326                                old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
    13251327                               
    13261328                                /* Remove old mapping */
     
    14521454         * we need to make sure the mapping has not been already inserted.
    14531455         */
    1454         pte_t *pte;
    1455         if ((pte = page_mapping_find(AS, page, false))) {
    1456                 if (PTE_PRESENT(pte)) {
    1457                         if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
    1458                             (access == PF_ACCESS_WRITE && PTE_WRITABLE(pte)) ||
    1459                             (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(pte))) {
     1456        pte_t pte;
     1457        bool found = page_mapping_find(AS, page, false, &pte);
     1458        if (found) {
     1459                if (PTE_PRESENT(&pte)) {
     1460                        if (((access == PF_ACCESS_READ) && PTE_READABLE(&pte)) ||
     1461                            (access == PF_ACCESS_WRITE && PTE_WRITABLE(&pte)) ||
     1462                            (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(&pte))) {
    14601463                                page_table_unlock(AS, false);
    14611464                                mutex_unlock(&area->lock);
     
    21832186
    21842187sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags,
    2185     uintptr_t bound, int pager)
     2188    uintptr_t bound)
    21862189{
    21872190        uintptr_t virt = base;
    2188         mem_backend_t *backend;
    2189         mem_backend_data_t backend_data;
    2190 
    2191         if (pager == AS_AREA_UNPAGED)
    2192                 backend = &anon_backend;
    2193         else {
    2194                 backend = &user_backend;
    2195                 backend_data.pager = pager;
    2196         }
    21972191        as_area_t *area = as_area_create(AS, flags, size,
    2198             AS_AREA_ATTR_NONE, backend, &backend_data, &virt, bound);
     2192            AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, bound);
    21992193        if (area == NULL)
    2200                 return (sysarg_t) AS_MAP_FAILED;
     2194                return (sysarg_t) -1;
    22012195       
    22022196        return (sysarg_t) virt;
Note: See TracChangeset for help on using the changeset viewer.