Subversion Repositories HelenOS

Rev

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

Rev 2787 Rev 3011
Line 77... Line 77...
77
int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
77
int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
78
{
78
{
79
    elf_header_t *elf = area->backend_data.elf;
79
    elf_header_t *elf = area->backend_data.elf;
80
    elf_segment_header_t *entry = area->backend_data.segment;
80
    elf_segment_header_t *entry = area->backend_data.segment;
81
    btree_node_t *leaf;
81
    btree_node_t *leaf;
82
    uintptr_t base, frame;
82
    uintptr_t base, frame, page, start_anon;
83
    index_t i;
83
    index_t i;
84
    bool dirty = false;
84
    bool dirty = false;
85
 
85
 
86
    if (!as_area_check_access(area, access))
86
    if (!as_area_check_access(area, access))
87
        return AS_PF_FAULT;
87
        return AS_PF_FAULT;
88
 
88
 
89
    ASSERT((addr >= entry->p_vaddr) &&
89
    ASSERT((addr >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) &&
90
        (addr < entry->p_vaddr + entry->p_memsz));
90
        (addr < entry->p_vaddr + entry->p_memsz));
91
    i = (addr - entry->p_vaddr) >> PAGE_WIDTH;
91
    i = (addr - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
-
 
92
    base = (uintptr_t)
92
    base = (uintptr_t) (((void *) elf) + entry->p_offset);
93
        (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
-
 
94
 
-
 
95
    /* Virtual address of faulting page*/
93
    ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
96
    page = ALIGN_DOWN(addr, PAGE_SIZE);
-
 
97
 
-
 
98
    /* Virtual address of the end of initialized part of segment */
-
 
99
    start_anon = entry->p_vaddr + entry->p_filesz;
94
 
100
 
95
    if (area->sh_info) {
101
    if (area->sh_info) {
96
        bool found = false;
102
        bool found = false;
97
 
103
 
98
        /*
104
        /*
99
         * The address space area is shared.
105
         * The address space area is shared.
100
         */
106
         */
101
         
107
       
102
        mutex_lock(&area->sh_info->lock);
108
        mutex_lock(&area->sh_info->lock);
103
        frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
109
        frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
104
            ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
110
            page - area->base, &leaf);
105
        if (!frame) {
111
        if (!frame) {
106
            unsigned int i;
112
            unsigned int i;
107
 
113
 
108
            /*
114
            /*
109
             * Workaround for valid NULL address.
115
             * Workaround for valid NULL address.
110
             */
116
             */
111
 
117
 
112
            for (i = 0; i < leaf->keys; i++) {
118
            for (i = 0; i < leaf->keys; i++) {
113
                if (leaf->key[i] ==
119
                if (leaf->key[i] == page) {
114
                    ALIGN_DOWN(addr, PAGE_SIZE)) {
-
 
115
                    found = true;
120
                    found = true;
116
                    break;
121
                    break;
117
                }
122
                }
118
            }
123
            }
119
        }
124
        }
120
        if (frame || found) {
125
        if (frame || found) {
121
            frame_reference_add(ADDR2PFN(frame));
126
            frame_reference_add(ADDR2PFN(frame));
122
            page_mapping_insert(AS, addr, frame,
127
            page_mapping_insert(AS, addr, frame,
123
                as_area_get_flags(area));
128
                as_area_get_flags(area));
124
            if (!used_space_insert(area,
129
            if (!used_space_insert(area, page, 1))
125
                ALIGN_DOWN(addr, PAGE_SIZE), 1))
-
 
126
                panic("Could not insert used space.\n");
130
                panic("Could not insert used space.\n");
127
            mutex_unlock(&area->sh_info->lock);
131
            mutex_unlock(&area->sh_info->lock);
128
            return AS_PF_OK;
132
            return AS_PF_OK;
129
        }
133
        }
130
    }
134
    }
131
   
135
 
132
    /*
136
    /*
133
     * The area is either not shared or the pagemap does not contain the
137
     * The area is either not shared or the pagemap does not contain the
134
     * mapping.
138
     * mapping.
135
     */
139
     */
136
   
-
 
137
    if (ALIGN_DOWN(addr, PAGE_SIZE) + PAGE_SIZE <
-
 
138
        entry->p_vaddr + entry->p_filesz) {
140
    if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
139
        /*
141
        /*
140
         * Initialized portion of the segment. The memory is backed
142
         * Initialized portion of the segment. The memory is backed
141
         * directly by the content of the ELF image. Pages are
143
         * directly by the content of the ELF image. Pages are
142
         * only copied if the segment is writable so that there
144
         * only copied if the segment is writable so that there
143
         * can be more instantions of the same memory ELF image
145
         * can be more instantions of the same memory ELF image
Line 147... Line 149...
147
        if (entry->p_flags & PF_W) {
149
        if (entry->p_flags & PF_W) {
148
            frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
150
            frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
149
            memcpy((void *) PA2KA(frame),
151
            memcpy((void *) PA2KA(frame),
150
                (void *) (base + i * FRAME_SIZE), FRAME_SIZE);
152
                (void *) (base + i * FRAME_SIZE), FRAME_SIZE);
151
            dirty = true;
153
            dirty = true;
152
 
-
 
153
            if (area->sh_info) {
-
 
154
                frame_reference_add(ADDR2PFN(frame));
-
 
155
                btree_insert(&area->sh_info->pagemap,
-
 
156
                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
-
 
157
                    (void *) frame, leaf);
-
 
158
            }
-
 
159
 
-
 
160
        } else {
154
        } else {
161
            frame = KA2PA(base + i*FRAME_SIZE);
155
            frame = KA2PA(base + i * FRAME_SIZE);
162
        }  
156
        }  
163
    } else if (ALIGN_DOWN(addr, PAGE_SIZE) >=
157
    } else if (page >= start_anon) {
164
        ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
-
 
165
        /*
158
        /*
166
         * This is the uninitialized portion of the segment.
159
         * This is the uninitialized portion of the segment.
167
         * It is not physically present in the ELF image.
160
         * It is not physically present in the ELF image.
168
         * To resolve the situation, a frame must be allocated
161
         * To resolve the situation, a frame must be allocated
169
         * and cleared.
162
         * and cleared.
170
         */
163
         */
171
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
164
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
172
        memsetb(PA2KA(frame), FRAME_SIZE, 0);
165
        memsetb(PA2KA(frame), FRAME_SIZE, 0);
173
        dirty = true;
166
        dirty = true;
174
 
-
 
175
        if (area->sh_info) {
-
 
176
            frame_reference_add(ADDR2PFN(frame));
-
 
177
            btree_insert(&area->sh_info->pagemap,
-
 
178
                ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
-
 
179
                (void *) frame, leaf);
-
 
180
        }
-
 
181
 
-
 
182
    } else {
167
    } else {
183
        size_t size;
168
        size_t pad_lo, pad_hi;
184
        /*
169
        /*
185
         * The mixed case.
170
         * The mixed case.
-
 
171
         *
186
         * The lower part is backed by the ELF image and
172
         * The middle part is backed by the ELF image and
187
         * the upper part is anonymous memory.
173
         * the lower and upper parts are anonymous memory.
-
 
174
         * (The segment can be and often is shorter than 1 page).
188
         */
175
         */
-
 
176
        if (page < entry->p_vaddr)
189
        size = entry->p_filesz - (i<<PAGE_WIDTH);
177
            pad_lo = entry->p_vaddr - page;
-
 
178
        else
-
 
179
            pad_lo = 0;
-
 
180
 
-
 
181
        if (start_anon < page + PAGE_SIZE)
-
 
182
            pad_hi = page + PAGE_SIZE - start_anon;
-
 
183
        else
-
 
184
            pad_hi = 0;
-
 
185
 
190
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
186
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
191
        memsetb(PA2KA(frame) + size, FRAME_SIZE - size, 0);
187
        memcpy((void *) (PA2KA(frame) + pad_lo),
192
        memcpy((void *) PA2KA(frame), (void *) (base + i * FRAME_SIZE),
188
            (void *) (base + i * FRAME_SIZE + pad_lo),
193
            size);
189
            FRAME_SIZE - pad_lo - pad_hi);
-
 
190
        memsetb(PA2KA(frame), pad_lo, 0);
-
 
191
        memsetb(PA2KA(frame) + FRAME_SIZE - pad_hi, pad_hi, 0);
194
        dirty = true;
192
        dirty = true;
-
 
193
    }
195
 
194
 
196
        if (area->sh_info) {
195
    if (dirty && area->sh_info) {
197
            frame_reference_add(ADDR2PFN(frame));
196
        frame_reference_add(ADDR2PFN(frame));
198
            btree_insert(&area->sh_info->pagemap,
197
        btree_insert(&area->sh_info->pagemap, page - area->base,
199
                ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
-
 
200
                (void *) frame, leaf);
198
            (void *) frame, leaf);
201
        }
-
 
202
 
-
 
203
    }
199
    }
204
   
200
 
205
    if (area->sh_info)
201
    if (area->sh_info)
206
        mutex_unlock(&area->sh_info->lock);
202
        mutex_unlock(&area->sh_info->lock);
207
   
203
 
208
    page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
204
    page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
209
    if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
205
    if (!used_space_insert(area, page, 1))
210
        panic("Could not insert used space.\n");
206
        panic("Could not insert used space.\n");
211
 
207
 
212
    return AS_PF_OK;
208
    return AS_PF_OK;
213
}
209
}
214
 
210
 
Line 223... Line 219...
223
 */
219
 */
224
void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
220
void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
225
{
221
{
226
    elf_header_t *elf = area->backend_data.elf;
222
    elf_header_t *elf = area->backend_data.elf;
227
    elf_segment_header_t *entry = area->backend_data.segment;
223
    elf_segment_header_t *entry = area->backend_data.segment;
228
    uintptr_t base;
224
    uintptr_t base, start_anon;
229
    index_t i;
225
    index_t i;
230
   
226
 
231
    ASSERT((page >= entry->p_vaddr) &&
227
    ASSERT((page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) &&
232
        (page < entry->p_vaddr + entry->p_memsz));
228
        (page < entry->p_vaddr + entry->p_memsz));
233
    i = (page - entry->p_vaddr) >> PAGE_WIDTH;
229
    i = (page - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
234
    base = (uintptr_t) (((void *) elf) + entry->p_offset);
230
    base = (uintptr_t) (((void *) elf) +
235
    ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
231
        ALIGN_DOWN(entry->p_offset, FRAME_SIZE));
-
 
232
    start_anon = entry->p_vaddr + entry->p_filesz;
236
   
233
 
237
    if (page + PAGE_SIZE <
-
 
238
        ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
234
    if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
239
        if (entry->p_flags & PF_W) {
235
        if (entry->p_flags & PF_W) {
240
            /*
236
            /*
241
             * Free the frame with the copy of writable segment
237
             * Free the frame with the copy of writable segment
242
             * data.
238
             * data.
243
             */
239
             */
Line 302... Line 298...
302
            /*
298
            /*
303
             * Skip read-only areas of used space that are backed
299
             * Skip read-only areas of used space that are backed
304
             * by the ELF image.
300
             * by the ELF image.
305
             */
301
             */
306
            if (!(area->flags & AS_AREA_WRITE))
302
            if (!(area->flags & AS_AREA_WRITE))
-
 
303
                if (base >= entry->p_vaddr &&
307
                if (base + count * PAGE_SIZE <= start_anon)
304
                    base + count * PAGE_SIZE <= start_anon)
308
                    continue;
305
                    continue;
309
           
306
           
310
            for (j = 0; j < count; j++) {
307
            for (j = 0; j < count; j++) {
311
                pte_t *pte;
308
                pte_t *pte;
312
           
309
           
313
                /*
310
                /*
314
                 * Skip read-only pages that are backed by the
311
                 * Skip read-only pages that are backed by the
315
                 * ELF image.
312
                 * ELF image.
316
                 */
313
                 */
317
                if (!(area->flags & AS_AREA_WRITE))
314
                if (!(area->flags & AS_AREA_WRITE))
-
 
315
                    if (base >= entry->p_vaddr &&
318
                    if (base + (j + 1) * PAGE_SIZE <=
316
                        base + (j + 1) * PAGE_SIZE <=
319
                        start_anon)
317
                        start_anon)
320
                        continue;
318
                        continue;
321
               
319
               
322
                page_table_lock(area->as, false);
320
                page_table_lock(area->as, false);
323
                pte = page_mapping_find(area->as,
321
                pte = page_mapping_find(area->as,