ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

linux-user: Remove qemu_host_page_{size, mask} from mmap.c 

Use qemu_real_host_page_size instead.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Reviewed-by: Ilya Leoshkevich <iii@linux.ibm.com>
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
Acked-by: Helge Deller <deller@gmx.de>
Message-Id: <20240102015808.132373-9-richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson 2024-01-02 12:57:43 +11:00
parent 2c796d230e
commit 621ac47d37
1 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
linux-user/mmap.c
View File

@ -165,6 +165,7 @@ static int target_to_host_prot(int prot)
/* NOTE: all the constants are the HOST ones, but addresses are target. */ /* NOTE: all the constants are the HOST ones, but addresses are target. */
int target_mprotect(abi_ulong start, abi_ulong len, int target_prot) int target_mprotect(abi_ulong start, abi_ulong len, int target_prot)
{ {
int host_page_size = qemu_real_host_page_size();
abi_ulong starts[3]; abi_ulong starts[3];
abi_ulong lens[3]; abi_ulong lens[3];
int prots[3]; int prots[3];
@ -189,13 +190,13 @@ int target_mprotect(abi_ulong start, abi_ulong len, int target_prot)
} }
last = start + len - 1; last = start + len - 1;
host_start = start & qemu_host_page_mask; host_start = start & -host_page_size;
host_last = HOST_PAGE_ALIGN(last) - 1; host_last = HOST_PAGE_ALIGN(last) - 1;
nranges = 0; nranges = 0;
mmap_lock(); mmap_lock();
if (host_last - host_start < qemu_host_page_size) { if (host_last - host_start < host_page_size) {
/* Single host page contains all guest pages: sum the prot. */ /* Single host page contains all guest pages: sum the prot. */
prot1 = target_prot; prot1 = target_prot;
for (abi_ulong a = host_start; a < start; a += TARGET_PAGE_SIZE) { for (abi_ulong a = host_start; a < start; a += TARGET_PAGE_SIZE) {
@ -205,7 +206,7 @@ int target_mprotect(abi_ulong start, abi_ulong len, int target_prot)
prot1 |= page_get_flags(a + 1); prot1 |= page_get_flags(a + 1);
} }
starts[nranges] = host_start; starts[nranges] = host_start;
lens[nranges] = qemu_host_page_size; lens[nranges] = host_page_size;
prots[nranges] = prot1; prots[nranges] = prot1;
nranges++; nranges++;
} else { } else {
@ -218,10 +219,10 @@ int target_mprotect(abi_ulong start, abi_ulong len, int target_prot)
/* If the resulting sum differs, create a new range. */ /* If the resulting sum differs, create a new range. */
if (prot1 != target_prot) { if (prot1 != target_prot) {
starts[nranges] = host_start; starts[nranges] = host_start;
lens[nranges] = qemu_host_page_size; lens[nranges] = host_page_size;
prots[nranges] = prot1; prots[nranges] = prot1;
nranges++; nranges++;
host_start += qemu_host_page_size; host_start += host_page_size;
} }
} }
@ -233,9 +234,9 @@ int target_mprotect(abi_ulong start, abi_ulong len, int target_prot)
} }
/* If the resulting sum differs, create a new range. */ /* If the resulting sum differs, create a new range. */
if (prot1 != target_prot) { if (prot1 != target_prot) {
host_last -= qemu_host_page_size; host_last -= host_page_size;
starts[nranges] = host_last + 1; starts[nranges] = host_last + 1;
lens[nranges] = qemu_host_page_size; lens[nranges] = host_page_size;
prots[nranges] = prot1; prots[nranges] = prot1;
nranges++; nranges++;
} }
@ -270,6 +271,7 @@ int target_mprotect(abi_ulong start, abi_ulong len, int target_prot)
static bool mmap_frag(abi_ulong real_start, abi_ulong start, abi_ulong last, static bool mmap_frag(abi_ulong real_start, abi_ulong start, abi_ulong last,
int prot, int flags, int fd, off_t offset) int prot, int flags, int fd, off_t offset)
{ {
int host_page_size = qemu_real_host_page_size();
abi_ulong real_last; abi_ulong real_last;
void *host_start; void *host_start;
int prot_old, prot_new; int prot_old, prot_new;
@ -286,7 +288,7 @@ static bool mmap_frag(abi_ulong real_start, abi_ulong start, abi_ulong last,
return false; return false;
} }
real_last = real_start + qemu_host_page_size - 1; real_last = real_start + host_page_size - 1;
host_start = g2h_untagged(real_start); host_start = g2h_untagged(real_start);
/* Get the protection of the target pages outside the mapping. */ /* Get the protection of the target pages outside the mapping. */
@ -304,12 +306,12 @@ static bool mmap_frag(abi_ulong real_start, abi_ulong start, abi_ulong last,
* outside of the fragment we need to map. Allocate a new host * outside of the fragment we need to map. Allocate a new host
* page to cover, discarding whatever else may have been present. * page to cover, discarding whatever else may have been present.
*/ */
void *p = mmap(host_start, qemu_host_page_size, void *p = mmap(host_start, host_page_size,
target_to_host_prot(prot), target_to_host_prot(prot),
flags | MAP_ANONYMOUS, -1, 0); flags | MAP_ANONYMOUS, -1, 0);
if (p != host_start) { if (p != host_start) {
if (p != MAP_FAILED) { if (p != MAP_FAILED) {
munmap(p, qemu_host_page_size); munmap(p, host_page_size);
errno = EEXIST; errno = EEXIST;
} }
return false; return false;
@ -324,7 +326,7 @@ static bool mmap_frag(abi_ulong real_start, abi_ulong start, abi_ulong last,
/* Adjust protection to be able to write. */ /* Adjust protection to be able to write. */
if (!(host_prot_old & PROT_WRITE)) { if (!(host_prot_old & PROT_WRITE)) {
host_prot_old |= PROT_WRITE; host_prot_old |= PROT_WRITE;
mprotect(host_start, qemu_host_page_size, host_prot_old); mprotect(host_start, host_page_size, host_prot_old);
} }
/* Read or zero the new guest pages. */ /* Read or zero the new guest pages. */
@ -338,7 +340,7 @@ static bool mmap_frag(abi_ulong real_start, abi_ulong start, abi_ulong last,
/* Put final protection */ /* Put final protection */
if (host_prot_new != host_prot_old) { if (host_prot_new != host_prot_old) {
mprotect(host_start, qemu_host_page_size, host_prot_new); mprotect(host_start, host_page_size, host_prot_new);
} }
return true; return true;
} }
@ -373,17 +375,18 @@ static abi_ulong mmap_find_vma_reserved(abi_ulong start, abi_ulong size,
*/ */
abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size, abi_ulong align) abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size, abi_ulong align)
{ {
int host_page_size = qemu_real_host_page_size();
void *ptr, *prev; void *ptr, *prev;
abi_ulong addr; abi_ulong addr;
int wrapped, repeat; int wrapped, repeat;
align = MAX(align, qemu_host_page_size); align = MAX(align, host_page_size);
/* If 'start' == 0, then a default start address is used. */ /* If 'start' == 0, then a default start address is used. */
if (start == 0) { if (start == 0) {
start = mmap_next_start; start = mmap_next_start;
} else { } else {
start &= qemu_host_page_mask; start &= -host_page_size;
} }
start = ROUND_UP(start, align); start = ROUND_UP(start, align);
@ -492,6 +495,7 @@ abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size, abi_ulong align)
abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot, abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
int flags, int fd, off_t offset) int flags, int fd, off_t offset)
{ {
int host_page_size = qemu_real_host_page_size();
abi_ulong ret, last, real_start, real_last, retaddr, host_len; abi_ulong ret, last, real_start, real_last, retaddr, host_len;
abi_ulong passthrough_start = -1, passthrough_last = 0; abi_ulong passthrough_start = -1, passthrough_last = 0;
int page_flags; int page_flags;
@ -537,8 +541,8 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
} }
} }
real_start = start & qemu_host_page_mask; real_start = start & -host_page_size;
host_offset = offset & qemu_host_page_mask; host_offset = offset & -host_page_size;
/* /*
* If the user is asking for the kernel to find a location, do that * If the user is asking for the kernel to find a location, do that
@ -567,8 +571,7 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
* may need to truncate file maps at EOF and add extra anonymous pages * may need to truncate file maps at EOF and add extra anonymous pages
* up to the targets page boundary. * up to the targets page boundary.
*/ */
if ((qemu_real_host_page_size() < qemu_host_page_size) && if (host_page_size < TARGET_PAGE_SIZE && !(flags & MAP_ANONYMOUS)) {
!(flags & MAP_ANONYMOUS)) {
struct stat sb; struct stat sb;
if (fstat(fd, &sb) == -1) { if (fstat(fd, &sb) == -1) {
@ -595,11 +598,7 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
host_len = HOST_PAGE_ALIGN(host_len); host_len = HOST_PAGE_ALIGN(host_len);
host_prot = target_to_host_prot(target_prot); host_prot = target_to_host_prot(target_prot);
/* /* Note: we prefer to control the mapping address. */
* Note: we prefer to control the mapping address. It is
* especially important if qemu_host_page_size >
* qemu_real_host_page_size.
*/
p = mmap(g2h_untagged(start), host_len, host_prot, p = mmap(g2h_untagged(start), host_len, host_prot,
flags | MAP_FIXED | MAP_ANONYMOUS, -1, 0); flags | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
if (p == MAP_FAILED) { if (p == MAP_FAILED) {
@ -665,7 +664,7 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
* aligned, so we read it * aligned, so we read it
*/ */
if (!(flags & MAP_ANONYMOUS) && if (!(flags & MAP_ANONYMOUS) &&
(offset & ~qemu_host_page_mask) != (start & ~qemu_host_page_mask)) { (offset & (host_page_size - 1)) != (start & (host_page_size - 1))) {
/* /*
* msync() won't work here, so we return an error if write is * msync() won't work here, so we return an error if write is
* possible while it is a shared mapping * possible while it is a shared mapping
@ -694,7 +693,7 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
/* handle the start of the mapping */ /* handle the start of the mapping */
if (start > real_start) { if (start > real_start) {
if (real_last == real_start + qemu_host_page_size - 1) { if (real_last == real_start + host_page_size - 1) {
/* one single host page */ /* one single host page */
if (!mmap_frag(real_start, start, last, if (!mmap_frag(real_start, start, last,
target_prot, flags, fd, offset)) { target_prot, flags, fd, offset)) {
@ -703,21 +702,21 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
goto the_end1; goto the_end1;
} }
if (!mmap_frag(real_start, start, if (!mmap_frag(real_start, start,
real_start + qemu_host_page_size - 1, real_start + host_page_size - 1,
target_prot, flags, fd, offset)) { target_prot, flags, fd, offset)) {
goto fail; goto fail;
} }
real_start += qemu_host_page_size; real_start += host_page_size;
} }
/* handle the end of the mapping */ /* handle the end of the mapping */
if (last < real_last) { if (last < real_last) {
abi_ulong real_page = real_last - qemu_host_page_size + 1; abi_ulong real_page = real_last - host_page_size + 1;
if (!mmap_frag(real_page, real_page, last, if (!mmap_frag(real_page, real_page, last,
target_prot, flags, fd, target_prot, flags, fd,
offset + real_page - start)) { offset + real_page - start)) {
goto fail; goto fail;
} }
real_last -= qemu_host_page_size; real_last -= host_page_size;
} }
/* map the middle (easier) */ /* map the middle (easier) */
@ -784,6 +783,7 @@ fail:
static int mmap_reserve_or_unmap(abi_ulong start, abi_ulong len) static int mmap_reserve_or_unmap(abi_ulong start, abi_ulong len)
{ {
int host_page_size = qemu_real_host_page_size();
abi_ulong real_start; abi_ulong real_start;
abi_ulong real_last; abi_ulong real_last;
abi_ulong real_len; abi_ulong real_len;
@ -793,7 +793,7 @@ static int mmap_reserve_or_unmap(abi_ulong start, abi_ulong len)
int prot; int prot;
last = start + len - 1; last = start + len - 1;
real_start = start & qemu_host_page_mask; real_start = start & -host_page_size;
real_last = HOST_PAGE_ALIGN(last) - 1; real_last = HOST_PAGE_ALIGN(last) - 1;
/* /*
@ -802,7 +802,7 @@ static int mmap_reserve_or_unmap(abi_ulong start, abi_ulong len)
* The single page special case is required for the last page, * The single page special case is required for the last page,
* lest real_start overflow to zero. * lest real_start overflow to zero.
*/ */
if (real_last - real_start < qemu_host_page_size) { if (real_last - real_start < host_page_size) {
prot = 0; prot = 0;
for (a = real_start; a < start; a += TARGET_PAGE_SIZE) { for (a = real_start; a < start; a += TARGET_PAGE_SIZE) {
prot |= page_get_flags(a); prot |= page_get_flags(a);
@ -818,14 +818,14 @@ static int mmap_reserve_or_unmap(abi_ulong start, abi_ulong len)
prot |= page_get_flags(a); prot |= page_get_flags(a);
} }
if (prot != 0) { if (prot != 0) {
real_start += qemu_host_page_size; real_start += host_page_size;
} }
for (prot = 0, a = last; a < real_last; a += TARGET_PAGE_SIZE) { for (prot = 0, a = last; a < real_last; a += TARGET_PAGE_SIZE) {
prot |= page_get_flags(a + 1); prot |= page_get_flags(a + 1);
} }
if (prot != 0) { if (prot != 0) {
real_last -= qemu_host_page_size; real_last -= host_page_size;
} }
if (real_last < real_start) { if (real_last < real_start) {