WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/mm/backend_elf.c


/*
 * Copyright (C) 2006 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup genericmm
 * @{
 */
 
/**
 * @file
 * @brief   Backend for address space areas backed by an ELF image.
 */
 
#include <elf.h>
#include <debug.h>
#include <arch/types.h>
#include <typedefs.h>
#include <mm/as.h>
#include <mm/frame.h>
#include <mm/slab.h>
#include <mm/page.h>
#include <genarch/mm/page_pt.h>
#include <genarch/mm/page_ht.h>
#include <align.h>
#include <memstr.h>
#include <macros.h>
#include <arch.h>
 
static int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
static void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame);
static void elf_share(as_area_t *area);
 
mem_backend_t elf_backend = {
    .page_fault = elf_page_fault,
    .frame_free = elf_frame_free,
    .share = elf_share
};
 
/** Service a page fault in the ELF backend address space area.
 *
 * The address space area and page tables must be already locked.
 *
 * @param area Pointer to the address space area.
 * @param addr Faulting virtual address.
 * @param access Access mode that caused the fault (i.e. read/write/exec).
 *
 * @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e. serviced).
 */
int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
{
    elf_header_t *elf = area->backend_data.elf;
    elf_segment_header_t *entry = area->backend_data.segment;
    btree_node_t *leaf;
    uintptr_t base, frame;
    index_t i;
 
    if (!as_area_check_access(area, access))
        return AS_PF_FAULT;
 
    ASSERT((addr >= entry->p_vaddr) && (addr < entry->p_vaddr + entry->p_memsz));
    i = (addr - entry->p_vaddr) >> PAGE_WIDTH;
    base = (uintptr_t) (((void *) elf) + entry->p_offset);
    ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
 
    if (area->sh_info) {
        bool found = false;
 
        /*
         * The address space area is shared.
         */
         
        mutex_lock(&area->sh_info->lock);
        frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
            ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
        if (!frame) {
            int i;
 
            /*
             * Workaround for valid NULL address.
             */
 
            for (i = 0; i < leaf->keys; i++) {
                if (leaf->key[i] == ALIGN_DOWN(addr, PAGE_SIZE)) {
                    found = true;
                    break;
                }
            }
        }
        if (frame || found) {
            frame_reference_add(ADDR2PFN(frame));
            page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
            if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
                panic("Could not insert used space.\n");
            mutex_unlock(&area->sh_info->lock);
            return AS_PF_OK;
        }
    }
   
    /*
     * The area is either not shared or the pagemap does not contain the mapping.
     */
   
    if (ALIGN_DOWN(addr, PAGE_SIZE) + PAGE_SIZE < entry->p_vaddr + entry->p_filesz) {
        /*
         * Initialized portion of the segment. The memory is backed
         * directly by the content of the ELF image. Pages are
         * only copied if the segment is writable so that there
         * can be more instantions of the same memory ELF image
         * used at a time. Note that this could be later done
         * as COW.
         */
        if (entry->p_flags & PF_W) {
            frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
            memcpy((void *) PA2KA(frame), (void *) (base + i*FRAME_SIZE), FRAME_SIZE);
           
            if (area->sh_info) {
                frame_reference_add(ADDR2PFN(frame));
                btree_insert(&area->sh_info->pagemap, ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
                    (void *) frame, leaf);
            }
 
        } else {
            frame = KA2PA(base + i*FRAME_SIZE);
        }  
    } else if (ALIGN_DOWN(addr, PAGE_SIZE) >= ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
        /*
         * This is the uninitialized portion of the segment.
         * It is not physically present in the ELF image.
         * To resolve the situation, a frame must be allocated
         * and cleared.
         */
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
        memsetb(PA2KA(frame), FRAME_SIZE, 0);
 
        if (area->sh_info) {
            frame_reference_add(ADDR2PFN(frame));
            btree_insert(&area->sh_info->pagemap, ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
                (void *) frame, leaf);
        }
 
    } else {
        size_t size;
        /*
         * The mixed case.
         * The lower part is backed by the ELF image and
         * the upper part is anonymous memory.
         */
        size = entry->p_filesz - (i<<PAGE_WIDTH);
        frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
        memsetb(PA2KA(frame) + size, FRAME_SIZE - size, 0);
        memcpy((void *) PA2KA(frame), (void *) (base + i*FRAME_SIZE), size);
 
        if (area->sh_info) {
            frame_reference_add(ADDR2PFN(frame));
            btree_insert(&area->sh_info->pagemap, ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
                (void *) frame, leaf);
        }
 
    }
   
    if (area->sh_info)
        mutex_unlock(&area->sh_info->lock);
   
    page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
    if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
        panic("Could not insert used space.\n");
 
    return AS_PF_OK;
}
 
/** Free a frame that is backed by the ELF backend.
 *
 * The address space area and page tables must be already locked.
 *
 * @param area Pointer to the address space area.
 * @param page Page that is mapped to frame. Must be aligned to PAGE_SIZE.
 * @param frame Frame to be released.
 *
 */
void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
{
    elf_header_t *elf = area->backend_data.elf;
    elf_segment_header_t *entry = area->backend_data.segment;
    uintptr_t base;
    index_t i;
   
    ASSERT((page >= entry->p_vaddr) && (page < entry->p_vaddr + entry->p_memsz));
    i = (page - entry->p_vaddr) >> PAGE_WIDTH;
    base = (uintptr_t) (((void *) elf) + entry->p_offset);
    ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
   
    if (page + PAGE_SIZE < ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
        if (entry->p_flags & PF_W) {
            /*
             * Free the frame with the copy of writable segment data.
             */
            frame_free(frame);
        }
    } else {
        /*
         * The frame is either anonymous memory or the mixed case (i.e. lower
         * part is backed by the ELF image and the upper is anonymous).
         * In any case, a frame needs to be freed.
         */
        frame_free(frame);
    }
}
 
/** Share ELF image backed address space area.
 *
 * If the area is writable, then all mapped pages are duplicated in the pagemap.
 * Otherwise only portions of the area that are not backed by the ELF image
 * are put into the pagemap.
 *
 * The address space and address space area must be locked prior to the call.
 *
 * @param area Address space area.
 */
void elf_share(as_area_t *area)
{
    elf_segment_header_t *entry = area->backend_data.segment;
    link_t *cur;
    btree_node_t *leaf, *node;
    uintptr_t start_anon = entry->p_vaddr + entry->p_filesz;
 
    /*
     * Find the node in which to start linear search.
     */
    if (area->flags & AS_AREA_WRITE) {
        node = list_get_instance(area->used_space.leaf_head.next, btree_node_t, leaf_link);
    } else {
        (void) btree_search(&area->sh_info->pagemap, start_anon, &leaf);
        node = btree_leaf_node_left_neighbour(&area->sh_info->pagemap, leaf);
        if (!node)
            node = leaf;
    }
 
    /*
     * Copy used anonymous portions of the area to sh_info's page map.
     */
    mutex_lock(&area->sh_info->lock);
    for (cur = &node->leaf_link; cur != &area->used_space.leaf_head; cur = cur->next) {
        int i;
       
        node = list_get_instance(cur, btree_node_t, leaf_link);
       
        for (i = 0; i < node->keys; i++) {
            uintptr_t base = node->key[i];
            count_t count = (count_t) node->value[i];
            int j;
           
            /*
             * Skip read-only areas of used space that are backed
             * by the ELF image.
             */
            if (!(area->flags & AS_AREA_WRITE))
                if (base + count*PAGE_SIZE <= start_anon)
                    continue;
           
            for (j = 0; j < count; j++) {
                pte_t *pte;
           
                /*
                 * Skip read-only pages that are backed by the ELF image.
                 */
                if (!(area->flags & AS_AREA_WRITE))
                    if (base + (j + 1)*PAGE_SIZE <= start_anon)
                        continue;
               
                page_table_lock(area->as, false);
                pte = page_mapping_find(area->as, base + j*PAGE_SIZE);
                ASSERT(pte && PTE_VALID(pte) && PTE_PRESENT(pte));
                btree_insert(&area->sh_info->pagemap, (base + j*PAGE_SIZE) - area->base,
                    (void *) PTE_GET_FRAME(pte), NULL);
                page_table_unlock(area->as, false);
                frame_reference_add(ADDR2PFN(PTE_GET_FRAME(pte)));
            }
               
        }
    }
    mutex_unlock(&area->sh_info->lock);
}
 
/** @}
 */
 

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/mm/backend_elf.c – Rev 1760 → 1780

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