Changeset 2057572 in mainline


Ignore:
Timestamp:
2007-03-27T23:40:25Z (18 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
399ece9
Parents:
8d37a06
Message:

The Ultimate Solution To Illegal Virtual Aliases.
It is better to avoid them completely than to fight them.
Switch the sparc64 port to 16K pages. The TLBs and TSBs
continue to operate with 8K pages only. Page tables and
other generic parts operate with 16K pages.

Because the MMU doesn't support 16K directly, each 16K
page is emulated by a pair of 8K pages. With 16K pages,
illegal aliases cannot be created in 16K D-cache.

Files:
1 deleted
38 edited
1 moved

Legend:

Unmodified
Added
Removed

  • boot/arch/sparc64/loader/asm.h

    r8d37a06 r2057572  
    3434#include "main.h"
    3535
    36 #define PAGE_SIZE       8192
    37 #define PAGE_WIDTH      13
     36#define PAGE_WIDTH      14
     37#define PAGE_SIZE       (1 << PAGE_WIDTH)
    3838
    3939#define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))

  • kernel/arch/sparc64/Makefile.inc

    r8d37a06 r2057572  
    8484        arch/$(ARCH)/src/dummy.s \
    8585        arch/$(ARCH)/src/mm/as.c \
    86         arch/$(ARCH)/src/mm/cache.c \
    87         arch/$(ARCH)/src/mm/cache_asm.S \
     86        arch/$(ARCH)/src/mm/cache.S \
    8887        arch/$(ARCH)/src/mm/frame.c \
    8988        arch/$(ARCH)/src/mm/page.c \

  • kernel/arch/sparc64/include/cpu.h

    r8d37a06 r2057572  
    6565                                             generated when the TICK register
    6666                                             matches this value. */
    67 #ifdef CONFIG_SMP
    68         int dcache_active;
    69         dcache_shootdown_msg_t dcache_messages[DCACHE_MSG_QUEUE_LEN];
    70         count_t dcache_message_count;
    71 #endif
    7267} cpu_arch_t;
    7368       

  • kernel/arch/sparc64/include/mm/as.h

    r8d37a06 r2057572  
    8282
    8383#ifdef CONFIG_TSB
    84 #       include <arch/mm/tsb.h>
    85 #       define as_invalidate_translation_cache(as, page, cnt)   tsb_invalidate(as, page, cnt)
     84#include <arch/mm/tsb.h>
     85#define as_invalidate_translation_cache(as, page, cnt) \
     86        tsb_invalidate((as), (page), (cnt))
    8687#else
    87 #       define as_invalidate_translation_cache(as, page, cnt)
     88#define as_invalidate_translation_cache(as, page, cnt)
    8889#endif
    8990

  • kernel/arch/sparc64/include/mm/cache.h

    r8d37a06 r2057572  
    4444        dcache_flush_tag(PAGE_COLOR((p)), ADDR2PFN((f)));
    4545
    46 /**
    47  * Enumerations to differentiate among different scopes of D-Cache
    48  * invalidation.
    49  */
    50 typedef enum {
    51         DCACHE_INVL_INVALID,
    52         DCACHE_INVL_ALL,
    53         DCACHE_INVL_COLOR,
    54         DCACHE_INVL_FRAME
    55 } dcache_invalidate_type_t;
    56 
    57 /**
    58  * Number of messages that can be queued in the cpu_arch_t structure at a time.
    59  */
    60 #define DCACHE_MSG_QUEUE_LEN    10
    61 
    62 /** D-cache shootdown message type. */
    63 typedef struct {
    64         dcache_invalidate_type_t type;
    65         int color;
    66         uintptr_t frame;
    67 } dcache_shootdown_msg_t;
    68 
    6946extern void dcache_flush(void);
    7047extern void dcache_flush_color(int c);
    7148extern void dcache_flush_tag(int c, pfn_t tag);
    72 
    73 #ifdef CONFIG_SMP
    74 extern void dcache_shootdown_start(dcache_invalidate_type_t type, int color,
    75     uintptr_t frame);
    76 extern void dcache_shootdown_finalize(void);
    77 extern void dcache_shootdown_ipi_recv(void);
    78 #else
    79 #define dcache_shootdown_start(t, c, f)
    80 #define dcache_shootdown_finalize()
    81 #define dcache_shootdown_ipi_recv()
    82 #endif /* CONFIG_SMP */
    8349
    8450#endif

  • kernel/arch/sparc64/include/mm/frame.h

    r8d37a06 r2057572  
    3636#define KERN_sparc64_FRAME_H_
    3737
    38 #define FRAME_WIDTH             13      /* 8K */
     38/*
     39 * Page size supported by the MMU.
     40 * For 8K there is the nasty illegal virtual aliasing problem.
     41 * Therefore, the kernel uses 8K only internally on the TLB and TSB levels.
     42 */
     43#define MMU_FRAME_WIDTH         13      /* 8K */
     44#define MMU_FRAME_SIZE          (1 << MMU_FRAME_WIDTH)
     45
     46/*
     47 * Page size exported to the generic memory management subsystems.
     48 * This page size is not directly supported by the MMU, but we can emulate
     49 * each 16K page with a pair of adjacent 8K pages.
     50 */
     51#define FRAME_WIDTH             14      /* 16K */
    3952#define FRAME_SIZE              (1 << FRAME_WIDTH)
    4053

  • kernel/arch/sparc64/include/mm/page.h

    r8d37a06 r2057572  
    3838#include <arch/mm/frame.h>
    3939
     40/*
     41 * On the TLB and TSB level, we still use 8K pages, which are supported by the
     42 * MMU.
     43 */
     44#define MMU_PAGE_WIDTH  MMU_FRAME_WIDTH
     45#define MMU_PAGE_SIZE   MMU_FRAME_SIZE
     46
     47/*
     48 * On the page table level, we use 16K pages. 16K pages are not supported by
     49 * the MMU but we emulate them with pairs of 8K pages.
     50 */
    4051#define PAGE_WIDTH      FRAME_WIDTH
    4152#define PAGE_SIZE       FRAME_SIZE
    4253
    43 #define PAGE_COLOR_BITS 1       /**< 14 - 13; 2^14 == 16K == alias boundary. */
     54#define MMU_PAGES_PER_PAGE      (1 << (PAGE_WIDTH - MMU_PAGE_WIDTH))
     55
     56/*
     57 * With 16K pages, there is only one page color.
     58 */
     59#define PAGE_COLOR_BITS 0       /**< 14 - 14; 2^14 == 16K == alias boundary. */
    4460
    4561#ifdef KERNEL

  • kernel/arch/sparc64/include/mm/tsb.h

    r8d37a06 r2057572  
    113113
    114114extern void tsb_invalidate(struct as *as, uintptr_t page, count_t pages);
    115 extern void itsb_pte_copy(struct pte *t);
    116 extern void dtsb_pte_copy(struct pte *t, bool ro);
     115extern void itsb_pte_copy(struct pte *t, index_t index);
     116extern void dtsb_pte_copy(struct pte *t, index_t index, bool ro);
    117117
    118118#endif /* !def __ASM__ */

  • kernel/arch/sparc64/include/stack.h

    r8d37a06 r2057572  
    4444 * 16-extended-word save area for %i[0-7] and %l[0-7] registers.
    4545 */
    46 #define STACK_WINDOW_SAVE_AREA_SIZE     (16*STACK_ITEM_SIZE)
     46#define STACK_WINDOW_SAVE_AREA_SIZE     (16 * STACK_ITEM_SIZE)
    4747
    4848/**

  • kernel/arch/sparc64/src/cpu/cpu.c

    r8d37a06 r2057572  
    5252        CPU->arch.mid = upa_config.mid;
    5353       
    54 #if (defined(CONFIG_SMP) && defined(CONFIG_VIRT_IDX_DCACHE))
    55         CPU->arch.dcache_active = 1;
    56         CPU->arch.dcache_message_count = 0;
    57 #endif
    58 
    5954        /*
    6055         * Detect processor frequency.

  • kernel/arch/sparc64/src/mm/as.c

    r8d37a06 r2057572  
    6363#ifdef CONFIG_TSB
    6464        int order = fnzb32(((ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT) *
    65                 sizeof(tsb_entry_t)) >> FRAME_WIDTH);
     65                sizeof(tsb_entry_t)) >> MMU_FRAME_WIDTH);
    6666        uintptr_t tsb = (uintptr_t) frame_alloc(order, flags | FRAME_KA);
    6767
    … …  
    7272        as->arch.dtsb = (tsb_entry_t *) (tsb + ITSB_ENTRY_COUNT *
    7373                sizeof(tsb_entry_t));
    74         memsetb((uintptr_t) as->arch.itsb, (ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT)
    75                 * sizeof(tsb_entry_t), 0);
     74        memsetb((uintptr_t) as->arch.itsb,
     75            (ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT) * sizeof(tsb_entry_t), 0);
    7676#endif
    7777        return 0;
    … …  
    8282#ifdef CONFIG_TSB
    8383        count_t cnt = ((ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT) *
    84                 sizeof(tsb_entry_t)) >> FRAME_WIDTH;
     84                sizeof(tsb_entry_t)) >> MMU_FRAME_WIDTH;
    8585        frame_free(KA2PA((uintptr_t) as->arch.itsb));
    8686        return cnt;
    … …  
    140140        uintptr_t tsb = (uintptr_t) as->arch.itsb;
    141141               
    142         if (!overlaps(tsb, 8 * PAGE_SIZE, base, 1 << KERNEL_PAGE_WIDTH)) {
     142        if (!overlaps(tsb, 8 * MMU_PAGE_SIZE, base, 1 << KERNEL_PAGE_WIDTH)) {
    143143                /*
    144144                 * TSBs were allocated from memory not covered
    … …  
    159159        tsb_base.split = 0;
    160160
    161         tsb_base.base = ((uintptr_t) as->arch.itsb) >> PAGE_WIDTH;
     161        tsb_base.base = ((uintptr_t) as->arch.itsb) >> MMU_PAGE_WIDTH;
    162162        itsb_base_write(tsb_base.value);
    163         tsb_base.base = ((uintptr_t) as->arch.dtsb) >> PAGE_WIDTH;
     163        tsb_base.base = ((uintptr_t) as->arch.dtsb) >> MMU_PAGE_WIDTH;
    164164        dtsb_base_write(tsb_base.value);
    165165#endif
    … …  
    190190        uintptr_t tsb = (uintptr_t) as->arch.itsb;
    191191               
    192         if (!overlaps(tsb, 8 * PAGE_SIZE, base, 1 << KERNEL_PAGE_WIDTH)) {
     192        if (!overlaps(tsb, 8 * MMU_PAGE_SIZE, base, 1 << KERNEL_PAGE_WIDTH)) {
    193193                /*
    194194                 * TSBs were allocated from memory not covered

  • kernel/arch/sparc64/src/mm/page.c

    r8d37a06 r2057572  
    7474                for (i = 0; i < bsp_locked_dtlb_entries; i++) {
    7575                        dtlb_insert_mapping(bsp_locked_dtlb_entry[i].virt_page,
    76                                 bsp_locked_dtlb_entry[i].phys_page,
    77                                 bsp_locked_dtlb_entry[i].pagesize_code, true,
    78                                 false);
     76                            bsp_locked_dtlb_entry[i].phys_page,
     77                            bsp_locked_dtlb_entry[i].pagesize_code, true,
     78                            false);
    7979                }
    8080#endif 
    … …  
    108108                count_t count;
    109109        } sizemap[] = {
    110                 { PAGESIZE_8K, 0, 1 },                  /* 8K */
    111                 { PAGESIZE_8K, PAGE_SIZE, 2 },          /* 16K */
    112                 { PAGESIZE_8K, PAGE_SIZE, 4 },          /* 32K */
    113                 { PAGESIZE_64K, 0, 1},                  /* 64K */
    114                 { PAGESIZE_64K, 8 * PAGE_SIZE, 2 },     /* 128K */
    115                 { PAGESIZE_64K, 8 * PAGE_SIZE, 4 },     /* 256K */
    116                 { PAGESIZE_512K, 0, 1 },                /* 512K */
    117                 { PAGESIZE_512K, 64 * PAGE_SIZE, 2 },   /* 1M */
    118                 { PAGESIZE_512K, 64 * PAGE_SIZE, 4 },   /* 2M */
    119                 { PAGESIZE_4M, 0, 1 },                  /* 4M */
    120                 { PAGESIZE_4M, 512 * PAGE_SIZE, 2 }     /* 8M */
     110                { PAGESIZE_8K, 0, 1 },                          /* 8K */
     111                { PAGESIZE_8K, MMU_PAGE_SIZE, 2 },              /* 16K */
     112                { PAGESIZE_8K, MMU_PAGE_SIZE, 4 },              /* 32K */
     113                { PAGESIZE_64K, 0, 1},                          /* 64K */
     114                { PAGESIZE_64K, 8 * MMU_PAGE_SIZE, 2 },         /* 128K */
     115                { PAGESIZE_64K, 8 * MMU_PAGE_SIZE, 4 },         /* 256K */
     116                { PAGESIZE_512K, 0, 1 },                        /* 512K */
     117                { PAGESIZE_512K, 64 * MMU_PAGE_SIZE, 2 },       /* 1M */
     118                { PAGESIZE_512K, 64 * MMU_PAGE_SIZE, 4 },       /* 2M */
     119                { PAGESIZE_4M, 0, 1 },                          /* 4M */
     120                { PAGESIZE_4M, 512 * MMU_PAGE_SIZE, 2 }         /* 8M */
    121121        };
    122122       
    123         ASSERT(ALIGN_UP(physaddr, PAGE_SIZE) == physaddr);
     123        ASSERT(ALIGN_UP(physaddr, MMU_PAGE_SIZE) == physaddr);
    124124        ASSERT(size <= 8 * 1024 * 1024);
    125125       
    126         if (size <= FRAME_SIZE)
     126        if (size <= MMU_FRAME_SIZE)
    127127                order = 0;
    128128        else
    129                 order = (fnzb64(size - 1) + 1) - FRAME_WIDTH;
     129                order = (fnzb64(size - 1) + 1) - MMU_FRAME_WIDTH;
    130130
    131131        /*
    … …  
    135135         */
    136136        ASSERT(PA2KA(last_frame));
    137         uintptr_t virtaddr = ALIGN_UP(PA2KA(last_frame), 1 << (order + FRAME_WIDTH));
    138         last_frame = ALIGN_UP(KA2PA(virtaddr) + size, 1 << (order + FRAME_WIDTH));
     137        uintptr_t virtaddr = ALIGN_UP(PA2KA(last_frame),
     138            1 << (order + FRAME_WIDTH));
     139        last_frame = ALIGN_UP(KA2PA(virtaddr) + size,
     140            1 << (order + FRAME_WIDTH));
    139141       
    140142        for (i = 0; i < sizemap[order].count; i++) {
    … …  
    143145                 */
    144146                dtlb_insert_mapping(virtaddr + i * sizemap[order].increment,
    145                         physaddr + i * sizemap[order].increment,
    146                         sizemap[order].pagesize_code, true, false);
     147                    physaddr + i * sizemap[order].increment,
     148                    sizemap[order].pagesize_code, true, false);
    147149       
    148150#ifdef CONFIG_SMP       
    … …  
    151153                 */
    152154                bsp_locked_dtlb_entry[bsp_locked_dtlb_entries].virt_page =
    153                         virtaddr + i * sizemap[order].increment;
     155                    virtaddr + i * sizemap[order].increment;
    154156                bsp_locked_dtlb_entry[bsp_locked_dtlb_entries].phys_page =
    155                         physaddr + i * sizemap[order].increment;
     157                    physaddr + i * sizemap[order].increment;
    156158                bsp_locked_dtlb_entry[bsp_locked_dtlb_entries].pagesize_code =
    157                         sizemap[order].pagesize_code;
     159                    sizemap[order].pagesize_code;
    158160                bsp_locked_dtlb_entries++;
    159161#endif

  • kernel/arch/sparc64/src/mm/tlb.c

    r8d37a06 r2057572  
    5555#endif
    5656
    57 static void dtlb_pte_copy(pte_t *t, bool ro);
    58 static void itlb_pte_copy(pte_t *t);
    59 static void do_fast_instruction_access_mmu_miss_fault(istate_t *istate, const
    60         char *str);
     57static void dtlb_pte_copy(pte_t *t, index_t index, bool ro);
     58static void itlb_pte_copy(pte_t *t, index_t index);
     59static void do_fast_instruction_access_mmu_miss_fault(istate_t *istate,
     60    const char *str);
    6161static void do_fast_data_access_mmu_miss_fault(istate_t *istate,
    62         tlb_tag_access_reg_t tag, const char *str);
     62    tlb_tag_access_reg_t tag, const char *str);
    6363static void do_fast_data_access_protection_fault(istate_t *istate,
    64         tlb_tag_access_reg_t tag, const char *str);
     64    tlb_tag_access_reg_t tag, const char *str);
    6565
    6666char *context_encoding[] = {
    … …  
    9393 * @param cacheable True if the mapping is cacheable, false otherwise.
    9494 */
    95 void dtlb_insert_mapping(uintptr_t page, uintptr_t frame, int pagesize, bool
    96         locked, bool cacheable)
     95void dtlb_insert_mapping(uintptr_t page, uintptr_t frame, int pagesize,
     96    bool locked, bool cacheable)
    9797{
    9898        tlb_tag_access_reg_t tag;
    … …  
    127127/** Copy PTE to TLB.
    128128 *
    129  * @param t Page Table Entry to be copied.
    130  * @param ro If true, the entry will be created read-only, regardless of its w
    131  *      field.
    132  */
    133 void dtlb_pte_copy(pte_t *t, bool ro)
     129 * @param t     Page Table Entry to be copied.
     130 * @param index Zero if lower 8K-subpage, one if higher 8K-subpage.
     131 * @param ro    If true, the entry will be created read-only, regardless of its
     132 *              w field.
     133 */
     134void dtlb_pte_copy(pte_t *t, index_t index, bool ro)
    134135{
    135136        tlb_tag_access_reg_t tag;
    … …  
    138139        frame_address_t fr;
    139140
    140         pg.address = t->page;
    141         fr.address = t->frame;
     141        pg.address = t->page + (index << MMU_PAGE_WIDTH);
     142        fr.address = t->frame + (index << MMU_PAGE_WIDTH);
    142143
    143144        tag.value = 0;
    144145        tag.context = t->as->asid;
    145146        tag.vpn = pg.vpn;
    146        
     147
    147148        dtlb_tag_access_write(tag.value);
    148        
     149
    149150        data.value = 0;
    150151        data.v = true;
    … …  
    159160        data.w = ro ? false : t->w;
    160161        data.g = t->g;
    161        
     162
    162163        dtlb_data_in_write(data.value);
    163164}
    … …  
    165166/** Copy PTE to ITLB.
    166167 *
    167  * @param t Page Table Entry to be copied.
    168  */
    169 void itlb_pte_copy(pte_t *t)
     168 * @param t     Page Table Entry to be copied.
     169 * @param index Zero if lower 8K-subpage, one if higher 8K-subpage.
     170 */
     171void itlb_pte_copy(pte_t *t, index_t index)
    170172{
    171173        tlb_tag_access_reg_t tag;
    … …  
    174176        frame_address_t fr;
    175177
    176         pg.address = t->page;
    177         fr.address = t->frame;
     178        pg.address = t->page + (index << MMU_PAGE_WIDTH);
     179        fr.address = t->frame + (index << MMU_PAGE_WIDTH);
    178180
    179181        tag.value = 0;
    … …  
    200202{
    201203        uintptr_t va = ALIGN_DOWN(istate->tpc, PAGE_SIZE);
     204        index_t index = (istate->tpc >> MMU_PAGE_WIDTH) % MMU_PAGES_PER_PAGE;
    202205        pte_t *t;
    203206
    … …  
    210213                 */
    211214                t->a = true;
    212                 itlb_pte_copy(t);
     215                itlb_pte_copy(t, index);
    213216#ifdef CONFIG_TSB
    214                 itsb_pte_copy(t);
     217                itsb_pte_copy(t, index);
    215218#endif
    216219                page_table_unlock(AS, true);
    … …  
    223226                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    224227                        do_fast_instruction_access_mmu_miss_fault(istate,
    225                                 __FUNCTION__);
     228                            __FUNCTION__);
    226229                }
    227230        }
    … …  
    237240        tlb_tag_access_reg_t tag;
    238241        uintptr_t va;
     242        index_t index;
    239243        pte_t *t;
    240244
    241245        tag.value = dtlb_tag_access_read();
    242         va = tag.vpn << PAGE_WIDTH;
     246        va = ALIGN_DOWN((uint64_t) tag.vpn << MMU_PAGE_WIDTH, PAGE_SIZE);
     247        index = tag.vpn % MMU_PAGES_PER_PAGE;
    243248
    244249        if (tag.context == ASID_KERNEL) {
    … …  
    246251                        /* NULL access in kernel */
    247252                        do_fast_data_access_mmu_miss_fault(istate, tag,
    248                                 __FUNCTION__);
     253                            __FUNCTION__);
    249254                }
    250255                do_fast_data_access_mmu_miss_fault(istate, tag, "Unexpected "
    251                         "kernel page fault.");
     256                    "kernel page fault.");
    252257        }
    253258
    … …  
    260265                 */
    261266                t->a = true;
    262                 dtlb_pte_copy(t, true);
     267                dtlb_pte_copy(t, index, true);
    263268#ifdef CONFIG_TSB
    264                 dtsb_pte_copy(t, true);
     269                dtsb_pte_copy(t, index, true);
    265270#endif
    266271                page_table_unlock(AS, true);
    267272        } else {
    268273                /*
    269                  * Forward the page fault to the address space page fault handler.
     274                 * Forward the page fault to the address space page fault
     275                 * handler.
    270276                 */             
    271277                page_table_unlock(AS, true);
    272278                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    273279                        do_fast_data_access_mmu_miss_fault(istate, tag,
    274                                 __FUNCTION__);
     280                            __FUNCTION__);
    275281                }
    276282        }
    … …  
    282288        tlb_tag_access_reg_t tag;
    283289        uintptr_t va;
     290        index_t index;
    284291        pte_t *t;
    285292
    286293        tag.value = dtlb_tag_access_read();
    287         va = tag.vpn << PAGE_WIDTH;
     294        va = ALIGN_DOWN((uint64_t) tag.vpn << MMU_PAGE_WIDTH, PAGE_SIZE);
     295        index = tag.vpn % MMU_PAGES_PER_PAGE;   /* 16K-page emulation */
    288296
    289297        page_table_lock(AS, true);
    … …  
    297305                t->a = true;
    298306                t->d = true;
    299                 dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_SECONDARY, va);
    300                 dtlb_pte_copy(t, false);
     307                dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_SECONDARY,
     308                    va + index * MMU_PAGE_SIZE);
     309                dtlb_pte_copy(t, index, false);
    301310#ifdef CONFIG_TSB
    302                 dtsb_pte_copy(t, false);
     311                dtsb_pte_copy(t, index, false);
    303312#endif
    304313                page_table_unlock(AS, true);
    … …  
    311320                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    312321                        do_fast_data_access_protection_fault(istate, tag,
    313                                 __FUNCTION__);
     322                            __FUNCTION__);
    314323                }
    315324        }
    … …  
    329338
    330339                printf("%d: vpn=%#llx, context=%d, v=%d, size=%d, nfo=%d, "
    331                         "ie=%d, soft2=%#x, diag=%#x, pfn=%#x, soft=%#x, l=%d, "
    332                         "cp=%d, cv=%d, e=%d, p=%d, w=%d, g=%d\n", i, t.vpn,
    333                         t.context, d.v, d.size, d.nfo, d.ie, d.soft2, d.diag,
    334                         d.pfn, d.soft, d.l, d.cp, d.cv, d.e, d.p, d.w, d.g);
     340                    "ie=%d, soft2=%#x, diag=%#x, pfn=%#x, soft=%#x, l=%d, "
     341                    "cp=%d, cv=%d, e=%d, p=%d, w=%d, g=%d\n", i, t.vpn,
     342                    t.context, d.v, d.size, d.nfo, d.ie, d.soft2, d.diag,
     343                    d.pfn, d.soft, d.l, d.cp, d.cv, d.e, d.p, d.w, d.g);
    335344        }
    336345
    … …  
    341350               
    342351                printf("%d: vpn=%#llx, context=%d, v=%d, size=%d, nfo=%d, "
    343                         "ie=%d, soft2=%#x, diag=%#x, pfn=%#x, soft=%#x, l=%d, "
    344                         "cp=%d, cv=%d, e=%d, p=%d, w=%d, g=%d\n", i, t.vpn,
    345                         t.context, d.v, d.size, d.nfo, d.ie, d.soft2, d.diag,
    346                         d.pfn, d.soft, d.l, d.cp, d.cv, d.e, d.p, d.w, d.g);
    347         }
    348 
    349 }
    350 
    351 void do_fast_instruction_access_mmu_miss_fault(istate_t *istate, const char
    352         *str)
     352                    "ie=%d, soft2=%#x, diag=%#x, pfn=%#x, soft=%#x, l=%d, "
     353                    "cp=%d, cv=%d, e=%d, p=%d, w=%d, g=%d\n", i, t.vpn,
     354                    t.context, d.v, d.size, d.nfo, d.ie, d.soft2, d.diag,
     355                    d.pfn, d.soft, d.l, d.cp, d.cv, d.e, d.p, d.w, d.g);
     356        }
     357
     358}
     359
     360void do_fast_instruction_access_mmu_miss_fault(istate_t *istate,
     361    const char *str)
    353362{
    354363        fault_if_from_uspace(istate, "%s\n", str);
    … …  
    357366}
    358367
    359 void do_fast_data_access_mmu_miss_fault(istate_t *istate, tlb_tag_access_reg_t
    360         tag, const char *str)
     368void do_fast_data_access_mmu_miss_fault(istate_t *istate,
     369    tlb_tag_access_reg_t tag, const char *str)
    361370{
    362371        uintptr_t va;
    363372
    364         va = tag.vpn << PAGE_WIDTH;
     373        va = tag.vpn << MMU_PAGE_WIDTH;
    365374
    366375        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
    367                 tag.context);
     376            tag.context);
    368377        dump_istate(istate);
    369378        printf("Faulting page: %p, ASID=%d\n", va, tag.context);
    … …  
    371380}
    372381
    373 void do_fast_data_access_protection_fault(istate_t *istate, tlb_tag_access_reg_t
    374         tag, const char *str)
     382void do_fast_data_access_protection_fault(istate_t *istate,
     383    tlb_tag_access_reg_t tag, const char *str)
    375384{
    376385        uintptr_t va;
    377386
    378         va = tag.vpn << PAGE_WIDTH;
     387        va = tag.vpn << MMU_PAGE_WIDTH;
    379388
    380389        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
    381                 tag.context);
     390            tag.context);
    382391        printf("Faulting page: %p, ASID=%d\n", va, tag.context);
    383392        dump_istate(istate);
    … …  
    394403       
    395404        printf("DTLB SFSR: asi=%#x, ft=%#x, e=%d, ct=%d, pr=%d, w=%d, ow=%d, "
    396                 "fv=%d\n", sfsr.asi, sfsr.ft, sfsr.e, sfsr.ct, sfsr.pr, sfsr.w,
    397                 sfsr.ow, sfsr.fv);
     405            "fv=%d\n", sfsr.asi, sfsr.ft, sfsr.e, sfsr.ct, sfsr.pr, sfsr.w,
     406            sfsr.ow, sfsr.fv);
    398407        printf("DTLB SFAR: address=%p\n", sfar);
    399408       
    … …  
    482491        mmu_primary_context_write(ctx.v);
    483492       
    484         for (i = 0; i < cnt; i++) {
     493        for (i = 0; i < cnt * MMU_PAGES_PER_PAGE; i++) {
    485494                itlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_PRIMARY,
    486                     page + i * PAGE_SIZE);
     495                    page + i * MMU_PAGE_SIZE);
    487496                dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_PRIMARY,
    488                     page + i * PAGE_SIZE);
     497                    page + i * MMU_PAGE_SIZE);
    489498        }
    490499       

  • kernel/arch/sparc64/src/mm/tsb.c

    r8d37a06 r2057572  
    3535#include <arch/mm/tsb.h>
    3636#include <arch/mm/tlb.h>
     37#include <arch/mm/page.h>
    3738#include <arch/barrier.h>
    3839#include <mm/as.h>
    … …  
    4142#include <debug.h>
    4243
    43 #define TSB_INDEX_MASK          ((1 << (21 + 1 + TSB_SIZE - PAGE_WIDTH)) - 1)
     44#define TSB_INDEX_MASK  ((1 << (21 + 1 + TSB_SIZE - MMU_PAGE_WIDTH)) - 1)
    4445
    4546/** Invalidate portion of TSB.
    … …  
    6061        ASSERT(as->arch.itsb && as->arch.dtsb);
    6162       
    62         i0 = (page >> PAGE_WIDTH) & TSB_INDEX_MASK;
    63         cnt = min(pages, ITSB_ENTRY_COUNT);
     63        i0 = (page >> MMU_PAGE_WIDTH) & TSB_INDEX_MASK;
     64        cnt = min(pages * MMU_PAGES_PER_PAGE, ITSB_ENTRY_COUNT);
    6465       
    6566        for (i = 0; i < cnt; i++) {
    6667                as->arch.itsb[(i0 + i) & (ITSB_ENTRY_COUNT - 1)].tag.invalid =
    67                         true;
     68                    true;
    6869                as->arch.dtsb[(i0 + i) & (DTSB_ENTRY_COUNT - 1)].tag.invalid =
    69                         true;
     70                    true;
    7071        }
    7172}
    … …  
    7374/** Copy software PTE to ITSB.
    7475 *
    75  * @param t Software PTE.
     76 * @param t     Software PTE.
     77 * @param index Zero if lower 8K-subpage, one if higher 8K subpage.
    7678 */
    77 void itsb_pte_copy(pte_t *t)
     79void itsb_pte_copy(pte_t *t, index_t index)
    7880{
    7981        as_t *as;
    8082        tsb_entry_t *tsb;
     83        index_t entry;
    8184       
    8285        as = t->as;
    83         tsb = &as->arch.itsb[(t->page >> PAGE_WIDTH) & TSB_INDEX_MASK];
     86        entry = ((t->page >> MMU_PAGE_WIDTH) + index) & TSB_INDEX_MASK;
     87        tsb = &as->arch.itsb[entry];
    8488
    8589        /*
    … …  
    96100
    97101        tsb->tag.context = as->asid;
    98         tsb->tag.va_tag = t->page >> VA_TAG_PAGE_SHIFT;
     102        tsb->tag.va_tag = (t->page + (index << MMU_PAGE_WIDTH)) >>
     103            VA_TAG_PAGE_SHIFT;
    99104        tsb->data.value = 0;
    100105        tsb->data.size = PAGESIZE_8K;
    101         tsb->data.pfn = t->frame >> FRAME_WIDTH;
     106        tsb->data.pfn = (t->frame >> MMU_FRAME_WIDTH) + index;
    102107        tsb->data.cp = t->c;
    103108        tsb->data.p = t->k;             /* p as privileged */
    … …  
    111116/** Copy software PTE to DTSB.
    112117 *
    113  * @param t Software PTE.
    114  * @param ro If true, the mapping is copied read-only.
     118 * @param t     Software PTE.
     119 * @param index Zero if lower 8K-subpage, one if higher 8K-subpage.
     120 * @param ro    If true, the mapping is copied read-only.
    115121 */
    116 void dtsb_pte_copy(pte_t *t, bool ro)
     122void dtsb_pte_copy(pte_t *t, index_t index, bool ro)
    117123{
    118124        as_t *as;
    119125        tsb_entry_t *tsb;
     126        index_t entry;
    120127       
    121128        as = t->as;
    122         tsb = &as->arch.dtsb[(t->page >> PAGE_WIDTH) & TSB_INDEX_MASK];
     129        entry = ((t->page >> MMU_PAGE_WIDTH) + index) & TSB_INDEX_MASK;
     130        tsb = &as->arch.dtsb[entry];
    123131
    124132        /*
    … …  
    135143
    136144        tsb->tag.context = as->asid;
    137         tsb->tag.va_tag = t->page >> VA_TAG_PAGE_SHIFT;
     145        tsb->tag.va_tag = (t->page + (index << MMU_PAGE_WIDTH)) >>
     146            VA_TAG_PAGE_SHIFT;
    138147        tsb->data.value = 0;
    139148        tsb->data.size = PAGESIZE_8K;
    140         tsb->data.pfn = t->frame >> FRAME_WIDTH;
     149        tsb->data.pfn = (t->frame >> MMU_FRAME_WIDTH) + index;
    141150        tsb->data.cp = t->c;
    142151#ifdef CONFIG_VIRT_IDX_DCACHE

  • kernel/arch/sparc64/src/smp/ipi.c

    r8d37a06 r2057572  
    4040#include <config.h>
    4141#include <mm/tlb.h>
    42 #include <arch/mm/cache.h>
    4342#include <arch/interrupt.h>
    4443#include <arch/trap/interrupt.h>
    … …  
    126125                func = tlb_shootdown_ipi_recv;
    127126                break;
    128 #if (defined(CONFIG_SMP) && (defined(CONFIG_VIRT_IDX_DCACHE)))
    129         case IPI_DCACHE_SHOOTDOWN:
    130                 func = dcache_shootdown_ipi_recv;
    131                 break;
    132 #endif
    133127        default:
    134128                panic("Unknown IPI (%d).\n", ipi);

  • kernel/arch/sparc64/src/trap/interrupt.c

    r8d37a06 r2057572  
    4545#include <arch.h>
    4646#include <mm/tlb.h>
    47 #include <arch/mm/cache.h>
    4847#include <config.h>
    4948#include <synch/spinlock.h>
    … …  
    9291                if (data0 == (uintptr_t) tlb_shootdown_ipi_recv) {
    9392                        tlb_shootdown_ipi_recv();
    94 #ifdef CONFIG_VIRT_IDX_DCACHE
    95                 } else if (data0 == (uintptr_t) dcache_shootdown_ipi_recv) {
    96                         dcache_shootdown_ipi_recv();
    97 #endif
    9893                }
    9994#endif

  • kernel/genarch/src/fb/fb.c

    r8d37a06 r2057572  
    512512        sysinfo_set_item_val("fb.visual", NULL, visual);
    513513        sysinfo_set_item_val("fb.address.physical", NULL, addr);
    514         sysinfo_set_item_val("fb.address.color", NULL,
    515             PAGE_COLOR((uintptr_t) fbaddress));
    516514        sysinfo_set_item_val("fb.invert-colors", NULL, invert_colors);
    517515

  • kernel/genarch/src/mm/page_ht.c

    r8d37a06 r2057572  
    5656static void remove_callback(link_t *item);
    5757
    58 static void ht_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags);
     58static void ht_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame,
     59    int flags);
    5960static void ht_mapping_remove(as_t *as, uintptr_t page);
    6061static pte_t *ht_mapping_find(as_t *as, uintptr_t page);
    … …  
    104105         * hash index.
    105106         */
    106         index = ((page >> PAGE_WIDTH) & (PAGE_HT_ENTRIES-1));
     107        index = ((page >> PAGE_WIDTH) & (PAGE_HT_ENTRIES - 1));
    107108       
    108109        /*
    … …  
    111112         * hash index.
    112113         */
    113         index |= ((unative_t) as) & (PAGE_HT_ENTRIES-1);
     114        index |= ((unative_t) as) & (PAGE_HT_ENTRIES - 1);
    114115       
    115116        return index;
    … …  
    137138
    138139        if (keys == PAGE_HT_KEYS) {
    139                 return (key[KEY_AS] == (uintptr_t) t->as) && (key[KEY_PAGE] == t->page);
     140                return (key[KEY_AS] == (uintptr_t) t->as) &&
     141                    (key[KEY_PAGE] == t->page);
    140142        } else {
    141143                return (key[KEY_AS] == (uintptr_t) t->as);
    … …  
    176178{
    177179        pte_t *t;
    178         unative_t key[2] = { (uintptr_t) as, page = ALIGN_DOWN(page, PAGE_SIZE) };
     180        unative_t key[2] = {
     181                (uintptr_t) as,
     182                page = ALIGN_DOWN(page, PAGE_SIZE)
     183        };
    179184       
    180185        if (!hash_table_find(&page_ht, key)) {
    … …  
    210215void ht_mapping_remove(as_t *as, uintptr_t page)
    211216{
    212         unative_t key[2] = { (uintptr_t) as, page = ALIGN_DOWN(page, PAGE_SIZE) };
     217        unative_t key[2] = {
     218                (uintptr_t) as,
     219                page = ALIGN_DOWN(page, PAGE_SIZE)
     220        };
    213221       
    214222        /*
    … …  
    235243        link_t *hlp;
    236244        pte_t *t = NULL;
    237         unative_t key[2] = { (uintptr_t) as, page = ALIGN_DOWN(page, PAGE_SIZE) };
     245        unative_t key[2] = {
     246                (uintptr_t) as,
     247                page = ALIGN_DOWN(page, PAGE_SIZE)
     248        };
    238249       
    239250        hlp = hash_table_find(&page_ht, key);

  • kernel/generic/src/console/klog.c

    r8d37a06 r2057572  
    9191
    9292        sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);
    93         sysinfo_set_item_val("klog.fcolor", NULL, (unative_t)
    94                 PAGE_COLOR((uintptr_t) klog));
    9593        sysinfo_set_item_val("klog.pages", NULL, 1 << KLOG_ORDER);
    9694        sysinfo_set_item_val("klog.devno", NULL, devno);

  • kernel/generic/src/ddi/ddi.c

    r8d37a06 r2057572  
    100100 *      syscall, ENOENT if there is no task matching the specified ID or the
    101101 *      physical address space is not enabled for mapping and ENOMEM if there
    102  *      was a problem in creating address space area. ENOTSUP is returned when
    103  *      an attempt to create an illegal address alias is detected.
     102 *      was a problem in creating address space area.
    104103 */
    105104static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, count_t pages, int flags)
    … …  
    140139                return ENOENT;
    141140        }
    142 
    143 #ifdef CONFIG_VIRT_IDX_DCACHE
    144         if (PAGE_COLOR(parea->vbase) != PAGE_COLOR(vp)) {
    145                 /*
    146                  * Refuse to create an illegal address alias.
    147                  */
    148                 spinlock_unlock(&parea_lock);
    149                 interrupts_restore(ipl);
    150                 return ENOTSUP;
    151         }
    152 #endif /* CONFIG_VIRT_IDX_DCACHE */
    153 
    154141        spinlock_unlock(&parea_lock);
    155142

  • kernel/generic/src/lib/rd.c

    r8d37a06 r2057572  
    9191        sysinfo_set_item_val("rd.address.physical", NULL, (unative_t)
    9292                KA2PA((void *) header + hsize));
    93         sysinfo_set_item_val("rd.address.color", NULL, (unative_t)
    94                 PAGE_COLOR((uintptr_t) header + hsize));
    9593
    9694        return RE_OK;

  • kernel/generic/src/mm/as.c

    r8d37a06 r2057572  
    614614 * or ENOMEM if there was a problem in allocating destination address space
    615615 * area. ENOTSUP is returned if the address space area backend does not support
    616  * sharing or if the kernel detects an attempt to create an illegal address
    617  * alias.
     616 * sharing.
    618617 */
    619618int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
    … …  
    667666                return EPERM;
    668667        }
    669 
    670 #ifdef CONFIG_VIRT_IDX_DCACHE
    671         if (!(dst_flags_mask & AS_AREA_EXEC)) {
    672                 if (PAGE_COLOR(src_area->base) != PAGE_COLOR(dst_base)) {
    673                         /*
    674                          * Refuse to create an illegal address alias.
    675                          */
    676                         mutex_unlock(&src_area->lock);
    677                         mutex_unlock(&src_as->lock);
    678                         interrupts_restore(ipl);
    679                         return ENOTSUP;
    680                 }
    681         }
    682 #endif /* CONFIG_VIRT_IDX_DCACHE */
    683668
    684669        /*
    … …  
    902887                         * ASID.
    903888                         */
    904                          ASSERT(old_as->asid != ASID_INVALID);
    905                          list_append(&old_as->inactive_as_with_asid_link,
    906                              &inactive_as_with_asid_head);
     889                        ASSERT(old_as->asid != ASID_INVALID);
     890                        list_append(&old_as->inactive_as_with_asid_link,
     891                            &inactive_as_with_asid_head);
    907892                }
    908893                mutex_unlock(&old_as->lock);

  • kernel/generic/src/mm/backend_anon.c

    r8d37a06 r2057572  
    158158                panic("Could not insert used space.\n");
    159159               
    160 #ifdef CONFIG_VIRT_IDX_DCACHE
    161         if (dirty && PAGE_COLOR(PA2KA(frame)) != PAGE_COLOR(addr)) {
    162                 /*
    163                  * By writing to the frame using kernel virtual address,
    164                  * we have created an illegal virtual alias. We now have to
    165                  * invalidate cachelines belonging to addr on all processors
    166                  * so that they will be reloaded with the new content on next
    167                  * read.
    168                  */
    169                 dcache_flush_frame(addr, frame);
    170                 dcache_shootdown_start(DCACHE_INVL_FRAME, PAGE_COLOR(addr), frame);
    171                 dcache_shootdown_finalize();
    172         }
    173 #endif
    174 
    175160        return AS_PF_OK;
    176161}
    … …  
    241226/** @}
    242227 */
    243 

  • kernel/generic/src/mm/backend_elf.c

    r8d37a06 r2057572  
    209209        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
    210210                panic("Could not insert used space.\n");
    211 
    212 #ifdef CONFIG_VIRT_IDX_DCACHE
    213         if (dirty && PAGE_COLOR(PA2KA(frame)) != PAGE_COLOR(addr)) {
    214                 /*
    215                  * By writing to the frame using kernel virtual address,
    216                  * we have created an illegal virtual alias. We now have to
    217                  * invalidate cachelines belonging to addr on all processors
    218                  * so that they will be reloaded with the new content on next
    219                  * read.
    220                  */
    221                 dcache_flush_frame(addr, frame);
    222                 dcache_shootdown_start(DCACHE_INVL_FRAME, PAGE_COLOR(addr), frame);
    223                 dcache_shootdown_finalize();
    224         }
    225 #endif
    226211
    227212        return AS_PF_OK;
    … …  
    356341/** @}
    357342 */
    358 

  • kernel/generic/src/time/clock.c

    r8d37a06 r2057572  
    105105         */
    106106        sysinfo_set_item_val("clock.cacheable", NULL, (unative_t) true);
    107         sysinfo_set_item_val("clock.fcolor", NULL, (unative_t)
    108                 PAGE_COLOR(clock_parea.vbase));
    109107        sysinfo_set_item_val("clock.faddr", NULL, (unative_t) faddr);
    110108}

  • uspace/fb/ega.c

    r8d37a06 r2057572  
    316316
    317317        sz = scr_width * scr_height * 2;
    318         scr_addr = as_get_mappable_page(sz, (int)
    319                 sysinfo_value("fb.address.color"));
     318        scr_addr = as_get_mappable_page(sz);
    320319
    321320        physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>

  • uspace/fb/fb.c

    r8d37a06 r2057572  
    756756                /* We accept one area for data interchange */
    757757                if (IPC_GET_ARG1(*call) == shm_id) {
    758                         void *dest = as_get_mappable_page(IPC_GET_ARG2(*call),
    759                                 PAGE_COLOR(IPC_GET_ARG1(*call)));
     758                        void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
    760759                        shm_size = IPC_GET_ARG2(*call);
    761760                        if (!ipc_answer_fast(callid, 0, (sysarg_t) dest, 0))
    … …  
    13701369
    13711370        asz = fb_scanline * fb_height;
    1372         fb_addr = as_get_mappable_page(asz, (int)
    1373                 sysinfo_value("fb.address.color"));
     1371        fb_addr = as_get_mappable_page(asz);
    13741372       
    13751373        physmem_map(fb_ph_addr, fb_addr, ALIGN_UP(asz, PAGE_SIZE) >>

  • uspace/fb/main.c

    r8d37a06 r2057572  
    4444        void *dest;
    4545
    46         dest = as_get_mappable_page(IPC_GET_ARG2(*call),
    47                 PAGE_COLOR(IPC_GET_ARG1(*call)));
     46        dest = as_get_mappable_page(IPC_GET_ARG2(*call));
    4847        if (ipc_answer_fast(callid, 0, (sysarg_t) dest, 0) == 0) {
    4948                if (*area)

  • uspace/klog/klog.c

    r8d37a06 r2057572  
    6363        printf("Kernel console output.\n");
    6464       
    65         mapping = as_get_mappable_page(PAGE_SIZE, sysinfo_value("klog.fcolor"));
     65        mapping = as_get_mappable_page(PAGE_SIZE);
    6666        res = ipc_call_sync_3(PHONE_NS, IPC_M_AS_AREA_RECV,
    6767                              (sysarg_t) mapping, PAGE_SIZE, SERVICE_MEM_KLOG,

  • uspace/libc/arch/sparc64/_link.ld.in

    r8d37a06 r2057572  
    88
    99SECTIONS {
    10         . = 0x2000;
     10        . = 0x4000;
    1111
    12         .init ALIGN(0x2000) : SUBALIGN(0x2000) {
     12        .init ALIGN(0x4000) : SUBALIGN(0x4000) {
    1313                *(.init);
    1414        } :text
    … …  
    1818        } :text
    1919       
    20         .got ALIGN(0x2000) : SUBALIGN(0x2000) {
     20        .got ALIGN(0x4000) : SUBALIGN(0x4000) {
    2121                 _gp = .;
    2222                 *(.got*);
    2323        } :data
    24         .data ALIGN(0x2000) : SUBALIGN(0x2000) {
     24        .data ALIGN(0x4000) : SUBALIGN(0x4000) {
    2525                *(.data);
    2626                *(.sdata);
    … …  
    4242        } :data
    4343
    44         . = ALIGN(0x2000);
     44        . = ALIGN(0x4000);
    4545        _heap = .;
    4646       

  • uspace/libc/arch/sparc64/include/config.h

    r8d37a06 r2057572  
    3636#define LIBC_sparc64_CONFIG_H_
    3737
    38 #define PAGE_WIDTH      13
    39 #define PAGE_SIZE       (1<<PAGE_WIDTH)
    40 #define PAGE_COLOR_BITS 1               /**< Bit 13 is the page color. */
     38#define PAGE_WIDTH      14
     39#define PAGE_SIZE       (1 << PAGE_WIDTH)
     40#define PAGE_COLOR_BITS 0               /**< Only one page color. */
    4141
    4242#endif

  • uspace/libc/arch/sparc64/include/stack.h

    r8d37a06 r2057572  
    4444 * 16-extended-word save area for %i[0-7] and %l[0-7] registers.
    4545 */
    46 #define STACK_WINDOW_SAVE_AREA_SIZE     (16*STACK_ITEM_SIZE)
     46#define STACK_WINDOW_SAVE_AREA_SIZE     (16 * STACK_ITEM_SIZE)
    4747
    4848/**

  • uspace/libc/generic/as.c

    r8d37a06 r2057572  
    5656{
    5757        return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t ) address,
    58                 (sysarg_t) size, (sysarg_t) flags);
     58            (sysarg_t) size, (sysarg_t) flags);
    5959}
    6060
    … …  
    7070int as_area_resize(void *address, size_t size, int flags)
    7171{
    72         return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t ) address, (sysarg_t)
    73                 size, (sysarg_t) flags);
     72        return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t ) address,
     73            (sysarg_t) size, (sysarg_t) flags);
    7474}
    7575
    … …  
    144144 *
    145145 * @param sz Requested size of the allocation.
    146  * @param color Requested virtual color of the allocation.
    147146 *
    148147 * @return Pointer to the beginning
    … …  
    151150 *       the pointer to last area
    152151 */
    153 void *as_get_mappable_page(size_t sz, int color)
     152void *as_get_mappable_page(size_t sz)
    154153{
    155154        void *res;
    … …  
    167166       
    168167        /*
    169          * Make sure we allocate from naturally aligned address and a page of
    170          * appropriate color.
     168         * Make sure we allocate from naturally aligned address.
    171169         */
    172170        i = 0;
    173         do {
    174                 if (!last_allocated) {
    175                         last_allocated = (void *) ALIGN_UP((void *) &_heap +
    176                                 maxheapsize, asz);
    177                 } else {
    178                         last_allocated = (void *) ALIGN_UP(((uintptr_t)
    179                                 last_allocated) + (int) (i > 0), asz);
    180                 }
    181         } while ((asz < (1 << (PAGE_COLOR_BITS + PAGE_WIDTH))) &&
    182                 (PAGE_COLOR((uintptr_t) last_allocated) != color) &&
    183                 (++i < (1 << PAGE_COLOR_BITS)));
     171        if (!last_allocated) {
     172                last_allocated = (void *) ALIGN_UP((void *) &_heap +
     173                    maxheapsize, asz);
     174        } else {
     175                last_allocated = (void *) ALIGN_UP(((uintptr_t)
     176                    last_allocated) + (int) (i > 0), asz);
     177        }
    184178
    185179        res = last_allocated;

  • uspace/libc/generic/mman.c

    r8d37a06 r2057572  
    3737#include <unistd.h>
    3838
    39 void *mmap(void  *start, size_t length, int prot, int flags, int fd, off_t offset)
     39void *mmap(void  *start, size_t length, int prot, int flags, int fd,
     40    off_t offset)
    4041{
    4142        if (!start)
    42                 start = as_get_mappable_page(length, 0);
     43                start = as_get_mappable_page(length);
    4344       
    4445//      if (! ((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE)))

  • uspace/libc/generic/time.c

    r8d37a06 r2057572  
    7373
    7474        if (!ktime) {
    75                 mapping = as_get_mappable_page(PAGE_SIZE, (int)
    76                         sysinfo_value("clock.fcolor"));
     75                mapping = as_get_mappable_page(PAGE_SIZE);
    7776                /* Get the mapping of kernel clock */
    78                 res = ipc_call_sync_3(PHONE_NS, IPC_M_AS_AREA_RECV, (sysarg_t)
    79                         mapping, PAGE_SIZE, SERVICE_MEM_REALTIME, NULL, &rights,
    80                         NULL);
     77                res = ipc_call_sync_3(PHONE_NS, IPC_M_AS_AREA_RECV,
     78                    (sysarg_t) mapping, PAGE_SIZE, SERVICE_MEM_REALTIME, NULL,
     79                    &rights, NULL);
    8180                if (res) {
    8281                        printf("Failed to initialize timeofday memarea\n");

  • uspace/libc/include/as.h

    r8d37a06 r2057572  
    4141#include <libarch/config.h>
    4242
    43 #define PAGE_COLOR(va)  (((va) >> PAGE_WIDTH) & ((1 << PAGE_COLOR_BITS) - 1))
    44 
    4543extern void *as_area_create(void *address, size_t size, int flags);
    4644extern int as_area_resize(void *address, size_t size, int flags);
    4745extern int as_area_destroy(void *address);
    4846extern void *set_maxheapsize(size_t mhs);
    49 extern void * as_get_mappable_page(size_t sz, int color);
     47extern void * as_get_mappable_page(size_t sz);
    5048
    5149#endif

  • uspace/ns/ns.c

    r8d37a06 r2057572  
    8484static void *klogaddr = NULL;
    8585
    86 static void get_as_area(ipc_callid_t callid, ipc_call_t *call, char *name, char *colstr, void **addr)
     86static void get_as_area(ipc_callid_t callid, ipc_call_t *call, char *name, void **addr)
    8787{
    8888        void *ph_addr;
    89         int ph_color;
    9089
    9190        if (!*addr) {
    … …  
    9594                        return;
    9695                }
    97                 ph_color = (int) sysinfo_value(colstr);
    98                 *addr = as_get_mappable_page(PAGE_SIZE, ph_color);
     96                *addr = as_get_mappable_page(PAGE_SIZE);
    9997                physmem_map(ph_addr, *addr, 1, AS_AREA_READ | AS_AREA_CACHEABLE);
    10098        }
    … …  
    120118                        case SERVICE_MEM_REALTIME:
    121119                                get_as_area(callid, &call, "clock.faddr",
    122                                         "clock.fcolor", &clockaddr);
     120                                    &clockaddr);
    123121                                break;
    124122                        case SERVICE_MEM_KLOG:
    125123                                get_as_area(callid, &call, "klog.faddr",
    126                                         "klog.fcolor", &klogaddr);
     124                                    &klogaddr);
    127125                                break;
    128126                        default:

  • uspace/rd/rd.c

    r8d37a06 r2057572  
    7474        size_t rd_size = sysinfo_value("rd.size");
    7575        void * rd_ph_addr = (void *) sysinfo_value("rd.address.physical");
    76         int rd_color = (int) sysinfo_value("rd.address.color");
    7776       
    7877        if (rd_size == 0)
    7978                return false;
    8079       
    81         void * rd_addr = as_get_mappable_page(rd_size, rd_color);
     80        void * rd_addr = as_get_mappable_page(rd_size);
    8281       
    8382        physmem_map(rd_ph_addr, rd_addr, ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
Note: See TracChangeset for help on using the changeset viewer.