bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 1 | /* |
| 2 | * mmap support for qemu |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 3 | * |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 4 | * Copyright (c) 2003 Fabrice Bellard |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
Blue Swirl | 8167ee8 | 2009-07-16 20:47:01 +0000 | [diff] [blame] | 17 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 18 | */ |
Peter Maydell | d39594e | 2016-01-26 18:17:02 +0000 | [diff] [blame] | 19 | #include "qemu/osdep.h" |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 20 | |
| 21 | #include "qemu.h" |
blueswir1 | 78f5bf1 | 2008-10-02 19:55:50 +0000 | [diff] [blame] | 22 | #include "qemu-common.h" |
Paolo Bonzini | 1652b97 | 2015-04-22 14:15:48 +0200 | [diff] [blame] | 23 | #include "translate-all.h" |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 24 | |
| 25 | //#define DEBUG_MMAP |
| 26 | |
Blue Swirl | 1e6eec8 | 2009-09-05 10:14:07 +0000 | [diff] [blame] | 27 | static pthread_mutex_t mmap_mutex = PTHREAD_MUTEX_INITIALIZER; |
Juan Quintela | dfd3f85 | 2009-09-23 01:19:03 +0200 | [diff] [blame] | 28 | static __thread int mmap_lock_count; |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 29 | |
| 30 | void mmap_lock(void) |
| 31 | { |
| 32 | if (mmap_lock_count++ == 0) { |
| 33 | pthread_mutex_lock(&mmap_mutex); |
| 34 | } |
| 35 | } |
| 36 | |
| 37 | void mmap_unlock(void) |
| 38 | { |
| 39 | if (--mmap_lock_count == 0) { |
| 40 | pthread_mutex_unlock(&mmap_mutex); |
| 41 | } |
| 42 | } |
pbrook | d597536 | 2008-06-07 20:50:51 +0000 | [diff] [blame] | 43 | |
Alex Bennée | 301e40e | 2016-10-27 16:10:00 +0100 | [diff] [blame] | 44 | bool have_mmap_lock(void) |
| 45 | { |
| 46 | return mmap_lock_count > 0 ? true : false; |
| 47 | } |
| 48 | |
pbrook | d597536 | 2008-06-07 20:50:51 +0000 | [diff] [blame] | 49 | /* Grab lock to make sure things are in a consistent state after fork(). */ |
| 50 | void mmap_fork_start(void) |
| 51 | { |
| 52 | if (mmap_lock_count) |
| 53 | abort(); |
| 54 | pthread_mutex_lock(&mmap_mutex); |
| 55 | } |
| 56 | |
| 57 | void mmap_fork_end(int child) |
| 58 | { |
| 59 | if (child) |
| 60 | pthread_mutex_init(&mmap_mutex, NULL); |
| 61 | else |
| 62 | pthread_mutex_unlock(&mmap_mutex); |
| 63 | } |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 64 | |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 65 | /* NOTE: all the constants are the HOST ones, but addresses are target. */ |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 66 | int target_mprotect(abi_ulong start, abi_ulong len, int prot) |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 67 | { |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 68 | abi_ulong end, host_start, host_end, addr; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 69 | int prot1, ret; |
| 70 | |
| 71 | #ifdef DEBUG_MMAP |
Blue Swirl | 0bf9e31 | 2009-07-20 17:19:25 +0000 | [diff] [blame] | 72 | printf("mprotect: start=0x" TARGET_ABI_FMT_lx |
| 73 | "len=0x" TARGET_ABI_FMT_lx " prot=%c%c%c\n", start, len, |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 74 | prot & PROT_READ ? 'r' : '-', |
| 75 | prot & PROT_WRITE ? 'w' : '-', |
| 76 | prot & PROT_EXEC ? 'x' : '-'); |
| 77 | #endif |
| 78 | |
| 79 | if ((start & ~TARGET_PAGE_MASK) != 0) |
| 80 | return -EINVAL; |
| 81 | len = TARGET_PAGE_ALIGN(len); |
| 82 | end = start + len; |
| 83 | if (end < start) |
| 84 | return -EINVAL; |
balrog | 171cd1c | 2008-04-24 21:11:41 +0000 | [diff] [blame] | 85 | prot &= PROT_READ | PROT_WRITE | PROT_EXEC; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 86 | if (len == 0) |
| 87 | return 0; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 88 | |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 89 | mmap_lock(); |
bellard | 83fb7ad | 2004-07-05 21:25:26 +0000 | [diff] [blame] | 90 | host_start = start & qemu_host_page_mask; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 91 | host_end = HOST_PAGE_ALIGN(end); |
| 92 | if (start > host_start) { |
| 93 | /* handle host page containing start */ |
| 94 | prot1 = prot; |
| 95 | for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) { |
| 96 | prot1 |= page_get_flags(addr); |
| 97 | } |
bellard | 83fb7ad | 2004-07-05 21:25:26 +0000 | [diff] [blame] | 98 | if (host_end == host_start + qemu_host_page_size) { |
bellard | d418c81 | 2003-05-13 00:57:50 +0000 | [diff] [blame] | 99 | for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) { |
| 100 | prot1 |= page_get_flags(addr); |
| 101 | } |
| 102 | end = host_end; |
| 103 | } |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 104 | ret = mprotect(g2h(host_start), qemu_host_page_size, prot1 & PAGE_BITS); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 105 | if (ret != 0) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 106 | goto error; |
bellard | 83fb7ad | 2004-07-05 21:25:26 +0000 | [diff] [blame] | 107 | host_start += qemu_host_page_size; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 108 | } |
| 109 | if (end < host_end) { |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 110 | prot1 = prot; |
| 111 | for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) { |
| 112 | prot1 |= page_get_flags(addr); |
| 113 | } |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 114 | ret = mprotect(g2h(host_end - qemu_host_page_size), qemu_host_page_size, |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 115 | prot1 & PAGE_BITS); |
| 116 | if (ret != 0) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 117 | goto error; |
bellard | 83fb7ad | 2004-07-05 21:25:26 +0000 | [diff] [blame] | 118 | host_end -= qemu_host_page_size; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 119 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 120 | |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 121 | /* handle the pages in the middle */ |
| 122 | if (host_start < host_end) { |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 123 | ret = mprotect(g2h(host_start), host_end - host_start, prot); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 124 | if (ret != 0) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 125 | goto error; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 126 | } |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 127 | page_set_flags(start, start + len, prot | PAGE_VALID); |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 128 | mmap_unlock(); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 129 | return 0; |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 130 | error: |
| 131 | mmap_unlock(); |
| 132 | return ret; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | /* map an incomplete host page */ |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 136 | static int mmap_frag(abi_ulong real_start, |
| 137 | abi_ulong start, abi_ulong end, |
| 138 | int prot, int flags, int fd, abi_ulong offset) |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 139 | { |
ths | 80210bc | 2007-11-02 19:08:57 +0000 | [diff] [blame] | 140 | abi_ulong real_end, addr; |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 141 | void *host_start; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 142 | int prot1, prot_new; |
| 143 | |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 144 | real_end = real_start + qemu_host_page_size; |
| 145 | host_start = g2h(real_start); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 146 | |
| 147 | /* get the protection of the target pages outside the mapping */ |
| 148 | prot1 = 0; |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 149 | for(addr = real_start; addr < real_end; addr++) { |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 150 | if (addr < start || addr >= end) |
| 151 | prot1 |= page_get_flags(addr); |
| 152 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 153 | |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 154 | if (prot1 == 0) { |
| 155 | /* no page was there, so we allocate one */ |
ths | 80210bc | 2007-11-02 19:08:57 +0000 | [diff] [blame] | 156 | void *p = mmap(host_start, qemu_host_page_size, prot, |
| 157 | flags | MAP_ANONYMOUS, -1, 0); |
| 158 | if (p == MAP_FAILED) |
| 159 | return -1; |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 160 | prot1 = prot; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 161 | } |
| 162 | prot1 &= PAGE_BITS; |
| 163 | |
| 164 | prot_new = prot | prot1; |
| 165 | if (!(flags & MAP_ANONYMOUS)) { |
| 166 | /* msync() won't work here, so we return an error if write is |
| 167 | possible while it is a shared mapping */ |
| 168 | if ((flags & MAP_TYPE) == MAP_SHARED && |
| 169 | (prot & PROT_WRITE)) |
Juan Quintela | ee63650 | 2010-01-20 00:56:24 +0100 | [diff] [blame] | 170 | return -1; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 171 | |
| 172 | /* adjust protection to be able to read */ |
| 173 | if (!(prot1 & PROT_WRITE)) |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 174 | mprotect(host_start, qemu_host_page_size, prot1 | PROT_WRITE); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 175 | |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 176 | /* read the corresponding file data */ |
Kirill A. Shutemov | fb7e378 | 2010-01-20 00:56:20 +0100 | [diff] [blame] | 177 | if (pread(fd, g2h(start), end - start, offset) == -1) |
| 178 | return -1; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 179 | |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 180 | /* put final protection */ |
| 181 | if (prot_new != (prot1 | PROT_WRITE)) |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 182 | mprotect(host_start, qemu_host_page_size, prot_new); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 183 | } else { |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 184 | if (prot_new != prot1) { |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 185 | mprotect(host_start, qemu_host_page_size, prot_new); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 186 | } |
Chen Gang | e6deac9 | 2015-12-30 09:10:54 +0800 | [diff] [blame] | 187 | if (prot_new & PROT_WRITE) { |
| 188 | memset(g2h(start), 0, end - start); |
| 189 | } |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 190 | } |
| 191 | return 0; |
| 192 | } |
| 193 | |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 194 | #if HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 64 |
| 195 | # define TASK_UNMAPPED_BASE (1ul << 38) |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 196 | #else |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 197 | # define TASK_UNMAPPED_BASE 0x40000000 |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 198 | #endif |
Peter Maydell | 59e9d91 | 2012-03-08 14:40:33 +0000 | [diff] [blame] | 199 | abi_ulong mmap_next_start = TASK_UNMAPPED_BASE; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 200 | |
pbrook | 0776590 | 2008-05-31 16:33:53 +0000 | [diff] [blame] | 201 | unsigned long last_brk; |
| 202 | |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 203 | /* Subroutine of mmap_find_vma, used when we have pre-allocated a chunk |
| 204 | of guest address space. */ |
| 205 | static abi_ulong mmap_find_vma_reserved(abi_ulong start, abi_ulong size) |
| 206 | { |
| 207 | abi_ulong addr; |
Peter Maydell | 59e9d91 | 2012-03-08 14:40:33 +0000 | [diff] [blame] | 208 | abi_ulong end_addr; |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 209 | int prot; |
| 210 | int looped = 0; |
| 211 | |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 212 | if (size > reserved_va) { |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 213 | return (abi_ulong)-1; |
| 214 | } |
| 215 | |
Peter Maydell | 59e9d91 | 2012-03-08 14:40:33 +0000 | [diff] [blame] | 216 | size = HOST_PAGE_ALIGN(size); |
| 217 | end_addr = start + size; |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 218 | if (end_addr > reserved_va) { |
| 219 | end_addr = reserved_va; |
Peter Maydell | 59e9d91 | 2012-03-08 14:40:33 +0000 | [diff] [blame] | 220 | } |
| 221 | addr = end_addr - qemu_host_page_size; |
| 222 | |
| 223 | while (1) { |
| 224 | if (addr > end_addr) { |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 225 | if (looped) { |
| 226 | return (abi_ulong)-1; |
| 227 | } |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 228 | end_addr = reserved_va; |
Peter Maydell | 59e9d91 | 2012-03-08 14:40:33 +0000 | [diff] [blame] | 229 | addr = end_addr - qemu_host_page_size; |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 230 | looped = 1; |
| 231 | continue; |
| 232 | } |
| 233 | prot = page_get_flags(addr); |
| 234 | if (prot) { |
Peter Maydell | 59e9d91 | 2012-03-08 14:40:33 +0000 | [diff] [blame] | 235 | end_addr = addr; |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 236 | } |
Peter Maydell | 59e9d91 | 2012-03-08 14:40:33 +0000 | [diff] [blame] | 237 | if (addr + size == end_addr) { |
| 238 | break; |
| 239 | } |
| 240 | addr -= qemu_host_page_size; |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 241 | } |
Peter Maydell | 59e9d91 | 2012-03-08 14:40:33 +0000 | [diff] [blame] | 242 | |
| 243 | if (start == mmap_next_start) { |
| 244 | mmap_next_start = addr; |
| 245 | } |
| 246 | |
| 247 | return addr; |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 248 | } |
| 249 | |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 250 | /* |
| 251 | * Find and reserve a free memory area of size 'size'. The search |
| 252 | * starts at 'start'. |
| 253 | * It must be called with mmap_lock() held. |
| 254 | * Return -1 if error. |
| 255 | */ |
Riku Voipio | 9ad197d | 2009-04-21 17:23:23 +0300 | [diff] [blame] | 256 | abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size) |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 257 | { |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 258 | void *ptr, *prev; |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 259 | abi_ulong addr; |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 260 | int wrapped, repeat; |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 261 | |
| 262 | /* If 'start' == 0, then a default start address is used. */ |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 263 | if (start == 0) { |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 264 | start = mmap_next_start; |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 265 | } else { |
| 266 | start &= qemu_host_page_mask; |
| 267 | } |
| 268 | |
| 269 | size = HOST_PAGE_ALIGN(size); |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 270 | |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 271 | if (reserved_va) { |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 272 | return mmap_find_vma_reserved(start, size); |
| 273 | } |
| 274 | |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 275 | addr = start; |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 276 | wrapped = repeat = 0; |
| 277 | prev = 0; |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 278 | |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 279 | for (;; prev = ptr) { |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 280 | /* |
| 281 | * Reserve needed memory area to avoid a race. |
| 282 | * It should be discarded using: |
| 283 | * - mmap() with MAP_FIXED flag |
| 284 | * - mremap() with MREMAP_FIXED flag |
| 285 | * - shmat() with SHM_REMAP flag |
| 286 | */ |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 287 | ptr = mmap(g2h(addr), size, PROT_NONE, |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 288 | MAP_ANONYMOUS|MAP_PRIVATE|MAP_NORESERVE, -1, 0); |
| 289 | |
| 290 | /* ENOMEM, if host address space has no memory */ |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 291 | if (ptr == MAP_FAILED) { |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 292 | return (abi_ulong)-1; |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 293 | } |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 294 | |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 295 | /* Count the number of sequential returns of the same address. |
| 296 | This is used to modify the search algorithm below. */ |
| 297 | repeat = (ptr == prev ? repeat + 1 : 0); |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 298 | |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 299 | if (h2g_valid(ptr + size - 1)) { |
| 300 | addr = h2g(ptr); |
| 301 | |
| 302 | if ((addr & ~TARGET_PAGE_MASK) == 0) { |
| 303 | /* Success. */ |
| 304 | if (start == mmap_next_start && addr >= TASK_UNMAPPED_BASE) { |
| 305 | mmap_next_start = addr + size; |
| 306 | } |
| 307 | return addr; |
| 308 | } |
| 309 | |
| 310 | /* The address is not properly aligned for the target. */ |
| 311 | switch (repeat) { |
| 312 | case 0: |
| 313 | /* Assume the result that the kernel gave us is the |
| 314 | first with enough free space, so start again at the |
| 315 | next higher target page. */ |
| 316 | addr = TARGET_PAGE_ALIGN(addr); |
| 317 | break; |
| 318 | case 1: |
| 319 | /* Sometimes the kernel decides to perform the allocation |
| 320 | at the top end of memory instead. */ |
| 321 | addr &= TARGET_PAGE_MASK; |
| 322 | break; |
| 323 | case 2: |
| 324 | /* Start over at low memory. */ |
| 325 | addr = 0; |
| 326 | break; |
| 327 | default: |
| 328 | /* Fail. This unaligned block must the last. */ |
| 329 | addr = -1; |
| 330 | break; |
| 331 | } |
| 332 | } else { |
| 333 | /* Since the result the kernel gave didn't fit, start |
| 334 | again at low memory. If any repetition, fail. */ |
| 335 | addr = (repeat ? -1 : 0); |
| 336 | } |
| 337 | |
| 338 | /* Unmap and try again. */ |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 339 | munmap(ptr, size); |
Kirill A. Shutemov | fe3b415 | 2009-08-13 21:03:58 +0300 | [diff] [blame] | 340 | |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 341 | /* ENOMEM if we checked the whole of the target address space. */ |
Blue Swirl | d0b3e4f | 2010-09-18 05:53:14 +0000 | [diff] [blame] | 342 | if (addr == (abi_ulong)-1) { |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 343 | return (abi_ulong)-1; |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 344 | } else if (addr == 0) { |
| 345 | if (wrapped) { |
| 346 | return (abi_ulong)-1; |
| 347 | } |
| 348 | wrapped = 1; |
| 349 | /* Don't actually use 0 when wrapping, instead indicate |
Stefan Weil | 8186e78 | 2011-04-28 17:20:41 +0200 | [diff] [blame] | 350 | that we'd truly like an allocation in low memory. */ |
Richard Henderson | 14f24e1 | 2010-03-10 15:39:07 -0800 | [diff] [blame] | 351 | addr = (mmap_min_addr > TARGET_PAGE_SIZE |
| 352 | ? TARGET_PAGE_ALIGN(mmap_min_addr) |
| 353 | : TARGET_PAGE_SIZE); |
| 354 | } else if (wrapped && addr >= start) { |
| 355 | return (abi_ulong)-1; |
| 356 | } |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 357 | } |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 358 | } |
| 359 | |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 360 | /* NOTE: all the constants are the HOST ones */ |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 361 | abi_long target_mmap(abi_ulong start, abi_ulong len, int prot, |
| 362 | int flags, int fd, abi_ulong offset) |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 363 | { |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 364 | abi_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 365 | |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 366 | mmap_lock(); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 367 | #ifdef DEBUG_MMAP |
| 368 | { |
Blue Swirl | 0bf9e31 | 2009-07-20 17:19:25 +0000 | [diff] [blame] | 369 | printf("mmap: start=0x" TARGET_ABI_FMT_lx |
| 370 | " len=0x" TARGET_ABI_FMT_lx " prot=%c%c%c flags=", |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 371 | start, len, |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 372 | prot & PROT_READ ? 'r' : '-', |
| 373 | prot & PROT_WRITE ? 'w' : '-', |
| 374 | prot & PROT_EXEC ? 'x' : '-'); |
| 375 | if (flags & MAP_FIXED) |
| 376 | printf("MAP_FIXED "); |
| 377 | if (flags & MAP_ANONYMOUS) |
| 378 | printf("MAP_ANON "); |
| 379 | switch(flags & MAP_TYPE) { |
| 380 | case MAP_PRIVATE: |
| 381 | printf("MAP_PRIVATE "); |
| 382 | break; |
| 383 | case MAP_SHARED: |
| 384 | printf("MAP_SHARED "); |
| 385 | break; |
| 386 | default: |
| 387 | printf("[MAP_TYPE=0x%x] ", flags & MAP_TYPE); |
| 388 | break; |
| 389 | } |
Blue Swirl | 0bf9e31 | 2009-07-20 17:19:25 +0000 | [diff] [blame] | 390 | printf("fd=%d offset=" TARGET_ABI_FMT_lx "\n", fd, offset); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 391 | } |
| 392 | #endif |
| 393 | |
pbrook | e89f07d | 2006-02-04 20:46:24 +0000 | [diff] [blame] | 394 | if (offset & ~TARGET_PAGE_MASK) { |
| 395 | errno = EINVAL; |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 396 | goto fail; |
pbrook | e89f07d | 2006-02-04 20:46:24 +0000 | [diff] [blame] | 397 | } |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 398 | |
| 399 | len = TARGET_PAGE_ALIGN(len); |
| 400 | if (len == 0) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 401 | goto the_end; |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 402 | real_start = start & qemu_host_page_mask; |
Richard Henderson | a5e7ee4 | 2012-06-01 16:07:52 -0700 | [diff] [blame] | 403 | host_offset = offset & qemu_host_page_mask; |
| 404 | |
| 405 | /* If the user is asking for the kernel to find a location, do that |
| 406 | before we truncate the length for mapping files below. */ |
| 407 | if (!(flags & MAP_FIXED)) { |
| 408 | host_len = len + offset - host_offset; |
| 409 | host_len = HOST_PAGE_ALIGN(host_len); |
| 410 | start = mmap_find_vma(real_start, host_len); |
| 411 | if (start == (abi_ulong)-1) { |
| 412 | errno = ENOMEM; |
| 413 | goto fail; |
| 414 | } |
| 415 | } |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 416 | |
edgar_igl | 54c5a2a | 2009-02-03 23:06:34 +0000 | [diff] [blame] | 417 | /* When mapping files into a memory area larger than the file, accesses |
| 418 | to pages beyond the file size will cause a SIGBUS. |
| 419 | |
| 420 | For example, if mmaping a file of 100 bytes on a host with 4K pages |
| 421 | emulating a target with 8K pages, the target expects to be able to |
| 422 | access the first 8K. But the host will trap us on any access beyond |
| 423 | 4K. |
| 424 | |
| 425 | When emulating a target with a larger page-size than the hosts, we |
| 426 | may need to truncate file maps at EOF and add extra anonymous pages |
| 427 | up to the targets page boundary. */ |
| 428 | |
Marc-André Lureau | 35f2fd0 | 2017-01-19 10:15:33 -0500 | [diff] [blame] | 429 | if ((qemu_real_host_page_size < qemu_host_page_size) && |
| 430 | !(flags & MAP_ANONYMOUS)) { |
| 431 | struct stat sb; |
edgar_igl | 54c5a2a | 2009-02-03 23:06:34 +0000 | [diff] [blame] | 432 | |
| 433 | if (fstat (fd, &sb) == -1) |
| 434 | goto fail; |
| 435 | |
| 436 | /* Are we trying to create a map beyond EOF?. */ |
| 437 | if (offset + len > sb.st_size) { |
| 438 | /* If so, truncate the file map at eof aligned with |
| 439 | the hosts real pagesize. Additional anonymous maps |
| 440 | will be created beyond EOF. */ |
Paolo Bonzini | 0c2d70c | 2015-12-02 13:00:54 +0100 | [diff] [blame] | 441 | len = REAL_HOST_PAGE_ALIGN(sb.st_size - offset); |
edgar_igl | 54c5a2a | 2009-02-03 23:06:34 +0000 | [diff] [blame] | 442 | } |
| 443 | } |
| 444 | |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 445 | if (!(flags & MAP_FIXED)) { |
Richard Henderson | a5e7ee4 | 2012-06-01 16:07:52 -0700 | [diff] [blame] | 446 | unsigned long host_start; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 447 | void *p; |
Richard Henderson | a5e7ee4 | 2012-06-01 16:07:52 -0700 | [diff] [blame] | 448 | |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 449 | host_len = len + offset - host_offset; |
| 450 | host_len = HOST_PAGE_ALIGN(host_len); |
Richard Henderson | a5e7ee4 | 2012-06-01 16:07:52 -0700 | [diff] [blame] | 451 | |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 452 | /* Note: we prefer to control the mapping address. It is |
| 453 | especially important if qemu_host_page_size > |
| 454 | qemu_real_host_page_size */ |
Richard Henderson | a5e7ee4 | 2012-06-01 16:07:52 -0700 | [diff] [blame] | 455 | p = mmap(g2h(start), host_len, prot, |
| 456 | flags | MAP_FIXED | MAP_ANONYMOUS, -1, 0); |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 457 | if (p == MAP_FAILED) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 458 | goto fail; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 459 | /* update start so that it points to the file position at 'offset' */ |
| 460 | host_start = (unsigned long)p; |
edgar_igl | 54c5a2a | 2009-02-03 23:06:34 +0000 | [diff] [blame] | 461 | if (!(flags & MAP_ANONYMOUS)) { |
Richard Henderson | a5e7ee4 | 2012-06-01 16:07:52 -0700 | [diff] [blame] | 462 | p = mmap(g2h(start), len, prot, |
edgar_igl | 54c5a2a | 2009-02-03 23:06:34 +0000 | [diff] [blame] | 463 | flags | MAP_FIXED, fd, host_offset); |
JĂ¼rg Billeter | 8384274 | 2013-06-29 11:41:32 +0200 | [diff] [blame] | 464 | if (p == MAP_FAILED) { |
| 465 | munmap(g2h(start), host_len); |
| 466 | goto fail; |
| 467 | } |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 468 | host_start += offset - host_offset; |
edgar_igl | 54c5a2a | 2009-02-03 23:06:34 +0000 | [diff] [blame] | 469 | } |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 470 | start = h2g(host_start); |
| 471 | } else { |
| 472 | if (start & ~TARGET_PAGE_MASK) { |
pbrook | e89f07d | 2006-02-04 20:46:24 +0000 | [diff] [blame] | 473 | errno = EINVAL; |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 474 | goto fail; |
pbrook | e89f07d | 2006-02-04 20:46:24 +0000 | [diff] [blame] | 475 | } |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 476 | end = start + len; |
| 477 | real_end = HOST_PAGE_ALIGN(end); |
balrog | 7ab240a | 2008-04-26 12:17:34 +0000 | [diff] [blame] | 478 | |
aurel32 | 45bc1f5 | 2008-12-08 18:12:33 +0000 | [diff] [blame] | 479 | /* |
| 480 | * Test if requested memory area fits target address space |
| 481 | * It can fail only on 64-bit host with 32-bit target. |
| 482 | * On any other target/host host mmap() handles this error correctly. |
| 483 | */ |
| 484 | if ((unsigned long)start + len - 1 > (abi_ulong) -1) { |
| 485 | errno = EINVAL; |
| 486 | goto fail; |
| 487 | } |
| 488 | |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 489 | /* worst case: we cannot map the file because the offset is not |
| 490 | aligned, so we read it */ |
| 491 | if (!(flags & MAP_ANONYMOUS) && |
| 492 | (offset & ~qemu_host_page_mask) != (start & ~qemu_host_page_mask)) { |
| 493 | /* msync() won't work here, so we return an error if write is |
| 494 | possible while it is a shared mapping */ |
| 495 | if ((flags & MAP_TYPE) == MAP_SHARED && |
| 496 | (prot & PROT_WRITE)) { |
| 497 | errno = EINVAL; |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 498 | goto fail; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 499 | } |
| 500 | retaddr = target_mmap(start, len, prot | PROT_WRITE, |
| 501 | MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, |
| 502 | -1, 0); |
| 503 | if (retaddr == -1) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 504 | goto fail; |
Kirill A. Shutemov | fb7e378 | 2010-01-20 00:56:20 +0100 | [diff] [blame] | 505 | if (pread(fd, g2h(start), len, offset) == -1) |
| 506 | goto fail; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 507 | if (!(prot & PROT_WRITE)) { |
| 508 | ret = target_mprotect(start, len, prot); |
Paolo Bonzini | 86abac0 | 2015-09-14 12:31:44 +0200 | [diff] [blame] | 509 | assert(ret == 0); |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 510 | } |
| 511 | goto the_end; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 512 | } |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 513 | |
| 514 | /* handle the start of the mapping */ |
| 515 | if (start > real_start) { |
| 516 | if (real_end == real_start + qemu_host_page_size) { |
| 517 | /* one single host page */ |
| 518 | ret = mmap_frag(real_start, start, end, |
| 519 | prot, flags, fd, offset); |
| 520 | if (ret == -1) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 521 | goto fail; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 522 | goto the_end1; |
| 523 | } |
| 524 | ret = mmap_frag(real_start, start, real_start + qemu_host_page_size, |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 525 | prot, flags, fd, offset); |
| 526 | if (ret == -1) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 527 | goto fail; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 528 | real_start += qemu_host_page_size; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 529 | } |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 530 | /* handle the end of the mapping */ |
| 531 | if (end < real_end) { |
| 532 | ret = mmap_frag(real_end - qemu_host_page_size, |
Chen Gang | 530c003 | 2015-12-24 09:07:33 +0800 | [diff] [blame] | 533 | real_end - qemu_host_page_size, end, |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 534 | prot, flags, fd, |
| 535 | offset + real_end - qemu_host_page_size - start); |
| 536 | if (ret == -1) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 537 | goto fail; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 538 | real_end -= qemu_host_page_size; |
| 539 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 540 | |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 541 | /* map the middle (easier) */ |
| 542 | if (real_start < real_end) { |
| 543 | void *p; |
| 544 | unsigned long offset1; |
| 545 | if (flags & MAP_ANONYMOUS) |
| 546 | offset1 = 0; |
| 547 | else |
| 548 | offset1 = offset + real_start - start; |
| 549 | p = mmap(g2h(real_start), real_end - real_start, |
| 550 | prot, flags, fd, offset1); |
| 551 | if (p == MAP_FAILED) |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 552 | goto fail; |
bellard | a03e2d4 | 2007-11-14 11:29:07 +0000 | [diff] [blame] | 553 | } |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 554 | } |
| 555 | the_end1: |
| 556 | page_set_flags(start, start + len, prot | PAGE_VALID); |
| 557 | the_end: |
| 558 | #ifdef DEBUG_MMAP |
Blue Swirl | 0bf9e31 | 2009-07-20 17:19:25 +0000 | [diff] [blame] | 559 | printf("ret=0x" TARGET_ABI_FMT_lx "\n", start); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 560 | page_dump(stdout); |
| 561 | printf("\n"); |
| 562 | #endif |
Paolo Bonzini | 3586533 | 2015-04-22 14:20:35 +0200 | [diff] [blame] | 563 | tb_invalidate_phys_range(start, start + len); |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 564 | mmap_unlock(); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 565 | return start; |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 566 | fail: |
| 567 | mmap_unlock(); |
| 568 | return -1; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 569 | } |
| 570 | |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 571 | static void mmap_reserve(abi_ulong start, abi_ulong size) |
| 572 | { |
| 573 | abi_ulong real_start; |
| 574 | abi_ulong real_end; |
| 575 | abi_ulong addr; |
| 576 | abi_ulong end; |
| 577 | int prot; |
| 578 | |
| 579 | real_start = start & qemu_host_page_mask; |
| 580 | real_end = HOST_PAGE_ALIGN(start + size); |
| 581 | end = start + size; |
| 582 | if (start > real_start) { |
| 583 | /* handle host page containing start */ |
| 584 | prot = 0; |
| 585 | for (addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) { |
| 586 | prot |= page_get_flags(addr); |
| 587 | } |
| 588 | if (real_end == real_start + qemu_host_page_size) { |
| 589 | for (addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) { |
| 590 | prot |= page_get_flags(addr); |
| 591 | } |
| 592 | end = real_end; |
| 593 | } |
| 594 | if (prot != 0) |
| 595 | real_start += qemu_host_page_size; |
| 596 | } |
| 597 | if (end < real_end) { |
| 598 | prot = 0; |
| 599 | for (addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) { |
| 600 | prot |= page_get_flags(addr); |
| 601 | } |
| 602 | if (prot != 0) |
| 603 | real_end -= qemu_host_page_size; |
| 604 | } |
| 605 | if (real_start != real_end) { |
| 606 | mmap(g2h(real_start), real_end - real_start, PROT_NONE, |
| 607 | MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE, |
| 608 | -1, 0); |
| 609 | } |
| 610 | } |
| 611 | |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 612 | int target_munmap(abi_ulong start, abi_ulong len) |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 613 | { |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 614 | abi_ulong end, real_start, real_end, addr; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 615 | int prot, ret; |
| 616 | |
| 617 | #ifdef DEBUG_MMAP |
Blue Swirl | 0bf9e31 | 2009-07-20 17:19:25 +0000 | [diff] [blame] | 618 | printf("munmap: start=0x" TARGET_ABI_FMT_lx " len=0x" |
| 619 | TARGET_ABI_FMT_lx "\n", |
| 620 | start, len); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 621 | #endif |
| 622 | if (start & ~TARGET_PAGE_MASK) |
| 623 | return -EINVAL; |
| 624 | len = TARGET_PAGE_ALIGN(len); |
| 625 | if (len == 0) |
| 626 | return -EINVAL; |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 627 | mmap_lock(); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 628 | end = start + len; |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 629 | real_start = start & qemu_host_page_mask; |
| 630 | real_end = HOST_PAGE_ALIGN(end); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 631 | |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 632 | if (start > real_start) { |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 633 | /* handle host page containing start */ |
| 634 | prot = 0; |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 635 | for(addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) { |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 636 | prot |= page_get_flags(addr); |
| 637 | } |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 638 | if (real_end == real_start + qemu_host_page_size) { |
| 639 | for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) { |
bellard | d418c81 | 2003-05-13 00:57:50 +0000 | [diff] [blame] | 640 | prot |= page_get_flags(addr); |
| 641 | } |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 642 | end = real_end; |
bellard | d418c81 | 2003-05-13 00:57:50 +0000 | [diff] [blame] | 643 | } |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 644 | if (prot != 0) |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 645 | real_start += qemu_host_page_size; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 646 | } |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 647 | if (end < real_end) { |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 648 | prot = 0; |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 649 | for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) { |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 650 | prot |= page_get_flags(addr); |
| 651 | } |
| 652 | if (prot != 0) |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 653 | real_end -= qemu_host_page_size; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 654 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 655 | |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 656 | ret = 0; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 657 | /* unmap what we can */ |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 658 | if (real_start < real_end) { |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 659 | if (reserved_va) { |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 660 | mmap_reserve(real_start, real_end - real_start); |
| 661 | } else { |
| 662 | ret = munmap(g2h(real_start), real_end - real_start); |
| 663 | } |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 664 | } |
| 665 | |
Alexander Graf | 77a8f1a | 2012-05-10 22:40:10 +0000 | [diff] [blame] | 666 | if (ret == 0) { |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 667 | page_set_flags(start, start + len, 0); |
Paolo Bonzini | 3586533 | 2015-04-22 14:20:35 +0200 | [diff] [blame] | 668 | tb_invalidate_phys_range(start, start + len); |
Alexander Graf | 77a8f1a | 2012-05-10 22:40:10 +0000 | [diff] [blame] | 669 | } |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 670 | mmap_unlock(); |
| 671 | return ret; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 672 | } |
| 673 | |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 674 | abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size, |
| 675 | abi_ulong new_size, unsigned long flags, |
| 676 | abi_ulong new_addr) |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 677 | { |
| 678 | int prot; |
aurel32 | f19412a | 2008-12-08 18:12:40 +0000 | [diff] [blame] | 679 | void *host_addr; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 680 | |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 681 | mmap_lock(); |
aurel32 | f19412a | 2008-12-08 18:12:40 +0000 | [diff] [blame] | 682 | |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 683 | if (flags & MREMAP_FIXED) { |
Felix Janda | 52956a9 | 2016-09-30 19:39:27 -0400 | [diff] [blame] | 684 | host_addr = mremap(g2h(old_addr), old_size, new_size, |
| 685 | flags, g2h(new_addr)); |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 686 | |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 687 | if (reserved_va && host_addr != MAP_FAILED) { |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 688 | /* If new and old addresses overlap then the above mremap will |
| 689 | already have failed with EINVAL. */ |
| 690 | mmap_reserve(old_addr, old_size); |
| 691 | } |
| 692 | } else if (flags & MREMAP_MAYMOVE) { |
aurel32 | f19412a | 2008-12-08 18:12:40 +0000 | [diff] [blame] | 693 | abi_ulong mmap_start; |
| 694 | |
| 695 | mmap_start = mmap_find_vma(0, new_size); |
| 696 | |
| 697 | if (mmap_start == -1) { |
| 698 | errno = ENOMEM; |
| 699 | host_addr = MAP_FAILED; |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 700 | } else { |
Felix Janda | 52956a9 | 2016-09-30 19:39:27 -0400 | [diff] [blame] | 701 | host_addr = mremap(g2h(old_addr), old_size, new_size, |
| 702 | flags | MREMAP_FIXED, g2h(mmap_start)); |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 703 | if (reserved_va) { |
amateur | c65ffe6 | 2010-09-14 13:22:34 +0800 | [diff] [blame] | 704 | mmap_reserve(old_addr, old_size); |
| 705 | } |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 706 | } |
blueswir1 | 3af72a4 | 2008-12-15 17:58:49 +0000 | [diff] [blame] | 707 | } else { |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 708 | int prot = 0; |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 709 | if (reserved_va && old_size < new_size) { |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 710 | abi_ulong addr; |
| 711 | for (addr = old_addr + old_size; |
| 712 | addr < old_addr + new_size; |
| 713 | addr++) { |
| 714 | prot |= page_get_flags(addr); |
| 715 | } |
| 716 | } |
| 717 | if (prot == 0) { |
| 718 | host_addr = mremap(g2h(old_addr), old_size, new_size, flags); |
Laurent Vivier | b76f21a | 2015-08-24 14:53:54 +0200 | [diff] [blame] | 719 | if (host_addr != MAP_FAILED && reserved_va && old_size > new_size) { |
Paul Brook | 68a1c81 | 2010-05-29 02:27:35 +0100 | [diff] [blame] | 720 | mmap_reserve(old_addr + old_size, new_size - old_size); |
| 721 | } |
| 722 | } else { |
| 723 | errno = ENOMEM; |
| 724 | host_addr = MAP_FAILED; |
| 725 | } |
aurel32 | f19412a | 2008-12-08 18:12:40 +0000 | [diff] [blame] | 726 | /* Check if address fits target address space */ |
| 727 | if ((unsigned long)host_addr + new_size > (abi_ulong)-1) { |
| 728 | /* Revert mremap() changes */ |
| 729 | host_addr = mremap(g2h(old_addr), new_size, old_size, flags); |
| 730 | errno = ENOMEM; |
| 731 | host_addr = MAP_FAILED; |
| 732 | } |
| 733 | } |
| 734 | |
| 735 | if (host_addr == MAP_FAILED) { |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 736 | new_addr = -1; |
| 737 | } else { |
| 738 | new_addr = h2g(host_addr); |
| 739 | prot = page_get_flags(old_addr); |
| 740 | page_set_flags(old_addr, old_addr + old_size, 0); |
| 741 | page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID); |
| 742 | } |
Paolo Bonzini | 3586533 | 2015-04-22 14:20:35 +0200 | [diff] [blame] | 743 | tb_invalidate_phys_range(new_addr, new_addr + new_size); |
pbrook | c8a706f | 2008-06-02 16:16:42 +0000 | [diff] [blame] | 744 | mmap_unlock(); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 745 | return new_addr; |
| 746 | } |
| 747 | |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 748 | int target_msync(abi_ulong start, abi_ulong len, int flags) |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 749 | { |
blueswir1 | 992f48a | 2007-10-14 16:27:31 +0000 | [diff] [blame] | 750 | abi_ulong end; |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 751 | |
| 752 | if (start & ~TARGET_PAGE_MASK) |
| 753 | return -EINVAL; |
| 754 | len = TARGET_PAGE_ALIGN(len); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 755 | end = start + len; |
bellard | d418c81 | 2003-05-13 00:57:50 +0000 | [diff] [blame] | 756 | if (end < start) |
| 757 | return -EINVAL; |
| 758 | if (end == start) |
| 759 | return 0; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 760 | |
bellard | 83fb7ad | 2004-07-05 21:25:26 +0000 | [diff] [blame] | 761 | start &= qemu_host_page_mask; |
pbrook | 53a5960 | 2006-03-25 19:31:22 +0000 | [diff] [blame] | 762 | return msync(g2h(start), end - start, flags); |
bellard | 5493600 | 2003-05-13 00:25:15 +0000 | [diff] [blame] | 763 | } |