Subversion Repositories HelenOS

Rev

Rev 3397 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1424 jermar 1
/*
2071 jermar 2
 * Copyright (c) 2006 Jakub Jermar
1424 jermar 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
1757 jermar 29
/** @addtogroup genericmm
1702 cejka 30
 * @{
31
 */
32
 
1424 jermar 33
/**
1702 cejka 34
 * @file
1424 jermar 35
 * @brief   Backend for address space areas backed by an ELF image.
36
 */
37
 
2000 decky 38
#include <lib/elf.h>
1424 jermar 39
#include <debug.h>
3862 rimsky 40
#include <arch/asm.h>
1424 jermar 41
#include <arch/types.h>
42
#include <mm/as.h>
43
#include <mm/frame.h>
44
#include <mm/slab.h>
1426 jermar 45
#include <mm/page.h>
46
#include <genarch/mm/page_pt.h>
47
#include <genarch/mm/page_ht.h>
1424 jermar 48
#include <align.h>
49
#include <memstr.h>
50
#include <macros.h>
51
#include <arch.h>
3141 jermar 52
#include <arch/barrier.h>
1424 jermar 53
 
2076 jermar 54
#ifdef CONFIG_VIRT_IDX_DCACHE
55
#include <arch/mm/cache.h>
56
#endif
57
 
1780 jermar 58
static int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
59
static void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame);
1426 jermar 60
static void elf_share(as_area_t *area);
1424 jermar 61
 
62
mem_backend_t elf_backend = {
63
    .page_fault = elf_page_fault,
64
    .frame_free = elf_frame_free,
1426 jermar 65
    .share = elf_share
1424 jermar 66
};
67
 
68
/** Service a page fault in the ELF backend address space area.
69
 *
70
 * The address space area and page tables must be already locked.
71
 *
3141 jermar 72
 * @param area      Pointer to the address space area.
73
 * @param addr      Faulting virtual address.
74
 * @param access    Access mode that caused the fault (i.e.
75
 *          read/write/exec).
1424 jermar 76
 *
3141 jermar 77
 * @return      AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK
78
 *          on success (i.e. serviced).
1424 jermar 79
 */
1780 jermar 80
int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
1424 jermar 81
{
1425 jermar 82
    elf_header_t *elf = area->backend_data.elf;
83
    elf_segment_header_t *entry = area->backend_data.segment;
1426 jermar 84
    btree_node_t *leaf;
3007 jermar 85
    uintptr_t base, frame, page, start_anon;
1424 jermar 86
    index_t i;
2134 jermar 87
    bool dirty = false;
1424 jermar 88
 
89
    if (!as_area_check_access(area, access))
90
        return AS_PF_FAULT;
91
 
3007 jermar 92
    ASSERT((addr >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) &&
2132 jermar 93
        (addr < entry->p_vaddr + entry->p_memsz));
3007 jermar 94
    i = (addr - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
95
    base = (uintptr_t)
96
        (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
1426 jermar 97
 
3007 jermar 98
    /* Virtual address of faulting page*/
99
    page = ALIGN_DOWN(addr, PAGE_SIZE);
100
 
101
    /* Virtual address of the end of initialized part of segment */
102
    start_anon = entry->p_vaddr + entry->p_filesz;
103
 
1426 jermar 104
    if (area->sh_info) {
105
        bool found = false;
106
 
107
        /*
108
         * The address space area is shared.
109
         */
3007 jermar 110
 
1426 jermar 111
        mutex_lock(&area->sh_info->lock);
1780 jermar 112
        frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
3007 jermar 113
            page - area->base, &leaf);
1426 jermar 114
        if (!frame) {
2745 decky 115
            unsigned int i;
1426 jermar 116
 
117
            /*
118
             * Workaround for valid NULL address.
119
             */
120
 
121
            for (i = 0; i < leaf->keys; i++) {
3397 rimsky 122
                if (leaf->key[i] == page - area->base) {
1426 jermar 123
                    found = true;
124
                    break;
125
                }
126
            }
127
        }
128
        if (frame || found) {
1546 jermar 129
            frame_reference_add(ADDR2PFN(frame));
2132 jermar 130
            page_mapping_insert(AS, addr, frame,
131
                as_area_get_flags(area));
3007 jermar 132
            if (!used_space_insert(area, page, 1))
1426 jermar 133
                panic("Could not insert used space.\n");
134
            mutex_unlock(&area->sh_info->lock);
135
            return AS_PF_OK;
136
        }
137
    }
3007 jermar 138
 
1426 jermar 139
    /*
2132 jermar 140
     * The area is either not shared or the pagemap does not contain the
141
     * mapping.
1426 jermar 142
     */
3007 jermar 143
    if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
1424 jermar 144
        /*
145
         * Initialized portion of the segment. The memory is backed
146
         * directly by the content of the ELF image. Pages are
147
         * only copied if the segment is writable so that there
148
         * can be more instantions of the same memory ELF image
149
         * used at a time. Note that this could be later done
150
         * as COW.
151
         */
152
        if (entry->p_flags & PF_W) {
1780 jermar 153
            frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
2132 jermar 154
            memcpy((void *) PA2KA(frame),
155
                (void *) (base + i * FRAME_SIZE), FRAME_SIZE);
3142 svoboda 156
            if (entry->p_flags & PF_X) {
3143 svoboda 157
                smc_coherence_block((void *) PA2KA(frame),
158
                    FRAME_SIZE);
3142 svoboda 159
            }
2134 jermar 160
            dirty = true;
1424 jermar 161
        } else {
3007 jermar 162
            frame = KA2PA(base + i * FRAME_SIZE);
1424 jermar 163
        }  
3007 jermar 164
    } else if (page >= start_anon) {
1424 jermar 165
        /*
166
         * This is the uninitialized portion of the segment.
167
         * It is not physically present in the ELF image.
168
         * To resolve the situation, a frame must be allocated
169
         * and cleared.
170
         */
1780 jermar 171
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
3104 svoboda 172
        memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
2134 jermar 173
        dirty = true;
1424 jermar 174
    } else {
3007 jermar 175
        size_t pad_lo, pad_hi;
1424 jermar 176
        /*
177
         * The mixed case.
3007 jermar 178
         *
179
         * The middle part is backed by the ELF image and
180
         * the lower and upper parts are anonymous memory.
181
         * (The segment can be and often is shorter than 1 page).
1424 jermar 182
         */
3007 jermar 183
        if (page < entry->p_vaddr)
184
            pad_lo = entry->p_vaddr - page;
185
        else
186
            pad_lo = 0;
187
 
188
        if (start_anon < page + PAGE_SIZE)
189
            pad_hi = page + PAGE_SIZE - start_anon;
190
        else
191
            pad_hi = 0;
192
 
1780 jermar 193
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
3007 jermar 194
        memcpy((void *) (PA2KA(frame) + pad_lo),
195
            (void *) (base + i * FRAME_SIZE + pad_lo),
196
            FRAME_SIZE - pad_lo - pad_hi);
3142 svoboda 197
        if (entry->p_flags & PF_X) {
3143 svoboda 198
            smc_coherence_block((void *) (PA2KA(frame) + pad_lo),
199
                FRAME_SIZE - pad_lo - pad_hi);
3142 svoboda 200
        }
3104 svoboda 201
        memsetb((void *) PA2KA(frame), pad_lo, 0);
3141 jermar 202
        memsetb((void *) (PA2KA(frame) + FRAME_SIZE - pad_hi), pad_hi,
203
            0);
2134 jermar 204
        dirty = true;
3007 jermar 205
    }
1426 jermar 206
 
3007 jermar 207
    if (dirty && area->sh_info) {
208
        frame_reference_add(ADDR2PFN(frame));
209
        btree_insert(&area->sh_info->pagemap, page - area->base,
210
            (void *) frame, leaf);
211
    }
1426 jermar 212
 
213
    if (area->sh_info)
214
        mutex_unlock(&area->sh_info->lock);
3007 jermar 215
 
1424 jermar 216
    page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
3007 jermar 217
    if (!used_space_insert(area, page, 1))
1426 jermar 218
        panic("Could not insert used space.\n");
1424 jermar 219
 
220
    return AS_PF_OK;
221
}
222
 
223
/** Free a frame that is backed by the ELF backend.
224
 *
225
 * The address space area and page tables must be already locked.
226
 *
3141 jermar 227
 * @param area      Pointer to the address space area.
228
 * @param page      Page that is mapped to frame. Must be aligned to
229
 *          PAGE_SIZE.
230
 * @param frame     Frame to be released.
1424 jermar 231
 *
232
 */
1780 jermar 233
void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
1424 jermar 234
{
1425 jermar 235
    elf_header_t *elf = area->backend_data.elf;
236
    elf_segment_header_t *entry = area->backend_data.segment;
3007 jermar 237
    uintptr_t base, start_anon;
1424 jermar 238
    index_t i;
3007 jermar 239
 
240
    ASSERT((page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) &&
2132 jermar 241
        (page < entry->p_vaddr + entry->p_memsz));
3007 jermar 242
    i = (page - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
243
    base = (uintptr_t) (((void *) elf) +
244
        ALIGN_DOWN(entry->p_offset, FRAME_SIZE));
245
    start_anon = entry->p_vaddr + entry->p_filesz;
246
 
247
    if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
1424 jermar 248
        if (entry->p_flags & PF_W) {
249
            /*
2132 jermar 250
             * Free the frame with the copy of writable segment
251
             * data.
1424 jermar 252
             */
1760 palkovsky 253
            frame_free(frame);
1424 jermar 254
        }
255
    } else {
256
        /*
2132 jermar 257
         * The frame is either anonymous memory or the mixed case (i.e.
258
         * lower part is backed by the ELF image and the upper is
259
         * anonymous). In any case, a frame needs to be freed.
2134 jermar 260
         */
261
        frame_free(frame);
1424 jermar 262
    }
263
}
1426 jermar 264
 
265
/** Share ELF image backed address space area.
266
 *
267
 * If the area is writable, then all mapped pages are duplicated in the pagemap.
268
 * Otherwise only portions of the area that are not backed by the ELF image
269
 * are put into the pagemap.
270
 *
271
 * The address space and address space area must be locked prior to the call.
272
 *
3141 jermar 273
 * @param area      Address space area.
1426 jermar 274
 */
275
void elf_share(as_area_t *area)
276
{
277
    elf_segment_header_t *entry = area->backend_data.segment;
278
    link_t *cur;
279
    btree_node_t *leaf, *node;
1780 jermar 280
    uintptr_t start_anon = entry->p_vaddr + entry->p_filesz;
1426 jermar 281
 
282
    /*
283
     * Find the node in which to start linear search.
284
     */
285
    if (area->flags & AS_AREA_WRITE) {
2132 jermar 286
        node = list_get_instance(area->used_space.leaf_head.next,
287
            btree_node_t, leaf_link);
1426 jermar 288
    } else {
289
        (void) btree_search(&area->sh_info->pagemap, start_anon, &leaf);
2132 jermar 290
        node = btree_leaf_node_left_neighbour(&area->sh_info->pagemap,
291
            leaf);
1426 jermar 292
        if (!node)
293
            node = leaf;
294
    }
295
 
296
    /*
297
     * Copy used anonymous portions of the area to sh_info's page map.
298
     */
299
    mutex_lock(&area->sh_info->lock);
2132 jermar 300
    for (cur = &node->leaf_link; cur != &area->used_space.leaf_head;
301
        cur = cur->next) {
2745 decky 302
        unsigned int i;
1426 jermar 303
 
304
        node = list_get_instance(cur, btree_node_t, leaf_link);
305
 
306
        for (i = 0; i < node->keys; i++) {
1780 jermar 307
            uintptr_t base = node->key[i];
1426 jermar 308
            count_t count = (count_t) node->value[i];
2745 decky 309
            unsigned int j;
1426 jermar 310
 
311
            /*
312
             * Skip read-only areas of used space that are backed
313
             * by the ELF image.
314
             */
315
            if (!(area->flags & AS_AREA_WRITE))
3007 jermar 316
                if (base >= entry->p_vaddr &&
317
                    base + count * PAGE_SIZE <= start_anon)
1426 jermar 318
                    continue;
319
 
320
            for (j = 0; j < count; j++) {
321
                pte_t *pte;
322
 
323
                /*
2132 jermar 324
                 * Skip read-only pages that are backed by the
325
                 * ELF image.
1426 jermar 326
                 */
327
                if (!(area->flags & AS_AREA_WRITE))
3007 jermar 328
                    if (base >= entry->p_vaddr &&
329
                        base + (j + 1) * PAGE_SIZE <=
2132 jermar 330
                        start_anon)
1426 jermar 331
                        continue;
332
 
333
                page_table_lock(area->as, false);
2132 jermar 334
                pte = page_mapping_find(area->as,
335
                    base + j * PAGE_SIZE);
336
                ASSERT(pte && PTE_VALID(pte) &&
337
                    PTE_PRESENT(pte));
338
                btree_insert(&area->sh_info->pagemap,
339
                    (base + j * PAGE_SIZE) - area->base,
2467 jermar 340
                    (void *) PTE_GET_FRAME(pte), NULL);
1426 jermar 341
                page_table_unlock(area->as, false);
2132 jermar 342
 
343
                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
344
                frame_reference_add(pfn);
1426 jermar 345
            }
346
 
347
        }
348
    }
349
    mutex_unlock(&area->sh_info->lock);
350
}
1702 cejka 351
 
1757 jermar 352
/** @}
1702 cejka 353
 */