Subversion Repositories HelenOS

Rev

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

Rev 2089 Rev 2132
Line 69... Line 69...
69
 *
69
 *
70
 * @param area Pointer to the address space area.
70
 * @param area Pointer to the address space area.
71
 * @param addr Faulting virtual address.
71
 * @param addr Faulting virtual address.
72
 * @param access Access mode that caused the fault (i.e. read/write/exec).
72
 * @param access Access mode that caused the fault (i.e. read/write/exec).
73
 *
73
 *
74
 * @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e. serviced).
74
 * @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e.
-
 
75
 *     serviced).
75
 */
76
 */
76
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)
77
{
78
{
78
    elf_header_t *elf = area->backend_data.elf;
79
    elf_header_t *elf = area->backend_data.elf;
79
    elf_segment_header_t *entry = area->backend_data.segment;
80
    elf_segment_header_t *entry = area->backend_data.segment;
Line 82... Line 83...
82
    index_t i;
83
    index_t i;
83
 
84
 
84
    if (!as_area_check_access(area, access))
85
    if (!as_area_check_access(area, access))
85
        return AS_PF_FAULT;
86
        return AS_PF_FAULT;
86
 
87
 
-
 
88
    ASSERT((addr >= entry->p_vaddr) &&
87
    ASSERT((addr >= entry->p_vaddr) && (addr < entry->p_vaddr + entry->p_memsz));
89
        (addr < entry->p_vaddr + entry->p_memsz));
88
    i = (addr - entry->p_vaddr) >> PAGE_WIDTH;
90
    i = (addr - entry->p_vaddr) >> PAGE_WIDTH;
89
    base = (uintptr_t) (((void *) elf) + entry->p_offset);
91
    base = (uintptr_t) (((void *) elf) + entry->p_offset);
90
    ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
92
    ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
91
 
93
 
92
    if (area->sh_info) {
94
    if (area->sh_info) {
Line 105... Line 107...
105
            /*
107
            /*
106
             * Workaround for valid NULL address.
108
             * Workaround for valid NULL address.
107
             */
109
             */
108
 
110
 
109
            for (i = 0; i < leaf->keys; i++) {
111
            for (i = 0; i < leaf->keys; i++) {
-
 
112
                if (leaf->key[i] ==
110
                if (leaf->key[i] == ALIGN_DOWN(addr, PAGE_SIZE)) {
113
                    ALIGN_DOWN(addr, PAGE_SIZE)) {
111
                    found = true;
114
                    found = true;
112
                    break;
115
                    break;
113
                }
116
                }
114
            }
117
            }
115
        }
118
        }
116
        if (frame || found) {
119
        if (frame || found) {
117
            frame_reference_add(ADDR2PFN(frame));
120
            frame_reference_add(ADDR2PFN(frame));
118
            page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
121
            page_mapping_insert(AS, addr, frame,
-
 
122
                as_area_get_flags(area));
-
 
123
            if (!used_space_insert(area,
119
            if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
124
                ALIGN_DOWN(addr, PAGE_SIZE), 1))
120
                panic("Could not insert used space.\n");
125
                panic("Could not insert used space.\n");
121
            mutex_unlock(&area->sh_info->lock);
126
            mutex_unlock(&area->sh_info->lock);
122
            return AS_PF_OK;
127
            return AS_PF_OK;
123
        }
128
        }
124
    }
129
    }
125
   
130
   
126
    /*
131
    /*
127
     * The area is either not shared or the pagemap does not contain the mapping.
132
     * The area is either not shared or the pagemap does not contain the
-
 
133
     * mapping.
128
     */
134
     */
129
   
135
   
130
    if (ALIGN_DOWN(addr, PAGE_SIZE) + PAGE_SIZE < entry->p_vaddr + entry->p_filesz) {
136
    if (ALIGN_DOWN(addr, PAGE_SIZE) + PAGE_SIZE <
-
 
137
        entry->p_vaddr + entry->p_filesz) {
131
        /*
138
        /*
132
         * Initialized portion of the segment. The memory is backed
139
         * Initialized portion of the segment. The memory is backed
133
         * directly by the content of the ELF image. Pages are
140
         * directly by the content of the ELF image. Pages are
134
         * only copied if the segment is writable so that there
141
         * only copied if the segment is writable so that there
135
         * can be more instantions of the same memory ELF image
142
         * can be more instantions of the same memory ELF image
136
         * used at a time. Note that this could be later done
143
         * used at a time. Note that this could be later done
137
         * as COW.
144
         * as COW.
138
         */
145
         */
139
        if (entry->p_flags & PF_W) {
146
        if (entry->p_flags & PF_W) {
140
            frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
147
            frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
-
 
148
            memcpy((void *) PA2KA(frame),
141
            memcpy((void *) PA2KA(frame), (void *) (base + i*FRAME_SIZE), FRAME_SIZE);
149
                (void *) (base + i * FRAME_SIZE), FRAME_SIZE);
142
           
150
           
143
            if (area->sh_info) {
151
            if (area->sh_info) {
144
                frame_reference_add(ADDR2PFN(frame));
152
                frame_reference_add(ADDR2PFN(frame));
-
 
153
                btree_insert(&area->sh_info->pagemap,
145
                btree_insert(&area->sh_info->pagemap, ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
154
                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
146
                    (void *) frame, leaf);
155
                    (void *) frame, leaf);
147
            }
156
            }
148
 
157
 
149
        } else {
158
        } else {
150
            frame = KA2PA(base + i*FRAME_SIZE);
159
            frame = KA2PA(base + i*FRAME_SIZE);
151
        }  
160
        }  
-
 
161
    } else if (ALIGN_DOWN(addr, PAGE_SIZE) >=
152
    } else if (ALIGN_DOWN(addr, PAGE_SIZE) >= ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
162
        ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
153
        /*
163
        /*
154
         * This is the uninitialized portion of the segment.
164
         * This is the uninitialized portion of the segment.
155
         * It is not physically present in the ELF image.
165
         * It is not physically present in the ELF image.
156
         * To resolve the situation, a frame must be allocated
166
         * To resolve the situation, a frame must be allocated
157
         * and cleared.
167
         * and cleared.
Line 159... Line 169...
159
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
169
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
160
        memsetb(PA2KA(frame), FRAME_SIZE, 0);
170
        memsetb(PA2KA(frame), FRAME_SIZE, 0);
161
 
171
 
162
        if (area->sh_info) {
172
        if (area->sh_info) {
163
            frame_reference_add(ADDR2PFN(frame));
173
            frame_reference_add(ADDR2PFN(frame));
-
 
174
            btree_insert(&area->sh_info->pagemap,
164
            btree_insert(&area->sh_info->pagemap, ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
175
                ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
165
                (void *) frame, leaf);
176
                (void *) frame, leaf);
166
        }
177
        }
167
 
178
 
168
    } else {
179
    } else {
169
        size_t size;
180
        size_t size;
170
        /*
181
        /*
Line 173... Line 184...
173
         * the upper part is anonymous memory.
184
         * the upper part is anonymous memory.
174
         */
185
         */
175
        size = entry->p_filesz - (i<<PAGE_WIDTH);
186
        size = entry->p_filesz - (i<<PAGE_WIDTH);
176
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
187
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
177
        memsetb(PA2KA(frame) + size, FRAME_SIZE - size, 0);
188
        memsetb(PA2KA(frame) + size, FRAME_SIZE - size, 0);
178
        memcpy((void *) PA2KA(frame), (void *) (base + i*FRAME_SIZE), size);
189
        memcpy((void *) PA2KA(frame), (void *) (base + i * FRAME_SIZE),
-
 
190
            size);
179
 
191
 
180
        if (area->sh_info) {
192
        if (area->sh_info) {
181
            frame_reference_add(ADDR2PFN(frame));
193
            frame_reference_add(ADDR2PFN(frame));
-
 
194
            btree_insert(&area->sh_info->pagemap,
182
            btree_insert(&area->sh_info->pagemap, ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
195
                ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
183
                (void *) frame, leaf);
196
                (void *) frame, leaf);
184
        }
197
        }
185
 
198
 
186
    }
199
    }
187
   
200
   
188
    if (area->sh_info)
201
    if (area->sh_info)
Line 209... Line 222...
209
    elf_header_t *elf = area->backend_data.elf;
222
    elf_header_t *elf = area->backend_data.elf;
210
    elf_segment_header_t *entry = area->backend_data.segment;
223
    elf_segment_header_t *entry = area->backend_data.segment;
211
    uintptr_t base;
224
    uintptr_t base;
212
    index_t i;
225
    index_t i;
213
   
226
   
-
 
227
    ASSERT((page >= entry->p_vaddr) &&
214
    ASSERT((page >= entry->p_vaddr) && (page < entry->p_vaddr + entry->p_memsz));
228
        (page < entry->p_vaddr + entry->p_memsz));
215
    i = (page - entry->p_vaddr) >> PAGE_WIDTH;
229
    i = (page - entry->p_vaddr) >> PAGE_WIDTH;
216
    base = (uintptr_t) (((void *) elf) + entry->p_offset);
230
    base = (uintptr_t) (((void *) elf) + entry->p_offset);
217
    ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
231
    ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
218
   
232
   
-
 
233
    if (page + PAGE_SIZE <
219
    if (page + PAGE_SIZE < ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
234
        ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
220
        if (entry->p_flags & PF_W) {
235
        if (entry->p_flags & PF_W) {
221
            /*
236
            /*
222
             * Free the frame with the copy of writable segment data.
237
             * Free the frame with the copy of writable segment
-
 
238
             * data.
223
             */
239
             */
224
            frame_free(frame);
240
            frame_free(frame);
225
#ifdef CONFIG_VIRT_IDX_DCACHE
241
#ifdef CONFIG_VIRT_IDX_DCACHE
226
                dcache_flush_frame(page, frame);
242
                dcache_flush_frame(page, frame);
227
#endif
243
#endif
228
        }
244
        }
229
    } else {
245
    } else {
230
        /*
246
        /*
231
         * The frame is either anonymous memory or the mixed case (i.e. lower
247
         * The frame is either anonymous memory or the mixed case (i.e.
232
         * part is backed by the ELF image and the upper is anonymous).
248
         * lower part is backed by the ELF image and the upper is
233
         * In any case, a frame needs to be freed.
249
         * anonymous). In any case, a frame needs to be freed.
234
         */
250
         */
235
        frame_free(frame);
251
        frame_free(frame);
236
#ifdef CONFIG_VIRT_IDX_DCACHE
252
#ifdef CONFIG_VIRT_IDX_DCACHE
237
            dcache_flush_frame(page, frame);
253
            dcache_flush_frame(page, frame);
238
#endif
254
#endif
Line 258... Line 274...
258
 
274
 
259
    /*
275
    /*
260
     * Find the node in which to start linear search.
276
     * Find the node in which to start linear search.
261
     */
277
     */
262
    if (area->flags & AS_AREA_WRITE) {
278
    if (area->flags & AS_AREA_WRITE) {
263
        node = list_get_instance(area->used_space.leaf_head.next, btree_node_t, leaf_link);
279
        node = list_get_instance(area->used_space.leaf_head.next,
-
 
280
            btree_node_t, leaf_link);
264
    } else {
281
    } else {
265
        (void) btree_search(&area->sh_info->pagemap, start_anon, &leaf);
282
        (void) btree_search(&area->sh_info->pagemap, start_anon, &leaf);
266
        node = btree_leaf_node_left_neighbour(&area->sh_info->pagemap, leaf);
283
        node = btree_leaf_node_left_neighbour(&area->sh_info->pagemap,
-
 
284
            leaf);
267
        if (!node)
285
        if (!node)
268
            node = leaf;
286
            node = leaf;
269
    }
287
    }
270
 
288
 
271
    /*
289
    /*
272
     * Copy used anonymous portions of the area to sh_info's page map.
290
     * Copy used anonymous portions of the area to sh_info's page map.
273
     */
291
     */
274
    mutex_lock(&area->sh_info->lock);
292
    mutex_lock(&area->sh_info->lock);
275
    for (cur = &node->leaf_link; cur != &area->used_space.leaf_head; cur = cur->next) {
293
    for (cur = &node->leaf_link; cur != &area->used_space.leaf_head;
-
 
294
        cur = cur->next) {
276
        int i;
295
        int i;
277
       
296
       
278
        node = list_get_instance(cur, btree_node_t, leaf_link);
297
        node = list_get_instance(cur, btree_node_t, leaf_link);
279
       
298
       
280
        for (i = 0; i < node->keys; i++) {
299
        for (i = 0; i < node->keys; i++) {
Line 292... Line 311...
292
           
311
           
293
            for (j = 0; j < count; j++) {
312
            for (j = 0; j < count; j++) {
294
                pte_t *pte;
313
                pte_t *pte;
295
           
314
           
296
                /*
315
                /*
297
                 * Skip read-only pages that are backed by the ELF image.
316
                 * Skip read-only pages that are backed by the
-
 
317
                 * ELF image.
298
                 */
318
                 */
299
                if (!(area->flags & AS_AREA_WRITE))
319
                if (!(area->flags & AS_AREA_WRITE))
300
                    if (base + (j + 1)*PAGE_SIZE <= start_anon)
320
                    if (base + (j + 1) * PAGE_SIZE <=
-
 
321
                        start_anon)
301
                        continue;
322
                        continue;
302
               
323
               
303
                page_table_lock(area->as, false);
324
                page_table_lock(area->as, false);
304
                pte = page_mapping_find(area->as, base + j*PAGE_SIZE);
325
                pte = page_mapping_find(area->as,
-
 
326
                    base + j * PAGE_SIZE);
305
                ASSERT(pte && PTE_VALID(pte) && PTE_PRESENT(pte));
327
                ASSERT(pte && PTE_VALID(pte) &&
-
 
328
                    PTE_PRESENT(pte));
306
                btree_insert(&area->sh_info->pagemap, (base + j*PAGE_SIZE) - area->base,
329
                btree_insert(&area->sh_info->pagemap,
-
 
330
                    (base + j * PAGE_SIZE) - area->base,
307
                    (void *) PTE_GET_FRAME(pte), NULL);
331
                    (void *) PTE_GET_FRAME(pte), NULL);
308
                page_table_unlock(area->as, false);
332
                page_table_unlock(area->as, false);
-
 
333
 
309
                frame_reference_add(ADDR2PFN(PTE_GET_FRAME(pte)));
334
                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
-
 
335
                frame_reference_add(pfn);
310
            }
336
            }
311
               
337
               
312
        }
338
        }
313
    }
339
    }
314
    mutex_unlock(&area->sh_info->lock);
340
    mutex_unlock(&area->sh_info->lock);
315
}
341
}
316
 
342
 
317
/** @}
343
/** @}
318
 */
344
 */
-
 
345