2 * Copyright (c) 2006 Jakub Jermar
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
29 /** @addtogroup kernel_generic_mm
35 * @brief Backend for address space areas backed by an ELF image.
45 #include <mm/reserve.h>
47 #include <genarch/mm/page_pt.h>
48 #include <genarch/mm/page_ht.h>
55 static bool elf_create(as_area_t
*);
56 static bool elf_resize(as_area_t
*, size_t);
57 static void elf_share(as_area_t
*);
58 static void elf_destroy(as_area_t
*);
60 static bool elf_is_resizable(as_area_t
*);
61 static bool elf_is_shareable(as_area_t
*);
63 static int elf_page_fault(as_area_t
*, uintptr_t, pf_access_t
);
64 static void elf_frame_free(as_area_t
*, uintptr_t, uintptr_t);
66 mem_backend_t elf_backend
= {
70 .destroy
= elf_destroy
,
72 .is_resizable
= elf_is_resizable
,
73 .is_shareable
= elf_is_shareable
,
75 .page_fault
= elf_page_fault
,
76 .frame_free
= elf_frame_free
,
78 .create_shared_data
= NULL
,
79 .destroy_shared_data
= NULL
82 static size_t elf_nonanon_pages_get(as_area_t
*area
)
84 elf_segment_header_t
*entry
= area
->backend_data
.segment
;
85 uintptr_t first
= ALIGN_UP(entry
->p_vaddr
, PAGE_SIZE
);
86 uintptr_t last
= ALIGN_DOWN(entry
->p_vaddr
+ entry
->p_filesz
,
89 if (entry
->p_flags
& PF_W
)
98 /** Get page number in the task where the ELF page originates from.
100 * The ELF page can be shared to a different address than it originated from,
101 * but we need the originating address since that corresponds to the ELF's
104 * @param area Area in which the page resides
105 * @param page Virtual address of the page in @a area
106 * @return Virtual address of the page in the origin address space
108 static uintptr_t elf_orig_page(as_area_t
*area
, uintptr_t page
)
110 return page
- area
->base
+ area
->backend_data
.elf_base
;
113 bool elf_create(as_area_t
*area
)
115 size_t nonanon_pages
= elf_nonanon_pages_get(area
);
117 if (area
->pages
<= nonanon_pages
)
120 return reserve_try_alloc(area
->pages
- nonanon_pages
);
123 bool elf_resize(as_area_t
*area
, size_t new_pages
)
125 size_t nonanon_pages
= elf_nonanon_pages_get(area
);
127 if (new_pages
> area
->pages
) {
128 /* The area is growing. */
129 if (area
->pages
>= nonanon_pages
)
130 return reserve_try_alloc(new_pages
- area
->pages
);
131 else if (new_pages
> nonanon_pages
)
132 return reserve_try_alloc(new_pages
- nonanon_pages
);
133 } else if (new_pages
< area
->pages
) {
134 /* The area is shrinking. */
135 if (new_pages
>= nonanon_pages
)
136 reserve_free(area
->pages
- new_pages
);
137 else if (area
->pages
> nonanon_pages
)
138 reserve_free(nonanon_pages
- new_pages
);
144 /** Share ELF image backed address space area.
146 * If the area is writable, then all mapped pages are duplicated in the pagemap.
147 * Otherwise only portions of the area that are not backed by the ELF image
148 * are put into the pagemap.
150 * @param area Address space area.
152 void elf_share(as_area_t
*area
)
154 elf_segment_header_t
*entry
= area
->backend_data
.segment
;
155 used_space_ival_t
*start
;
156 used_space_ival_t
*cur
;
157 uintptr_t start_anon
= entry
->p_vaddr
+ entry
->p_filesz
;
159 assert(mutex_locked(&area
->as
->lock
));
160 assert(mutex_locked(&area
->lock
));
163 * Find the node in which to start linear search.
165 if (area
->flags
& AS_AREA_WRITE
) {
166 start
= used_space_first(&area
->used_space
);
168 /* Find first interval containing addresses >= start_anon */
169 start
= used_space_find_gteq(&area
->used_space
, start_anon
);
173 * Copy used anonymous portions of the area to sh_info's page map.
175 mutex_lock(&area
->sh_info
->lock
);
177 while (cur
!= NULL
) {
178 uintptr_t base
= cur
->page
;
179 size_t count
= cur
->count
;
183 * Skip read-only areas of used space that are backed
186 if (!(area
->flags
& AS_AREA_WRITE
))
187 if (base
>= entry
->p_vaddr
&&
188 base
+ P2SZ(count
) <= start_anon
)
191 for (i
= 0; i
< count
; i
++) {
196 * Skip read-only pages that are backed by the
199 if (!(area
->flags
& AS_AREA_WRITE
))
200 if (base
>= entry
->p_vaddr
&&
201 base
+ P2SZ(i
+ 1) <= start_anon
)
204 page_table_lock(area
->as
, false);
205 found
= page_mapping_find(area
->as
,
206 base
+ P2SZ(i
), false, &pte
);
210 assert(PTE_VALID(&pte
));
211 assert(PTE_PRESENT(&pte
));
213 as_pagemap_insert(&area
->sh_info
->pagemap
,
214 (base
+ P2SZ(i
)) - area
->base
,
215 PTE_GET_FRAME(&pte
));
216 page_table_unlock(area
->as
, false);
218 pfn_t pfn
= ADDR2PFN(PTE_GET_FRAME(&pte
));
219 frame_reference_add(pfn
);
222 cur
= used_space_next(cur
);
225 mutex_unlock(&area
->sh_info
->lock
);
228 void elf_destroy(as_area_t
*area
)
230 size_t nonanon_pages
= elf_nonanon_pages_get(area
);
232 if (area
->pages
> nonanon_pages
)
233 reserve_free(area
->pages
- nonanon_pages
);
236 bool elf_is_resizable(as_area_t
*area
)
241 bool elf_is_shareable(as_area_t
*area
)
246 /** Service a page fault in the ELF backend address space area.
248 * The address space area and page tables must be already locked.
250 * @param area Pointer to the address space area.
251 * @param upage Faulting virtual page.
252 * @param access Access mode that caused the fault (i.e.
255 * @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK
256 * on success (i.e. serviced).
258 int elf_page_fault(as_area_t
*area
, uintptr_t upage
, pf_access_t access
)
260 elf_header_t
*elf
= area
->backend_data
.elf
;
261 elf_segment_header_t
*entry
= area
->backend_data
.segment
;
265 uintptr_t start_anon
;
270 assert(page_table_locked(AS
));
271 assert(mutex_locked(&area
->lock
));
272 assert(IS_ALIGNED(upage
, PAGE_SIZE
));
274 elfpage
= elf_orig_page(area
, upage
);
276 if (!as_area_check_access(area
, access
))
279 if (elfpage
< ALIGN_DOWN(entry
->p_vaddr
, PAGE_SIZE
))
282 if (elfpage
>= entry
->p_vaddr
+ entry
->p_memsz
)
285 i
= (elfpage
- ALIGN_DOWN(entry
->p_vaddr
, PAGE_SIZE
)) >>
288 (((void *) elf
) + ALIGN_DOWN(entry
->p_offset
, PAGE_SIZE
));
290 /* Virtual address of the end of initialized part of segment */
291 start_anon
= entry
->p_vaddr
+ entry
->p_filesz
;
293 mutex_lock(&area
->sh_info
->lock
);
294 if (area
->sh_info
->shared
) {
296 * The address space area is shared.
299 errno_t rc
= as_pagemap_find(&area
->sh_info
->pagemap
,
300 upage
- area
->base
, &frame
);
302 frame_reference_add(ADDR2PFN(frame
));
303 page_mapping_insert(AS
, upage
, frame
,
304 as_area_get_flags(area
));
305 if (!used_space_insert(&area
->used_space
, upage
, 1))
306 panic("Cannot insert used space.");
307 mutex_unlock(&area
->sh_info
->lock
);
313 * The area is either not shared or the pagemap does not contain the
316 if (elfpage
>= entry
->p_vaddr
&& elfpage
+ PAGE_SIZE
<= start_anon
) {
318 * Initialized portion of the segment. The memory is backed
319 * directly by the content of the ELF image. Pages are
320 * only copied if the segment is writable so that there
321 * can be more instances of the same memory ELF image
322 * used at a time. Note that this could be later done
325 if (entry
->p_flags
& PF_W
) {
326 kpage
= km_temporary_page_get(&frame
, FRAME_NO_RESERVE
);
327 memcpy((void *) kpage
, (void *) (base
+ i
* PAGE_SIZE
),
329 if (entry
->p_flags
& PF_X
) {
330 smc_coherence((void *) kpage
, PAGE_SIZE
);
332 km_temporary_page_put(kpage
);
338 found
= page_mapping_find(AS_KERNEL
,
339 base
+ i
* FRAME_SIZE
, true, &pte
);
343 assert(PTE_PRESENT(&pte
));
345 frame
= PTE_GET_FRAME(&pte
);
347 } else if (elfpage
>= start_anon
) {
349 * This is the uninitialized portion of the segment.
350 * It is not physically present in the ELF image.
351 * To resolve the situation, a frame must be allocated
354 kpage
= km_temporary_page_get(&frame
, FRAME_NO_RESERVE
);
355 memsetb((void *) kpage
, PAGE_SIZE
, 0);
356 km_temporary_page_put(kpage
);
359 size_t pad_lo
, pad_hi
;
363 * The middle part is backed by the ELF image and
364 * the lower and upper parts are anonymous memory.
365 * (The segment can be and often is shorter than 1 page).
367 if (upage
< entry
->p_vaddr
)
368 pad_lo
= entry
->p_vaddr
- upage
;
372 if (start_anon
< upage
+ PAGE_SIZE
)
373 pad_hi
= upage
+ PAGE_SIZE
- start_anon
;
377 kpage
= km_temporary_page_get(&frame
, FRAME_NO_RESERVE
);
378 memcpy((void *) (kpage
+ pad_lo
),
379 (void *) (base
+ i
* PAGE_SIZE
+ pad_lo
),
380 PAGE_SIZE
- pad_lo
- pad_hi
);
381 if (entry
->p_flags
& PF_X
) {
382 smc_coherence((void *) (kpage
+ pad_lo
),
383 PAGE_SIZE
- pad_lo
- pad_hi
);
385 memsetb((void *) kpage
, pad_lo
, 0);
386 memsetb((void *) (kpage
+ PAGE_SIZE
- pad_hi
), pad_hi
, 0);
387 km_temporary_page_put(kpage
);
391 if (dirty
&& area
->sh_info
->shared
) {
392 frame_reference_add(ADDR2PFN(frame
));
393 as_pagemap_insert(&area
->sh_info
->pagemap
, upage
- area
->base
,
397 mutex_unlock(&area
->sh_info
->lock
);
399 page_mapping_insert(AS
, upage
, frame
, as_area_get_flags(area
));
400 if (!used_space_insert(&area
->used_space
, upage
, 1))
401 panic("Cannot insert used space.");
406 /** Free a frame that is backed by the ELF backend.
408 * The address space area and page tables must be already locked.
410 * @param area Pointer to the address space area.
411 * @param page Page that is mapped to frame. Must be aligned to
413 * @param frame Frame to be released.
416 void elf_frame_free(as_area_t
*area
, uintptr_t page
, uintptr_t frame
)
418 elf_segment_header_t
*entry
= area
->backend_data
.segment
;
419 uintptr_t start_anon
;
422 assert(page_table_locked(area
->as
));
423 assert(mutex_locked(&area
->lock
));
425 elfpage
= elf_orig_page(area
, page
);
427 assert(elfpage
>= ALIGN_DOWN(entry
->p_vaddr
, PAGE_SIZE
));
428 assert(elfpage
< entry
->p_vaddr
+ entry
->p_memsz
);
430 start_anon
= entry
->p_vaddr
+ entry
->p_filesz
;
432 if (elfpage
>= entry
->p_vaddr
&& elfpage
+ PAGE_SIZE
<= start_anon
) {
433 if (entry
->p_flags
& PF_W
) {
435 * Free the frame with the copy of writable segment
438 frame_free_noreserve(frame
, 1);
442 * The frame is either anonymous memory or the mixed case (i.e.
443 * lower part is backed by the ELF image and the upper is
444 * anonymous). In any case, a frame needs to be freed.
446 frame_free_noreserve(frame
, 1);