Skip to content

Commit

Permalink
linux-user: Remove qemu_host_page_{size, mask} from mmap.c
Browse files Browse the repository at this point in the history 
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>
  • Loading branch information
@rth7680
rth7680 committed Feb 22, 2024
1 parent 0124231 commit f0e18f5
Showing 1 changed file with 33 additions and 33 deletions.
66 changes: 33 additions & 33 deletions linux-user/mmap.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -165,6 +165,7 @@ static int target_to_host_prot(int prot)
/* 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 host_page_size = qemu_real_host_page_size();
abi_ulong starts[3];
abi_ulong lens[3];
int prots[3];
Expand All @@ -189,13 +190,13 @@ int target_mprotect(abi_ulong start, abi_ulong len, int target_prot)
}

last = start + len - 1;
host_start = start & qemu_host_page_mask;
host_start = start & -host_page_size;
host_last = HOST_PAGE_ALIGN(last) - 1;
nranges = 0;

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. */
prot1 = target_prot;
for (abi_ulong a = host_start; a < start; a += TARGET_PAGE_SIZE) {
Expand All @@ -205,7 +206,7 @@ int target_mprotect(abi_ulong start, abi_ulong len, int target_prot)
prot1 |= page_get_flags(a + 1);
}
starts[nranges] = host_start;
lens[nranges] = qemu_host_page_size;
lens[nranges] = host_page_size;
prots[nranges] = prot1;
nranges++;
} else {
Expand All @@ -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 (prot1 != target_prot) {
starts[nranges] = host_start;
lens[nranges] = qemu_host_page_size;
lens[nranges] = host_page_size;
prots[nranges] = prot1;
nranges++;
host_start += qemu_host_page_size;
host_start += host_page_size;
}
}

Expand All @@ -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 (prot1 != target_prot) {
host_last -= qemu_host_page_size;
host_last -= host_page_size;
starts[nranges] = host_last + 1;
lens[nranges] = qemu_host_page_size;
lens[nranges] = host_page_size;
prots[nranges] = prot1;
nranges++;
}
Expand Down Expand Up @@ -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,
int prot, int flags, int fd, off_t offset)
{
int host_page_size = qemu_real_host_page_size();
abi_ulong real_last;
void *host_start;
int prot_old, prot_new;
Expand All @@ -286,7 +288,7 @@ static bool mmap_frag(abi_ulong real_start, abi_ulong start, abi_ulong last,
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);

/* Get the protection of the target pages outside the mapping. */
Expand All @@ -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
* 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),
flags | MAP_ANONYMOUS, -1, 0);
if (p != host_start) {
if (p != MAP_FAILED) {
munmap(p, qemu_host_page_size);
munmap(p, host_page_size);
errno = EEXIST;
}
return false;
Expand All @@ -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. */
if (!(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. */
Expand All @@ -338,7 +340,7 @@ static bool mmap_frag(abi_ulong real_start, abi_ulong start, abi_ulong last,

/* Put final protection */
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;
}
Expand Down Expand Up @@ -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)
{
int host_page_size = qemu_real_host_page_size();
void *ptr, *prev;
abi_ulong addr;
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) {
start = mmap_next_start;
} else {
start &= qemu_host_page_mask;
start &= -host_page_size;
}
start = ROUND_UP(start, align);

Expand Down Expand Up @@ -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,
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 passthrough_start = -1, passthrough_last = 0;
int page_flags;
Expand Down Expand Up @@ -537,8 +541,8 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
}
}

real_start = start & qemu_host_page_mask;
host_offset = offset & qemu_host_page_mask;
real_start = start & -host_page_size;
host_offset = offset & -host_page_size;

/*
* If the user is asking for the kernel to find a location, do that
Expand Down Expand Up @@ -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
* up to the targets page boundary.
*/
if ((qemu_real_host_page_size() < qemu_host_page_size) &&
!(flags & MAP_ANONYMOUS)) {
if (host_page_size < TARGET_PAGE_SIZE && !(flags & MAP_ANONYMOUS)) {
struct stat sb;

if (fstat(fd, &sb) == -1) {
Expand All @@ -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_prot = target_to_host_prot(target_prot);

/*
* Note: we prefer to control the mapping address. It is
* especially important if qemu_host_page_size >
* qemu_real_host_page_size.
*/
/* Note: we prefer to control the mapping address. */
p = mmap(g2h_untagged(start), host_len, host_prot,
flags | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
if (p == MAP_FAILED) {
Expand Down Expand Up @@ -665,7 +664,7 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
* aligned, so we read it
*/
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
* possible while it is a shared mapping
Expand Down Expand Up @@ -694,7 +693,7 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,

/* handle the start of the mapping */
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 */
if (!mmap_frag(real_start, start, last,
target_prot, flags, fd, offset)) {
Expand All @@ -703,21 +702,21 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,
goto the_end1;
}
if (!mmap_frag(real_start, start,
real_start + qemu_host_page_size - 1,
real_start + host_page_size - 1,
target_prot, flags, fd, offset)) {
goto fail;
}
real_start += qemu_host_page_size;
real_start += host_page_size;
}
/* handle the end of the mapping */
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,
target_prot, flags, fd,
offset + real_page - start)) {
goto fail;
}
real_last -= qemu_host_page_size;
real_last -= host_page_size;
}

/* map the middle (easier) */
Expand Down Expand Up @@ -784,6 +783,7 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int target_prot,

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_last;
abi_ulong real_len;
Expand All @@ -793,7 +793,7 @@ static int mmap_reserve_or_unmap(abi_ulong start, abi_ulong len)
int prot;

last = start + len - 1;
real_start = start & qemu_host_page_mask;
real_start = start & -host_page_size;
real_last = HOST_PAGE_ALIGN(last) - 1;

/*
Expand All @@ -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,
* 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;
for (a = real_start; a < start; a += TARGET_PAGE_SIZE) {
prot |= page_get_flags(a);
Expand All @@ -818,14 +818,14 @@ static int mmap_reserve_or_unmap(abi_ulong start, abi_ulong len)
prot |= page_get_flags(a);
}
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) {
prot |= page_get_flags(a + 1);
}
if (prot != 0) {
real_last -= qemu_host_page_size;
real_last -= host_page_size;
}

if (real_last < real_start) {
Expand Down

0 comments on commit f0e18f5

Please sign in to comment.