Subversion Repositories HelenOS

Rev

Rev 2131 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2131 Rev 2292
Line 32... Line 32...
32 
/** @file
 32 
/** @file
33 
 */
 33 
 */
34 
 
 34 
 
35 
#include <arch/mm/tsb.h>
 35 
#include <arch/mm/tsb.h>
36 
#include <arch/mm/tlb.h>
 36 
#include <arch/mm/tlb.h>
- 
 
 37 
#include <arch/mm/page.h>
37 
#include <arch/barrier.h>
 38 
#include <arch/barrier.h>
38 
#include <mm/as.h>
 39 
#include <mm/as.h>
39 
#include <arch/types.h>
 40 
#include <arch/types.h>
40 
#include <macros.h>
 41 
#include <macros.h>
41 
#include <debug.h>
 42 
#include <debug.h>
42 
 
 43 
 
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)
44 
 
 45 
 
45 
/** Invalidate portion of TSB.
 46 
/** Invalidate portion of TSB.
46 
 *
 47 
 *
47 
 * We assume that the address space is already locked. Note that respective
 48 
 * We assume that the address space is already locked. Note that respective
48 
 * portions of both TSBs are invalidated at a time.
 49 
 * portions of both TSBs are invalidated at a time.
Line 57... Line 58...
57 
    index_t i0, i;
 58 
    index_t i0, i;
58 
    count_t cnt;
 59 
    count_t cnt;
59 
   
 60 
   
60 
    ASSERT(as->arch.itsb && as->arch.dtsb);
 61 
    ASSERT(as->arch.itsb && as->arch.dtsb);
61 
   
 62 
   
62 
    i0 = (page >> PAGE_WIDTH) & TSB_INDEX_MASK;
 63 
    i0 = (page >> MMU_PAGE_WIDTH) & TSB_INDEX_MASK;
- 
 
 64 
    if (pages == (count_t) -1 || (pages * 2) > ITSB_ENTRY_COUNT)
63 
    cnt = min(pages, ITSB_ENTRY_COUNT);
 65 
        cnt = ITSB_ENTRY_COUNT;
- 
 
 66 
    else
- 
 
 67 
        cnt = pages * 2;
64 
   
 68 
   
65 
    for (i = 0; i < cnt; i++) {
 69 
    for (i = 0; i < cnt; i++) {
66 
        as->arch.itsb[(i0 + i) & (ITSB_ENTRY_COUNT - 1)].tag.invalid =
 70 
        as->arch.itsb[(i0 + i) & (ITSB_ENTRY_COUNT - 1)].tag.invalid =
67 
            true;
 71 
            true;
68 
        as->arch.dtsb[(i0 + i) & (DTSB_ENTRY_COUNT - 1)].tag.invalid =
 72 
        as->arch.dtsb[(i0 + i) & (DTSB_ENTRY_COUNT - 1)].tag.invalid =
69 
            true;
 73 
            true;
70 
    }
 74 
    }
71 
}
 75 
}
72 
 
 76 
 
73 
/** Copy software PTE to ITSB.
 77 
/** Copy software PTE to ITSB.
74 
 *
 78 
 *
75 
 * @param t Software PTE.
 79 
 * @param t     Software PTE.
- 
 
 80 
 * @param index Zero if lower 8K-subpage, one if higher 8K subpage.
76 
 */
 81 
 */
77 
void itsb_pte_copy(pte_t *t)
 82 
void itsb_pte_copy(pte_t *t, index_t index)
78 
{
 83 
{
79 
    as_t *as;
 84 
    as_t *as;
80 
    tsb_entry_t *tsb;
 85 
    tsb_entry_t *tsb;
- 
 
 86 
    index_t entry;
81 
   
 87 
   
82 
    as = t->as;
 88 
    as = t->as;
83 
    tsb = &as->arch.itsb[(t->page >> PAGE_WIDTH) & TSB_INDEX_MASK];
 89 
    entry = ((t->page >> MMU_PAGE_WIDTH) + index) & TSB_INDEX_MASK;
- 
 
 90 
    tsb = &as->arch.itsb[entry];
84 
 
 91 
 
85 
    /*
 92 
    /*
86 
     * We use write barriers to make sure that the TSB load
 93 
     * We use write barriers to make sure that the TSB load
87 
     * won't use inconsistent data or that the fault will
 94 
     * won't use inconsistent data or that the fault will
88 
     * be repeated.
 95 
     * be repeated.
Line 93... Line 100...
93 
                     * set to 0) */
 100 
                     * set to 0) */
94 
 
 101 
 
95 
    write_barrier();
 102 
    write_barrier();
96 
 
 103 
 
97 
    tsb->tag.context = as->asid;
 104 
    tsb->tag.context = as->asid;
98 
    tsb->tag.va_tag = t->page >> VA_TAG_PAGE_SHIFT;
 105 
    tsb->tag.va_tag = (t->page + (index << MMU_PAGE_WIDTH)) >>
- 
 
 106 
        VA_TAG_PAGE_SHIFT;
99 
    tsb->data.value = 0;
 107 
    tsb->data.value = 0;
100 
    tsb->data.size = PAGESIZE_8K;
 108 
    tsb->data.size = PAGESIZE_8K;
101 
    tsb->data.pfn = t->frame >> FRAME_WIDTH;
 109 
    tsb->data.pfn = (t->frame >> MMU_FRAME_WIDTH) + index;
102 
    tsb->data.cp = t->c;
 110 
    tsb->data.cp = t->c;
103 
    tsb->data.p = t->k;     /* p as privileged */
 111 
    tsb->data.p = t->k;     /* p as privileged */
104 
    tsb->data.v = t->p;
 112 
    tsb->data.v = t->p;
105 
   
 113 
   
106 
    write_barrier();
 114 
    write_barrier();
Line 108... Line 116...
108 
    tsb->tag.invalid = false;   /* mark the entry as valid */
 116 
    tsb->tag.invalid = false;   /* mark the entry as valid */
109 
}
 117 
}
110 
 
 118 
 
111 
/** Copy software PTE to DTSB.
 119 
/** Copy software PTE to DTSB.
112 
 *
 120 
 *
113 
 * @param t Software PTE.
 121 
 * @param t Software PTE.
- 
 
 122 
 * @param index Zero if lower 8K-subpage, one if higher 8K-subpage.
114 
 * @param ro If true, the mapping is copied read-only.
 123 
 * @param ro    If true, the mapping is copied read-only.
115 
 */
 124 
 */
116 
void dtsb_pte_copy(pte_t *t, bool ro)
 125 
void dtsb_pte_copy(pte_t *t, index_t index, bool ro)
117 
{
 126 
{
118 
    as_t *as;
 127 
    as_t *as;
119 
    tsb_entry_t *tsb;
 128 
    tsb_entry_t *tsb;
- 
 
 129 
    index_t entry;
120 
   
 130 
   
121 
    as = t->as;
 131 
    as = t->as;
122 
    tsb = &as->arch.dtsb[(t->page >> PAGE_WIDTH) & TSB_INDEX_MASK];
 132 
    entry = ((t->page >> MMU_PAGE_WIDTH) + index) & TSB_INDEX_MASK;
- 
 
 133 
    tsb = &as->arch.dtsb[entry];
123 
 
 134 
 
124 
    /*
 135 
    /*
125 
     * We use write barriers to make sure that the TSB load
 136 
     * We use write barriers to make sure that the TSB load
126 
     * won't use inconsistent data or that the fault will
 137 
     * won't use inconsistent data or that the fault will
127 
     * be repeated.
 138 
     * be repeated.
Line 132... Line 143...
132 
                     * set to 0) */
 143 
                     * set to 0) */
133 
 
 144 
 
134 
    write_barrier();
 145 
    write_barrier();
135 
 
 146 
 
136 
    tsb->tag.context = as->asid;
 147 
    tsb->tag.context = as->asid;
137 
    tsb->tag.va_tag = t->page >> VA_TAG_PAGE_SHIFT;
 148 
    tsb->tag.va_tag = (t->page + (index << MMU_PAGE_WIDTH)) >>
- 
 
 149 
        VA_TAG_PAGE_SHIFT;
138 
    tsb->data.value = 0;
 150 
    tsb->data.value = 0;
139 
    tsb->data.size = PAGESIZE_8K;
 151 
    tsb->data.size = PAGESIZE_8K;
140 
    tsb->data.pfn = t->frame >> FRAME_WIDTH;
 152 
    tsb->data.pfn = (t->frame >> MMU_FRAME_WIDTH) + index;
141 
    tsb->data.cp = t->c;
 153 
    tsb->data.cp = t->c;
142 
#ifdef CONFIG_VIRT_IDX_DCACHE
 154 
#ifdef CONFIG_VIRT_IDX_DCACHE
143 
    tsb->data.cv = t->c;
 155 
    tsb->data.cv = t->c;
144 
#endif /* CONFIG_VIRT_IDX_DCACHE */
 156 
#endif /* CONFIG_VIRT_IDX_DCACHE */
145 
    tsb->data.p = t->k;     /* p as privileged */
 157 
    tsb->data.p = t->k;     /* p as privileged */
146 
    tsb->data.w = ro ? false : t->w;
 158 
    tsb->data.w = ro ? false : t->w;
147 
    tsb->data.v = t->p;
 159 
    tsb->data.v = t->p;
148 
   
 160 
   
149 
    write_barrier();
 161 
    write_barrier();
150 
   
 162 
   
151 
    tsb->tag.invalid = true;    /* mark the entry as valid */
 163 
    tsb->tag.invalid = false;   /* mark the entry as valid */
152 
}
 164 
}
153 
 
 165 
 
154 
/** @}
 166 
/** @}
155 
 */
 167 
 */