exec.c

   1 /*
   2  *  virtual page mapping and translated block handling
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library 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 GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include "config.h"
  20 #ifdef _WIN32
  21 #include <windows.h>
  22 #else
  23 #include <sys/types.h>
  24 #include <sys/mman.h>
  25 #endif
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #include <unistd.h>
  32 #include <inttypes.h>
  33
  34 #include "cpu.h"
  35 #include "exec-all.h"
  36 #include "qemu-common.h"
  37 #include "tcg.h"
  38 #include "hw/hw.h"
  39 #include "osdep.h"
  40 #include "kvm.h"
  41 #include "qemu-timer.h"
  42 #if defined(CONFIG_USER_ONLY)
  43 #include <qemu.h>
  44 #include <signal.h>
  45 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  46 #include <sys/param.h>
  47 #if __FreeBSD_version >= 700104
  48 #define HAVE_KINFO_GETVMMAP
  49 #define sigqueue sigqueue_freebsd  /* avoid redefinition */
  50 #include <sys/time.h>
  51 #include <sys/proc.h>
  52 #include <machine/profile.h>
  53 #define _KERNEL
  54 #include <sys/user.h>
  55 #undef _KERNEL
  56 #undef sigqueue
  57 #include <libutil.h>
  58 #endif
  59 #endif
  60 #endif
  61
  62 //#define DEBUG_TB_INVALIDATE
  63 //#define DEBUG_FLUSH
  64 //#define DEBUG_TLB
  65 //#define DEBUG_UNASSIGNED
  66
  67 /* make various TB consistency checks */
  68 //#define DEBUG_TB_CHECK
  69 //#define DEBUG_TLB_CHECK
  70
  71 //#define DEBUG_IOPORT
  72 //#define DEBUG_SUBPAGE
  73
  74 #if !defined(CONFIG_USER_ONLY)
  75 /* TB consistency checks only implemented for usermode emulation.  */
  76 #undef DEBUG_TB_CHECK
  77 #endif
  78
  79 #define SMC_BITMAP_USE_THRESHOLD 10
  80
  81 static TranslationBlock *tbs;
  82 int code_gen_max_blocks;
  83 TranslationBlock *tb_phys_hash[CODE_GEN_PHYS_HASH_SIZE];
  84 static int nb_tbs;
  85 /* any access to the tbs or the page table must use this lock */
  86 spinlock_t tb_lock = SPIN_LOCK_UNLOCKED;
  87
  88 #if defined(__arm__) || defined(__sparc_v9__)
  89 /* The prologue must be reachable with a direct jump. ARM and Sparc64
  90  have limited branch ranges (possibly also PPC) so place it in a
  91  section close to code segment. */
  92 #define code_gen_section                                \
  93     __attribute__((__section__(".gen_code")))           \
  94     __attribute__((aligned (32)))
  95 #elif defined(_WIN32)
  96 /* Maximum alignment for Win32 is 16. */
  97 #define code_gen_section                                \
  98     __attribute__((aligned (16)))
  99 #else
 100 #define code_gen_section                                \
 101     __attribute__((aligned (32)))
 102 #endif
 103
 104 uint8_t code_gen_prologue[1024] code_gen_section;
 105 static uint8_t *code_gen_buffer;
 106 static unsigned long code_gen_buffer_size;
 107 /* threshold to flush the translated code buffer */
 108 static unsigned long code_gen_buffer_max_size;
 109 uint8_t *code_gen_ptr;
 110
 111 #if !defined(CONFIG_USER_ONLY)
 112 int phys_ram_fd;
 113 uint8_t *phys_ram_dirty;
 114 static int in_migration;
 115
 116 typedef struct RAMBlock {
 117     uint8_t *host;
 118     ram_addr_t offset;
 119     ram_addr_t length;
 120     struct RAMBlock *next;
 121 } RAMBlock;
 122
 123 static RAMBlock *ram_blocks;
 124 /* TODO: When we implement (and use) ram deallocation (e.g. for hotplug)
 125    then we can no longer assume contiguous ram offsets, and external uses
 126    of this variable will break.  */
 127 ram_addr_t last_ram_offset;
 128 #endif
 129
 130 CPUState *first_cpu;
 131 /* current CPU in the current thread. It is only valid inside
 132    cpu_exec() */
 133 CPUState *cpu_single_env;
 134 /* 0 = Do not count executed instructions.
 135    1 = Precise instruction counting.
 136    2 = Adaptive rate instruction counting.  */
 137 int use_icount = 0;
 138 /* Current instruction counter.  While executing translated code this may
 139    include some instructions that have not yet been executed.  */
 140 int64_t qemu_icount;
 141
 142 typedef struct PageDesc {
 143     /* list of TBs intersecting this ram page */
 144     TranslationBlock *first_tb;
 145     /* in order to optimize self modifying code, we count the number
 146        of lookups we do to a given page to use a bitmap */
 147     unsigned int code_write_count;
 148     uint8_t *code_bitmap;
 149 #if defined(CONFIG_USER_ONLY)
 150     unsigned long flags;
 151 #endif
 152 } PageDesc;
 153
 154 /* In system mode we want L1_MAP to be based on ram offsets,
 155    while in user mode we want it to be based on virtual addresses.  */
 156 #if !defined(CONFIG_USER_ONLY)
 157 #if HOST_LONG_BITS < TARGET_PHYS_ADDR_SPACE_BITS
 158 # define L1_MAP_ADDR_SPACE_BITS  HOST_LONG_BITS
 159 #else
 160 # define L1_MAP_ADDR_SPACE_BITS  TARGET_PHYS_ADDR_SPACE_BITS
 161 #endif
 162 #else
 163 # define L1_MAP_ADDR_SPACE_BITS  TARGET_VIRT_ADDR_SPACE_BITS
 164 #endif
 165
 166 /* Size of the L2 (and L3, etc) page tables.  */
 167 #define L2_BITS 10
 168 #define L2_SIZE (1 << L2_BITS)
 169
 170 /* The bits remaining after N lower levels of page tables.  */
 171 #define P_L1_BITS_REM \
 172     ((TARGET_PHYS_ADDR_SPACE_BITS - TARGET_PAGE_BITS) % L2_BITS)
 173 #define V_L1_BITS_REM \
 174     ((L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS) % L2_BITS)
 175
 176 /* Size of the L1 page table.  Avoid silly small sizes.  */
 177 #if P_L1_BITS_REM < 4
 178 #define P_L1_BITS  (P_L1_BITS_REM + L2_BITS)
 179 #else
 180 #define P_L1_BITS  P_L1_BITS_REM
 181 #endif
 182
 183 #if V_L1_BITS_REM < 4
 184 #define V_L1_BITS  (V_L1_BITS_REM + L2_BITS)
 185 #else
 186 #define V_L1_BITS  V_L1_BITS_REM
 187 #endif
 188
 189 #define P_L1_SIZE  ((target_phys_addr_t)1 << P_L1_BITS)
 190 #define V_L1_SIZE  ((target_ulong)1 << V_L1_BITS)
 191
 192 #define P_L1_SHIFT (TARGET_PHYS_ADDR_SPACE_BITS - TARGET_PAGE_BITS - P_L1_BITS)
 193 #define V_L1_SHIFT (L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS - V_L1_BITS)
 194
 195 unsigned long qemu_real_host_page_size;
 196 unsigned long qemu_host_page_bits;
 197 unsigned long qemu_host_page_size;
 198 unsigned long qemu_host_page_mask;
 199
 200 /* This is a multi-level map on the virtual address space.
 201    The bottom level has pointers to PageDesc.  */
 202 static void *l1_map[V_L1_SIZE];
 203
 204 #if !defined(CONFIG_USER_ONLY)
 205 typedef struct PhysPageDesc {
 206     /* offset in host memory of the page + io_index in the low bits */
 207     ram_addr_t phys_offset;
 208     ram_addr_t region_offset;
 209 } PhysPageDesc;
 210
 211 /* This is a multi-level map on the physical address space.
 212    The bottom level has pointers to PhysPageDesc.  */
 213 static void *l1_phys_map[P_L1_SIZE];
 214
 215 static void io_mem_init(void);
 216
 217 /* io memory support */
 218 CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
 219 CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
 220 void *io_mem_opaque[IO_MEM_NB_ENTRIES];
 221 static char io_mem_used[IO_MEM_NB_ENTRIES];
 222 static int io_mem_watch;
 223 #endif
 224
 225 /* log support */
 226 #ifdef WIN32
 227 static const char *logfilename = "qemu.log";
 228 #else
 229 static const char *logfilename = "/tmp/qemu.log";
 230 #endif
 231 FILE *logfile;
 232 int loglevel;
 233 static int log_append = 0;
 234
 235 /* statistics */
 236 #if !defined(CONFIG_USER_ONLY)
 237 static int tlb_flush_count;
 238 #endif
 239 static int tb_flush_count;
 240 static int tb_phys_invalidate_count;
 241
 242 #ifdef _WIN32
 243 static void map_exec(void *addr, long size)
 244 {
 245     DWORD old_protect;
 246     VirtualProtect(addr, size,
 247                    PAGE_EXECUTE_READWRITE, &old_protect);
 248
 249 }
 250 #else
 251 static void map_exec(void *addr, long size)
 252 {
 253     unsigned long start, end, page_size;
 254
 255     page_size = getpagesize();
 256     start = (unsigned long)addr;
 257     start &= ~(page_size - 1);
 258
 259     end = (unsigned long)addr + size;
 260     end += page_size - 1;
 261     end &= ~(page_size - 1);
 262
 263     mprotect((void *)start, end - start,
 264              PROT_READ | PROT_WRITE | PROT_EXEC);
 265 }
 266 #endif
 267
 268 static void page_init(void)
 269 {
 270     /* NOTE: we can always suppose that qemu_host_page_size >=
 271        TARGET_PAGE_SIZE */
 272 #ifdef _WIN32
 273     {
 274         SYSTEM_INFO system_info;
 275
 276         GetSystemInfo(&system_info);
 277         qemu_real_host_page_size = system_info.dwPageSize;
 278     }
 279 #else
 280     qemu_real_host_page_size = getpagesize();
 281 #endif
 282     if (qemu_host_page_size == 0)
 283         qemu_host_page_size = qemu_real_host_page_size;
 284     if (qemu_host_page_size < TARGET_PAGE_SIZE)
 285         qemu_host_page_size = TARGET_PAGE_SIZE;
 286     qemu_host_page_bits = 0;
 287     while ((1 << qemu_host_page_bits) < qemu_host_page_size)
 288         qemu_host_page_bits++;
 289     qemu_host_page_mask = ~(qemu_host_page_size - 1);
 290
 291 #if !defined(_WIN32) && defined(CONFIG_USER_ONLY)
 292     {
 293 #ifdef HAVE_KINFO_GETVMMAP
 294         struct kinfo_vmentry *freep;
 295         int i, cnt;
 296
 297         freep = kinfo_getvmmap(getpid(), &cnt);
 298         if (freep) {
 299             mmap_lock();
 300             for (i = 0; i < cnt; i++) {
 301                 unsigned long startaddr, endaddr;
 302
 303                 startaddr = freep[i].kve_start;
 304                 endaddr = freep[i].kve_end;
 305                 if (h2g_valid(startaddr)) {
 306                     startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
 307
 308                     if (h2g_valid(endaddr)) {
 309                         endaddr = h2g(endaddr);
 310                         page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 311                     } else {
 312 #if TARGET_ABI_BITS <= L1_MAP_ADDR_SPACE_BITS
 313                         endaddr = ~0ul;
 314                         page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 315 #endif
 316                     }
 317                 }
 318             }
 319             free(freep);
 320             mmap_unlock();
 321         }
 322 #else
 323         FILE *f;
 324
 325         last_brk = (unsigned long)sbrk(0);
 326
 327 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
 328         f = fopen("/compat/linux/proc/self/maps", "r");
 329 #else
 330         f = fopen("/proc/self/maps", "r");
 331 #endif
 332         if (f) {
 333             mmap_lock();
 334
 335             do {
 336                 unsigned long startaddr, endaddr;
 337                 int n;
 338
 339                 n = fscanf (f, "%lx-%lx %*[^\n]\n", &startaddr, &endaddr);
 340
 341                 if (n == 2 && h2g_valid(startaddr)) {
 342                     startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
 343
 344                     if (h2g_valid(endaddr)) {
 345                         endaddr = h2g(endaddr);
 346                     } else {
 347                         endaddr = ~0ul;
 348                     }
 349                     page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 350                 }
 351             } while (!feof(f));
 352
 353             fclose(f);
 354             mmap_unlock();
 355         }
 356 #endif
 357     }
 358 #endif
 359 }
 360
 361 static PageDesc *page_find_alloc(tb_page_addr_t index, int alloc)
 362 {
 363     PageDesc *pd;
 364     void **lp;
 365     int i;
 366
 367 #if defined(CONFIG_USER_ONLY)
 368     /* We can't use qemu_malloc because it may recurse into a locked mutex.
 369        Neither can we record the new pages we reserve while allocating a
 370        given page because that may recurse into an unallocated page table
 371        entry.  Stuff the allocations we do make into a queue and process
 372        them after having completed one entire page table allocation.  */
 373
 374     unsigned long reserve[2 * (V_L1_SHIFT / L2_BITS)];
 375     int reserve_idx = 0;
 376
 377 # define ALLOC(P, SIZE)                                 \
 378     do {                                                \
 379         P = mmap(NULL, SIZE, PROT_READ | PROT_WRITE,    \
 380                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);   \
 381         if (h2g_valid(P)) {                             \
 382             reserve[reserve_idx] = h2g(P);              \
 383             reserve[reserve_idx + 1] = SIZE;            \
 384             reserve_idx += 2;                           \
 385         }                                               \
 386     } while (0)
 387 #else
 388 # define ALLOC(P, SIZE) \
 389     do { P = qemu_mallocz(SIZE); } while (0)
 390 #endif
 391
 392     /* Level 1.  Always allocated.  */
 393     lp = l1_map + ((index >> V_L1_SHIFT) & (V_L1_SIZE - 1));
 394
 395     /* Level 2..N-1.  */
 396     for (i = V_L1_SHIFT / L2_BITS - 1; i > 0; i--) {
 397         void **p = *lp;
 398
 399         if (p == NULL) {
 400             if (!alloc) {
 401                 return NULL;
 402             }
 403             ALLOC(p, sizeof(void *) * L2_SIZE);
 404             *lp = p;
 405         }
 406
 407         lp = p + ((index >> (i * L2_BITS)) & (L2_SIZE - 1));
 408     }
 409
 410     pd = *lp;
 411     if (pd == NULL) {
 412         if (!alloc) {
 413             return NULL;
 414         }
 415         ALLOC(pd, sizeof(PageDesc) * L2_SIZE);
 416         *lp = pd;
 417     }
 418
 419 #undef ALLOC
 420 #if defined(CONFIG_USER_ONLY)
 421     for (i = 0; i < reserve_idx; i += 2) {
 422         unsigned long addr = reserve[i];
 423         unsigned long len = reserve[i + 1];
 424
 425         page_set_flags(addr & TARGET_PAGE_MASK,
 426                        TARGET_PAGE_ALIGN(addr + len),
 427                        PAGE_RESERVED);
 428     }
 429 #endif
 430
 431     return pd + (index & (L2_SIZE - 1));
 432 }
 433
 434 static inline PageDesc *page_find(tb_page_addr_t index)
 435 {
 436     return page_find_alloc(index, 0);
 437 }
 438
 439 #if !defined(CONFIG_USER_ONLY)
 440 static PhysPageDesc *phys_page_find_alloc(target_phys_addr_t index, int alloc)
 441 {
 442     PhysPageDesc *pd;
 443     void **lp;
 444     int i;
 445
 446     /* Level 1.  Always allocated.  */
 447     lp = l1_phys_map + ((index >> P_L1_SHIFT) & (P_L1_SIZE - 1));
 448
 449     /* Level 2..N-1.  */
 450     for (i = P_L1_SHIFT / L2_BITS - 1; i > 0; i--) {
 451         void **p = *lp;
 452         if (p == NULL) {
 453             if (!alloc) {
 454                 return NULL;
 455             }
 456             *lp = p = qemu_mallocz(sizeof(void *) * L2_SIZE);
 457         }
 458         lp = p + ((index >> (i * L2_BITS)) & (L2_SIZE - 1));
 459     }
 460
 461     pd = *lp;
 462     if (pd == NULL) {
 463         int i;
 464
 465         if (!alloc) {
 466             return NULL;
 467         }
 468
 469         *lp = pd = qemu_malloc(sizeof(PhysPageDesc) * L2_SIZE);
 470
 471         for (i = 0; i < L2_SIZE; i++) {
 472             pd[i].phys_offset = IO_MEM_UNASSIGNED;
 473             pd[i].region_offset = (index + i) << TARGET_PAGE_BITS;
 474         }
 475     }
 476
 477     return pd + (index & (L2_SIZE - 1));
 478 }
 479
 480 static inline PhysPageDesc *phys_page_find(target_phys_addr_t index)
 481 {
 482     return phys_page_find_alloc(index, 0);
 483 }
 484
 485 static void tlb_protect_code(ram_addr_t ram_addr);
 486 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
 487                                     target_ulong vaddr);
 488 #define mmap_lock() do { } while(0)
 489 #define mmap_unlock() do { } while(0)
 490 #endif
 491
 492 #define DEFAULT_CODE_GEN_BUFFER_SIZE (32 * 1024 * 1024)
 493
 494 #if defined(CONFIG_USER_ONLY)
 495 /* Currently it is not recommended to allocate big chunks of data in
 496    user mode. It will change when a dedicated libc will be used */
 497 #define USE_STATIC_CODE_GEN_BUFFER
 498 #endif
 499
 500 #ifdef USE_STATIC_CODE_GEN_BUFFER
 501 static uint8_t static_code_gen_buffer[DEFAULT_CODE_GEN_BUFFER_SIZE];
 502 #endif
 503
 504 static void code_gen_alloc(unsigned long tb_size)
 505 {
 506 #ifdef USE_STATIC_CODE_GEN_BUFFER
 507     code_gen_buffer = static_code_gen_buffer;
 508     code_gen_buffer_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
 509     map_exec(code_gen_buffer, code_gen_buffer_size);
 510 #else
 511     code_gen_buffer_size = tb_size;
 512     if (code_gen_buffer_size == 0) {
 513 #if defined(CONFIG_USER_ONLY)
 514         /* in user mode, phys_ram_size is not meaningful */
 515         code_gen_buffer_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
 516 #else
 517         /* XXX: needs adjustments */
 518         code_gen_buffer_size = (unsigned long)(ram_size / 4);
 519 #endif
 520     }
 521     if (code_gen_buffer_size < MIN_CODE_GEN_BUFFER_SIZE)
 522         code_gen_buffer_size = MIN_CODE_GEN_BUFFER_SIZE;
 523     /* The code gen buffer location may have constraints depending on
 524        the host cpu and OS */
 525 #if defined(__linux__)
 526     {
 527         int flags;
 528         void *start = NULL;
 529
 530         flags = MAP_PRIVATE | MAP_ANONYMOUS;
 531 #if defined(__x86_64__)
 532         flags |= MAP_32BIT;
 533         /* Cannot map more than that */
 534         if (code_gen_buffer_size > (800 * 1024 * 1024))
 535             code_gen_buffer_size = (800 * 1024 * 1024);
 536 #elif defined(__sparc_v9__)
 537         // Map the buffer below 2G, so we can use direct calls and branches
 538         flags |= MAP_FIXED;
 539         start = (void *) 0x60000000UL;
 540         if (code_gen_buffer_size > (512 * 1024 * 1024))
 541             code_gen_buffer_size = (512 * 1024 * 1024);
 542 #elif defined(__arm__)
 543         /* Map the buffer below 32M, so we can use direct calls and branches */
 544         flags |= MAP_FIXED;
 545         start = (void *) 0x01000000UL;
 546         if (code_gen_buffer_size > 16 * 1024 * 1024)
 547             code_gen_buffer_size = 16 * 1024 * 1024;
 548 #endif
 549         code_gen_buffer = mmap(start, code_gen_buffer_size,
 550                                PROT_WRITE | PROT_READ | PROT_EXEC,
 551                                flags, -1, 0);
 552         if (code_gen_buffer == MAP_FAILED) {
 553             fprintf(stderr, "Could not allocate dynamic translator buffer\n");
 554             exit(1);
 555         }
 556     }
 557 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
 558     {
 559         int flags;
 560         void *addr = NULL;
 561         flags = MAP_PRIVATE | MAP_ANONYMOUS;
 562 #if defined(__x86_64__)
 563         /* FreeBSD doesn't have MAP_32BIT, use MAP_FIXED and assume
 564          * 0x40000000 is free */
 565         flags |= MAP_FIXED;
 566         addr = (void *)0x40000000;
 567         /* Cannot map more than that */
 568         if (code_gen_buffer_size > (800 * 1024 * 1024))
 569             code_gen_buffer_size = (800 * 1024 * 1024);
 570 #endif
 571         code_gen_buffer = mmap(addr, code_gen_buffer_size,
 572                                PROT_WRITE | PROT_READ | PROT_EXEC,
 573                                flags, -1, 0);
 574         if (code_gen_buffer == MAP_FAILED) {
 575             fprintf(stderr, "Could not allocate dynamic translator buffer\n");
 576             exit(1);
 577         }
 578     }
 579 #else
 580     code_gen_buffer = qemu_malloc(code_gen_buffer_size);
 581     map_exec(code_gen_buffer, code_gen_buffer_size);
 582 #endif
 583 #endif /* !USE_STATIC_CODE_GEN_BUFFER */
 584     map_exec(code_gen_prologue, sizeof(code_gen_prologue));
 585     code_gen_buffer_max_size = code_gen_buffer_size -
 586         code_gen_max_block_size();
 587     code_gen_max_blocks = code_gen_buffer_size / CODE_GEN_AVG_BLOCK_SIZE;
 588     tbs = qemu_malloc(code_gen_max_blocks * sizeof(TranslationBlock));
 589 }
 590
 591 /* Must be called before using the QEMU cpus. 'tb_size' is the size
 592    (in bytes) allocated to the translation buffer. Zero means default
 593    size. */
 594 void cpu_exec_init_all(unsigned long tb_size)
 595 {
 596     cpu_gen_init();
 597     code_gen_alloc(tb_size);
 598     code_gen_ptr = code_gen_buffer;
 599     page_init();
 600 #if !defined(CONFIG_USER_ONLY)
 601     io_mem_init();
 602 #endif
 603 }
 604
 605 #if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
 606
 607 static int cpu_common_post_load(void *opaque, int version_id)
 608 {
 609     CPUState *env = opaque;
 610
 611     /* 0x01 was CPU_INTERRUPT_EXIT. This line can be removed when the
 612        version_id is increased. */
 613     env->interrupt_request &= ~0x01;
 614     tlb_flush(env, 1);
 615
 616     return 0;
 617 }
 618
 619 static const VMStateDescription vmstate_cpu_common = {
 620     .name = "cpu_common",
 621     .version_id = 1,
 622     .minimum_version_id = 1,
 623     .minimum_version_id_old = 1,
 624     .post_load = cpu_common_post_load,
 625     .fields      = (VMStateField []) {
 626         VMSTATE_UINT32(halted, CPUState),
 627         VMSTATE_UINT32(interrupt_request, CPUState),
 628         VMSTATE_END_OF_LIST()
 629     }
 630 };
 631 #endif
 632
 633 CPUState *qemu_get_cpu(int cpu)
 634 {
 635     CPUState *env = first_cpu;
 636
 637     while (env) {
 638         if (env->cpu_index == cpu)
 639             break;
 640         env = env->next_cpu;
 641     }
 642
 643     return env;
 644 }
 645
 646 void cpu_exec_init(CPUState *env)
 647 {
 648     CPUState **penv;
 649     int cpu_index;
 650
 651 #if defined(CONFIG_USER_ONLY)
 652     cpu_list_lock();
 653 #endif
 654     env->next_cpu = NULL;
 655     penv = &first_cpu;
 656     cpu_index = 0;
 657     while (*penv != NULL) {
 658         penv = &(*penv)->next_cpu;
 659         cpu_index++;
 660     }
 661     env->cpu_index = cpu_index;
 662     env->numa_node = 0;
 663     QTAILQ_INIT(&env->breakpoints);
 664     QTAILQ_INIT(&env->watchpoints);
 665     *penv = env;
 666 #if defined(CONFIG_USER_ONLY)
 667     cpu_list_unlock();
 668 #endif
 669 #if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
 670     vmstate_register(cpu_index, &vmstate_cpu_common, env);
 671     register_savevm("cpu", cpu_index, CPU_SAVE_VERSION,
 672                     cpu_save, cpu_load, env);
 673 #endif
 674 }
 675
 676 static inline void invalidate_page_bitmap(PageDesc *p)
 677 {
 678     if (p->code_bitmap) {
 679         qemu_free(p->code_bitmap);
 680         p->code_bitmap = NULL;
 681     }
 682     p->code_write_count = 0;
 683 }
 684
 685 /* Set to NULL all the 'first_tb' fields in all PageDescs. */
 686
 687 static void page_flush_tb_1 (int level, void **lp)
 688 {
 689     int i;
 690
 691     if (*lp == NULL) {
 692         return;
 693     }
 694     if (level == 0) {
 695         PageDesc *pd = *lp;
 696         for (i = 0; i < L2_SIZE; ++i) {
 697             pd[i].first_tb = NULL;
 698             invalidate_page_bitmap(pd + i);
 699         }
 700     } else {
 701         void **pp = *lp;
 702         for (i = 0; i < L2_SIZE; ++i) {
 703             page_flush_tb_1 (level - 1, pp + i);
 704         }
 705     }
 706 }
 707
 708 static void page_flush_tb(void)
 709 {
 710     int i;
 711     for (i = 0; i < V_L1_SIZE; i++) {
 712         page_flush_tb_1(V_L1_SHIFT / L2_BITS - 1, l1_map + i);
 713     }
 714 }
 715
 716 /* flush all the translation blocks */
 717 /* XXX: tb_flush is currently not thread safe */
 718 void tb_flush(CPUState *env1)
 719 {
 720     CPUState *env;
 721 #if defined(DEBUG_FLUSH)
 722     printf("qemu: flush code_size=%ld nb_tbs=%d avg_tb_size=%ld\n",
 723            (unsigned long)(code_gen_ptr - code_gen_buffer),
 724            nb_tbs, nb_tbs > 0 ?
 725            ((unsigned long)(code_gen_ptr - code_gen_buffer)) / nb_tbs : 0);
 726 #endif
 727     if ((unsigned long)(code_gen_ptr - code_gen_buffer) > code_gen_buffer_size)
 728         cpu_abort(env1, "Internal error: code buffer overflow\n");
 729
 730     nb_tbs = 0;
 731
 732     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 733         memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
 734     }
 735
 736     memset (tb_phys_hash, 0, CODE_GEN_PHYS_HASH_SIZE * sizeof (void *));
 737     page_flush_tb();
 738
 739     code_gen_ptr = code_gen_buffer;
 740     /* XXX: flush processor icache at this point if cache flush is
 741        expensive */
 742     tb_flush_count++;
 743 }
 744
 745 #ifdef DEBUG_TB_CHECK
 746
 747 static void tb_invalidate_check(target_ulong address)
 748 {
 749     TranslationBlock *tb;
 750     int i;
 751     address &= TARGET_PAGE_MASK;
 752     for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 753         for(tb = tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 754             if (!(address + TARGET_PAGE_SIZE <= tb->pc ||
 755                   address >= tb->pc + tb->size)) {
 756                 printf("ERROR invalidate: address=" TARGET_FMT_lx
 757                        " PC=%08lx size=%04x\n",
 758                        address, (long)tb->pc, tb->size);
 759             }
 760         }
 761     }
 762 }
 763
 764 /* verify that all the pages have correct rights for code */
 765 static void tb_page_check(void)
 766 {
 767     TranslationBlock *tb;
 768     int i, flags1, flags2;
 769
 770     for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 771         for(tb = tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 772             flags1 = page_get_flags(tb->pc);
 773             flags2 = page_get_flags(tb->pc + tb->size - 1);
 774             if ((flags1 & PAGE_WRITE) || (flags2 & PAGE_WRITE)) {
 775                 printf("ERROR page flags: PC=%08lx size=%04x f1=%x f2=%x\n",
 776                        (long)tb->pc, tb->size, flags1, flags2);
 777             }
 778         }
 779     }
 780 }
 781
 782 #endif
 783
 784 /* invalidate one TB */
 785 static inline void tb_remove(TranslationBlock **ptb, TranslationBlock *tb,
 786                              int next_offset)
 787 {
 788     TranslationBlock *tb1;
 789     for(;;) {
 790         tb1 = *ptb;
 791         if (tb1 == tb) {
 792             *ptb = *(TranslationBlock **)((char *)tb1 + next_offset);
 793             break;
 794         }
 795         ptb = (TranslationBlock **)((char *)tb1 + next_offset);
 796     }
 797 }
 798
 799 static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
 800 {
 801     TranslationBlock *tb1;
 802     unsigned int n1;
 803
 804     for(;;) {
 805         tb1 = *ptb;
 806         n1 = (long)tb1 & 3;
 807         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 808         if (tb1 == tb) {
 809             *ptb = tb1->page_next[n1];
 810             break;
 811         }
 812         ptb = &tb1->page_next[n1];
 813     }
 814 }
 815
 816 static inline void tb_jmp_remove(TranslationBlock *tb, int n)
 817 {
 818     TranslationBlock *tb1, **ptb;
 819     unsigned int n1;
 820
 821     ptb = &tb->jmp_next[n];
 822     tb1 = *ptb;
 823     if (tb1) {
 824         /* find tb(n) in circular list */
 825         for(;;) {
 826             tb1 = *ptb;
 827             n1 = (long)tb1 & 3;
 828             tb1 = (TranslationBlock *)((long)tb1 & ~3);
 829             if (n1 == n && tb1 == tb)
 830                 break;
 831             if (n1 == 2) {
 832                 ptb = &tb1->jmp_first;
 833             } else {
 834                 ptb = &tb1->jmp_next[n1];
 835             }
 836         }
 837         /* now we can suppress tb(n) from the list */
 838         *ptb = tb->jmp_next[n];
 839
 840         tb->jmp_next[n] = NULL;
 841     }
 842 }
 843
 844 /* reset the jump entry 'n' of a TB so that it is not chained to
 845    another TB */
 846 static inline void tb_reset_jump(TranslationBlock *tb, int n)
 847 {
 848     tb_set_jmp_target(tb, n, (unsigned long)(tb->tc_ptr + tb->tb_next_offset[n]));
 849 }
 850
 851 void tb_phys_invalidate(TranslationBlock *tb, tb_page_addr_t page_addr)
 852 {
 853     CPUState *env;
 854     PageDesc *p;
 855     unsigned int h, n1;
 856     tb_page_addr_t phys_pc;
 857     TranslationBlock *tb1, *tb2;
 858
 859     /* remove the TB from the hash list */
 860     phys_pc = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
 861     h = tb_phys_hash_func(phys_pc);
 862     tb_remove(&tb_phys_hash[h], tb,
 863               offsetof(TranslationBlock, phys_hash_next));
 864
 865     /* remove the TB from the page list */
 866     if (tb->page_addr[0] != page_addr) {
 867         p = page_find(tb->page_addr[0] >> TARGET_PAGE_BITS);
 868         tb_page_remove(&p->first_tb, tb);
 869         invalidate_page_bitmap(p);
 870     }
 871     if (tb->page_addr[1] != -1 && tb->page_addr[1] != page_addr) {
 872         p = page_find(tb->page_addr[1] >> TARGET_PAGE_BITS);
 873         tb_page_remove(&p->first_tb, tb);
 874         invalidate_page_bitmap(p);
 875     }
 876
 877     tb_invalidated_flag = 1;
 878
 879     /* remove the TB from the hash list */
 880     h = tb_jmp_cache_hash_func(tb->pc);
 881     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 882         if (env->tb_jmp_cache[h] == tb)
 883             env->tb_jmp_cache[h] = NULL;
 884     }
 885
 886     /* suppress this TB from the two jump lists */
 887     tb_jmp_remove(tb, 0);
 888     tb_jmp_remove(tb, 1);
 889
 890     /* suppress any remaining jumps to this TB */
 891     tb1 = tb->jmp_first;
 892     for(;;) {
 893         n1 = (long)tb1 & 3;
 894         if (n1 == 2)
 895             break;
 896         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 897         tb2 = tb1->jmp_next[n1];
 898         tb_reset_jump(tb1, n1);
 899         tb1->jmp_next[n1] = NULL;
 900         tb1 = tb2;
 901     }
 902     tb->jmp_first = (TranslationBlock *)((long)tb | 2); /* fail safe */
 903
 904     tb_phys_invalidate_count++;
 905 }
 906
 907 static inline void set_bits(uint8_t *tab, int start, int len)
 908 {
 909     int end, mask, end1;
 910
 911     end = start + len;
 912     tab += start >> 3;
 913     mask = 0xff << (start & 7);
 914     if ((start & ~7) == (end & ~7)) {
 915         if (start < end) {
 916             mask &= ~(0xff << (end & 7));
 917             *tab |= mask;
 918         }
 919     } else {
 920         *tab++ |= mask;
 921         start = (start + 8) & ~7;
 922         end1 = end & ~7;
 923         while (start < end1) {
 924             *tab++ = 0xff;
 925             start += 8;
 926         }
 927         if (start < end) {
 928             mask = ~(0xff << (end & 7));
 929             *tab |= mask;
 930         }
 931     }
 932 }
 933
 934 static void build_page_bitmap(PageDesc *p)
 935 {
 936     int n, tb_start, tb_end;
 937     TranslationBlock *tb;
 938
 939     p->code_bitmap = qemu_mallocz(TARGET_PAGE_SIZE / 8);
 940
 941     tb = p->first_tb;
 942     while (tb != NULL) {
 943         n = (long)tb & 3;
 944         tb = (TranslationBlock *)((long)tb & ~3);
 945         /* NOTE: this is subtle as a TB may span two physical pages */
 946         if (n == 0) {
 947             /* NOTE: tb_end may be after the end of the page, but
 948                it is not a problem */
 949             tb_start = tb->pc & ~TARGET_PAGE_MASK;
 950             tb_end = tb_start + tb->size;
 951             if (tb_end > TARGET_PAGE_SIZE)
 952                 tb_end = TARGET_PAGE_SIZE;
 953         } else {
 954             tb_start = 0;
 955             tb_end = ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
 956         }
 957         set_bits(p->code_bitmap, tb_start, tb_end - tb_start);
 958         tb = tb->page_next[n];
 959     }
 960 }
 961
 962 TranslationBlock *tb_gen_code(CPUState *env,
 963                               target_ulong pc, target_ulong cs_base,
 964                               int flags, int cflags)
 965 {
 966     TranslationBlock *tb;
 967     uint8_t *tc_ptr;
 968     tb_page_addr_t phys_pc, phys_page2;
 969     target_ulong virt_page2;
 970     int code_gen_size;
 971
 972     phys_pc = get_page_addr_code(env, pc);
 973     tb = tb_alloc(pc);
 974     if (!tb) {
 975         /* flush must be done */
 976         tb_flush(env);
 977         /* cannot fail at this point */
 978         tb = tb_alloc(pc);
 979         /* Don't forget to invalidate previous TB info.  */
 980         tb_invalidated_flag = 1;
 981     }
 982     tc_ptr = code_gen_ptr;
 983     tb->tc_ptr = tc_ptr;
 984     tb->cs_base = cs_base;
 985     tb->flags = flags;
 986     tb->cflags = cflags;
 987     cpu_gen_code(env, tb, &code_gen_size);
 988     code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
 989
 990     /* check next page if needed */
 991     virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
 992     phys_page2 = -1;
 993     if ((pc & TARGET_PAGE_MASK) != virt_page2) {
 994         phys_page2 = get_page_addr_code(env, virt_page2);
 995     }
 996     tb_link_page(tb, phys_pc, phys_page2);
 997     return tb;
 998 }
 999
1000 /* invalidate all TBs which intersect with the target physical page
1001    starting in range [start;end[. NOTE: start and end must refer to
1002    the same physical page. 'is_cpu_write_access' should be true if called
1003    from a real cpu write access: the virtual CPU will exit the current
1004    TB if code is modified inside this TB. */
1005 void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
1006                                    int is_cpu_write_access)
1007 {
1008     TranslationBlock *tb, *tb_next, *saved_tb;
1009     CPUState *env = cpu_single_env;
1010     tb_page_addr_t tb_start, tb_end;
1011     PageDesc *p;
1012     int n;
1013 #ifdef TARGET_HAS_PRECISE_SMC
1014     int current_tb_not_found = is_cpu_write_access;
1015     TranslationBlock *current_tb = NULL;
1016     int current_tb_modified = 0;
1017     target_ulong current_pc = 0;
1018     target_ulong current_cs_base = 0;
1019     int current_flags = 0;
1020 #endif /* TARGET_HAS_PRECISE_SMC */
1021
1022     p = page_find(start >> TARGET_PAGE_BITS);
1023     if (!p)
1024         return;
1025     if (!p->code_bitmap &&
1026         ++p->code_write_count >= SMC_BITMAP_USE_THRESHOLD &&
1027         is_cpu_write_access) {
1028         /* build code bitmap */
1029         build_page_bitmap(p);
1030     }
1031
1032     /* we remove all the TBs in the range [start, end[ */
1033     /* XXX: see if in some cases it could be faster to invalidate all the code */
1034     tb = p->first_tb;
1035     while (tb != NULL) {
1036         n = (long)tb & 3;
1037         tb = (TranslationBlock *)((long)tb & ~3);
1038         tb_next = tb->page_next[n];
1039         /* NOTE: this is subtle as a TB may span two physical pages */
1040         if (n == 0) {
1041             /* NOTE: tb_end may be after the end of the page, but
1042                it is not a problem */
1043             tb_start = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
1044             tb_end = tb_start + tb->size;
1045         } else {
1046             tb_start = tb->page_addr[1];
1047             tb_end = tb_start + ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
1048         }
1049         if (!(tb_end <= start || tb_start >= end)) {
1050 #ifdef TARGET_HAS_PRECISE_SMC
1051             if (current_tb_not_found) {
1052                 current_tb_not_found = 0;
1053                 current_tb = NULL;
1054                 if (env->mem_io_pc) {
1055                     /* now we have a real cpu fault */
1056                     current_tb = tb_find_pc(env->mem_io_pc);
1057                 }
1058             }
1059             if (current_tb == tb &&
1060                 (current_tb->cflags & CF_COUNT_MASK) != 1) {
1061                 /* If we are modifying the current TB, we must stop
1062                 its execution. We could be more precise by checking
1063                 that the modification is after the current PC, but it
1064                 would require a specialized function to partially
1065                 restore the CPU state */
1066
1067                 current_tb_modified = 1;
1068                 cpu_restore_state(current_tb, env,
1069                                   env->mem_io_pc, NULL);
1070                 cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1071                                      &current_flags);
1072             }
1073 #endif /* TARGET_HAS_PRECISE_SMC */
1074             /* we need to do that to handle the case where a signal
1075                occurs while doing tb_phys_invalidate() */
1076             saved_tb = NULL;
1077             if (env) {
1078                 saved_tb = env->current_tb;
1079                 env->current_tb = NULL;
1080             }
1081             tb_phys_invalidate(tb, -1);
1082             if (env) {
1083                 env->current_tb = saved_tb;
1084                 if (env->interrupt_request && env->current_tb)
1085                     cpu_interrupt(env, env->interrupt_request);
1086             }
1087         }
1088         tb = tb_next;
1089     }
1090 #if !defined(CONFIG_USER_ONLY)
1091     /* if no code remaining, no need to continue to use slow writes */
1092     if (!p->first_tb) {
1093         invalidate_page_bitmap(p);
1094         if (is_cpu_write_access) {
1095             tlb_unprotect_code_phys(env, start, env->mem_io_vaddr);
1096         }
1097     }
1098 #endif
1099 #ifdef TARGET_HAS_PRECISE_SMC
1100     if (current_tb_modified) {
1101         /* we generate a block containing just the instruction
1102            modifying the memory. It will ensure that it cannot modify
1103            itself */
1104         env->current_tb = NULL;
1105         tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);
1106         cpu_resume_from_signal(env, NULL);
1107     }
1108 #endif
1109 }
1110
1111 /* len must be <= 8 and start must be a multiple of len */
1112 static inline void tb_invalidate_phys_page_fast(tb_page_addr_t start, int len)
1113 {
1114     PageDesc *p;
1115     int offset, b;
1116 #if 0
1117     if (1) {
1118         qemu_log("modifying code at 0x%x size=%d EIP=%x PC=%08x\n",
1119                   cpu_single_env->mem_io_vaddr, len,
1120                   cpu_single_env->eip,
1121                   cpu_single_env->eip + (long)cpu_single_env->segs[R_CS].base);
1122     }
1123 #endif
1124     p = page_find(start >> TARGET_PAGE_BITS);
1125     if (!p)
1126         return;
1127     if (p->code_bitmap) {
1128         offset = start & ~TARGET_PAGE_MASK;
1129         b = p->code_bitmap[offset >> 3] >> (offset & 7);
1130         if (b & ((1 << len) - 1))
1131             goto do_invalidate;
1132     } else {
1133     do_invalidate:
1134         tb_invalidate_phys_page_range(start, start + len, 1);
1135     }
1136 }
1137
1138 #if !defined(CONFIG_SOFTMMU)
1139 static void tb_invalidate_phys_page(tb_page_addr_t addr,
1140                                     unsigned long pc, void *puc)
1141 {
1142     TranslationBlock *tb;
1143     PageDesc *p;
1144     int n;
1145 #ifdef TARGET_HAS_PRECISE_SMC
1146     TranslationBlock *current_tb = NULL;
1147     CPUState *env = cpu_single_env;
1148     int current_tb_modified = 0;
1149     target_ulong current_pc = 0;
1150     target_ulong current_cs_base = 0;
1151     int current_flags = 0;
1152 #endif
1153
1154     addr &= TARGET_PAGE_MASK;
1155     p = page_find(addr >> TARGET_PAGE_BITS);
1156     if (!p)
1157         return;
1158     tb = p->first_tb;
1159 #ifdef TARGET_HAS_PRECISE_SMC
1160     if (tb && pc != 0) {
1161         current_tb = tb_find_pc(pc);
1162     }
1163 #endif
1164     while (tb != NULL) {
1165         n = (long)tb & 3;
1166         tb = (TranslationBlock *)((long)tb & ~3);
1167 #ifdef TARGET_HAS_PRECISE_SMC
1168         if (current_tb == tb &&
1169             (current_tb->cflags & CF_COUNT_MASK) != 1) {
1170                 /* If we are modifying the current TB, we must stop
1171                    its execution. We could be more precise by checking
1172                    that the modification is after the current PC, but it
1173                    would require a specialized function to partially
1174                    restore the CPU state */
1175
1176             current_tb_modified = 1;
1177             cpu_restore_state(current_tb, env, pc, puc);
1178             cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1179                                  &current_flags);
1180         }
1181 #endif /* TARGET_HAS_PRECISE_SMC */
1182         tb_phys_invalidate(tb, addr);
1183         tb = tb->page_next[n];
1184     }
1185     p->first_tb = NULL;
1186 #ifdef TARGET_HAS_PRECISE_SMC
1187     if (current_tb_modified) {
1188         /* we generate a block containing just the instruction
1189            modifying the memory. It will ensure that it cannot modify
1190            itself */
1191         env->current_tb = NULL;
1192         tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);
1193         cpu_resume_from_signal(env, puc);
1194     }
1195 #endif
1196 }
1197 #endif
1198
1199 /* add the tb in the target page and protect it if necessary */
1200 static inline void tb_alloc_page(TranslationBlock *tb,
1201                                  unsigned int n, tb_page_addr_t page_addr)
1202 {
1203     PageDesc *p;
1204     TranslationBlock *last_first_tb;
1205
1206     tb->page_addr[n] = page_addr;
1207     p = page_find_alloc(page_addr >> TARGET_PAGE_BITS, 1);
1208     tb->page_next[n] = p->first_tb;
1209     last_first_tb = p->first_tb;
1210     p->first_tb = (TranslationBlock *)((long)tb | n);
1211     invalidate_page_bitmap(p);
1212
1213 #if defined(TARGET_HAS_SMC) || 1
1214
1215 #if defined(CONFIG_USER_ONLY)
1216     if (p->flags & PAGE_WRITE) {
1217         target_ulong addr;
1218         PageDesc *p2;
1219         int prot;
1220
1221         /* force the host page as non writable (writes will have a
1222            page fault + mprotect overhead) */
1223         page_addr &= qemu_host_page_mask;
1224         prot = 0;
1225         for(addr = page_addr; addr < page_addr + qemu_host_page_size;
1226             addr += TARGET_PAGE_SIZE) {
1227
1228             p2 = page_find (addr >> TARGET_PAGE_BITS);
1229             if (!p2)
1230                 continue;
1231             prot |= p2->flags;
1232             p2->flags &= ~PAGE_WRITE;
1233           }
1234         mprotect(g2h(page_addr), qemu_host_page_size,
1235                  (prot & PAGE_BITS) & ~PAGE_WRITE);
1236 #ifdef DEBUG_TB_INVALIDATE
1237         printf("protecting code page: 0x" TARGET_FMT_lx "\n",
1238                page_addr);
1239 #endif
1240     }
1241 #else
1242     /* if some code is already present, then the pages are already
1243        protected. So we handle the case where only the first TB is
1244        allocated in a physical page */
1245     if (!last_first_tb) {
1246         tlb_protect_code(page_addr);
1247     }
1248 #endif
1249
1250 #endif /* TARGET_HAS_SMC */
1251 }
1252
1253 /* Allocate a new translation block. Flush the translation buffer if
1254    too many translation blocks or too much generated code. */
1255 TranslationBlock *tb_alloc(target_ulong pc)
1256 {
1257     TranslationBlock *tb;
1258
1259     if (nb_tbs >= code_gen_max_blocks ||
1260         (code_gen_ptr - code_gen_buffer) >= code_gen_buffer_max_size)
1261         return NULL;
1262     tb = &tbs[nb_tbs++];
1263     tb->pc = pc;
1264     tb->cflags = 0;
1265     return tb;
1266 }
1267
1268 void tb_free(TranslationBlock *tb)
1269 {
1270     /* In practice this is mostly used for single use temporary TB
1271        Ignore the hard cases and just back up if this TB happens to
1272        be the last one generated.  */
1273     if (nb_tbs > 0 && tb == &tbs[nb_tbs - 1]) {
1274         code_gen_ptr = tb->tc_ptr;
1275         nb_tbs--;
1276     }
1277 }
1278
1279 /* add a new TB and link it to the physical page tables. phys_page2 is
1280    (-1) to indicate that only one page contains the TB. */
1281 void tb_link_page(TranslationBlock *tb,
1282                   tb_page_addr_t phys_pc, tb_page_addr_t phys_page2)
1283 {
1284     unsigned int h;
1285     TranslationBlock **ptb;
1286
1287     /* Grab the mmap lock to stop another thread invalidating this TB
1288        before we are done.  */
1289     mmap_lock();
1290     /* add in the physical hash table */
1291     h = tb_phys_hash_func(phys_pc);
1292     ptb = &tb_phys_hash[h];
1293     tb->phys_hash_next = *ptb;
1294     *ptb = tb;
1295
1296     /* add in the page list */
1297     tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
1298     if (phys_page2 != -1)
1299         tb_alloc_page(tb, 1, phys_page2);
1300     else
1301         tb->page_addr[1] = -1;
1302
1303     tb->jmp_first = (TranslationBlock *)((long)tb | 2);
1304     tb->jmp_next[0] = NULL;
1305     tb->jmp_next[1] = NULL;
1306
1307     /* init original jump addresses */
1308     if (tb->tb_next_offset[0] != 0xffff)
1309         tb_reset_jump(tb, 0);
1310     if (tb->tb_next_offset[1] != 0xffff)
1311         tb_reset_jump(tb, 1);
1312
1313 #ifdef DEBUG_TB_CHECK
1314     tb_page_check();
1315 #endif
1316     mmap_unlock();
1317 }
1318
1319 /* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
1320    tb[1].tc_ptr. Return NULL if not found */
1321 TranslationBlock *tb_find_pc(unsigned long tc_ptr)
1322 {
1323     int m_min, m_max, m;
1324     unsigned long v;
1325     TranslationBlock *tb;
1326
1327     if (nb_tbs <= 0)
1328         return NULL;
1329     if (tc_ptr < (unsigned long)code_gen_buffer ||
1330         tc_ptr >= (unsigned long)code_gen_ptr)
1331         return NULL;
1332     /* binary search (cf Knuth) */
1333     m_min = 0;
1334     m_max = nb_tbs - 1;
1335     while (m_min <= m_max) {
1336         m = (m_min + m_max) >> 1;
1337         tb = &tbs[m];
1338         v = (unsigned long)tb->tc_ptr;
1339         if (v == tc_ptr)
1340             return tb;
1341         else if (tc_ptr < v) {
1342             m_max = m - 1;
1343         } else {
1344             m_min = m + 1;
1345         }
1346     }
1347     return &tbs[m_max];
1348 }
1349
1350 static void tb_reset_jump_recursive(TranslationBlock *tb);
1351
1352 static inline void tb_reset_jump_recursive2(TranslationBlock *tb, int n)
1353 {
1354     TranslationBlock *tb1, *tb_next, **ptb;
1355     unsigned int n1;
1356
1357     tb1 = tb->jmp_next[n];
1358     if (tb1 != NULL) {
1359         /* find head of list */
1360         for(;;) {
1361             n1 = (long)tb1 & 3;
1362             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1363             if (n1 == 2)
1364                 break;
1365             tb1 = tb1->jmp_next[n1];
1366         }
1367         /* we are now sure now that tb jumps to tb1 */
1368         tb_next = tb1;
1369
1370         /* remove tb from the jmp_first list */
1371         ptb = &tb_next->jmp_first;
1372         for(;;) {
1373             tb1 = *ptb;
1374             n1 = (long)tb1 & 3;
1375             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1376             if (n1 == n && tb1 == tb)
1377                 break;
1378             ptb = &tb1->jmp_next[n1];
1379         }
1380         *ptb = tb->jmp_next[n];
1381         tb->jmp_next[n] = NULL;
1382
1383         /* suppress the jump to next tb in generated code */
1384         tb_reset_jump(tb, n);
1385
1386         /* suppress jumps in the tb on which we could have jumped */
1387         tb_reset_jump_recursive(tb_next);
1388     }
1389 }
1390
1391 static void tb_reset_jump_recursive(TranslationBlock *tb)
1392 {
1393     tb_reset_jump_recursive2(tb, 0);
1394     tb_reset_jump_recursive2(tb, 1);
1395 }
1396
1397 #if defined(TARGET_HAS_ICE)
1398 #if defined(CONFIG_USER_ONLY)
1399 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
1400 {
1401     tb_invalidate_phys_page_range(pc, pc + 1, 0);
1402 }
1403 #else
1404 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
1405 {
1406     target_phys_addr_t addr;
1407     target_ulong pd;
1408     ram_addr_t ram_addr;
1409     PhysPageDesc *p;
1410
1411     addr = cpu_get_phys_page_debug(env, pc);
1412     p = phys_page_find(addr >> TARGET_PAGE_BITS);
1413     if (!p) {
1414         pd = IO_MEM_UNASSIGNED;
1415     } else {
1416         pd = p->phys_offset;
1417     }
1418     ram_addr = (pd & TARGET_PAGE_MASK) | (pc & ~TARGET_PAGE_MASK);
1419     tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
1420 }
1421 #endif
1422 #endif /* TARGET_HAS_ICE */
1423
1424 #if defined(CONFIG_USER_ONLY)
1425 void cpu_watchpoint_remove_all(CPUState *env, int mask)
1426
1427 {
1428 }
1429
1430 int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len,
1431                           int flags, CPUWatchpoint **watchpoint)
1432 {
1433     return -ENOSYS;
1434 }
1435 #else
1436 /* Add a watchpoint.  */
1437 int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len,
1438                           int flags, CPUWatchpoint **watchpoint)
1439 {
1440     target_ulong len_mask = ~(len - 1);
1441     CPUWatchpoint *wp;
1442
1443     /* sanity checks: allow power-of-2 lengths, deny unaligned watchpoints */
1444     if ((len != 1 && len != 2 && len != 4 && len != 8) || (addr & ~len_mask)) {
1445         fprintf(stderr, "qemu: tried to set invalid watchpoint at "
1446                 TARGET_FMT_lx ", len=" TARGET_FMT_lu "\n", addr, len);
1447         return -EINVAL;
1448     }
1449     wp = qemu_malloc(sizeof(*wp));
1450
1451     wp->vaddr = addr;
1452     wp->len_mask = len_mask;
1453     wp->flags = flags;
1454
1455     /* keep all GDB-injected watchpoints in front */
1456     if (flags & BP_GDB)
1457         QTAILQ_INSERT_HEAD(&env->watchpoints, wp, entry);
1458     else
1459         QTAILQ_INSERT_TAIL(&env->watchpoints, wp, entry);
1460
1461     tlb_flush_page(env, addr);
1462
1463     if (watchpoint)
1464         *watchpoint = wp;
1465     return 0;
1466 }
1467
1468 /* Remove a specific watchpoint.  */
1469 int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len,
1470                           int flags)
1471 {
1472     target_ulong len_mask = ~(len - 1);
1473     CPUWatchpoint *wp;
1474
1475     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
1476         if (addr == wp->vaddr && len_mask == wp->len_mask
1477                 && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) {
1478             cpu_watchpoint_remove_by_ref(env, wp);
1479             return 0;
1480         }
1481     }
1482     return -ENOENT;
1483 }
1484
1485 /* Remove a specific watchpoint by reference.  */
1486 void cpu_watchpoint_remove_by_ref(CPUState *env, CPUWatchpoint *watchpoint)
1487 {
1488     QTAILQ_REMOVE(&env->watchpoints, watchpoint, entry);
1489
1490     tlb_flush_page(env, watchpoint->vaddr);
1491
1492     qemu_free(watchpoint);
1493 }
1494
1495 /* Remove all matching watchpoints.  */
1496 void cpu_watchpoint_remove_all(CPUState *env, int mask)
1497 {
1498     CPUWatchpoint *wp, *next;
1499
1500     QTAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) {
1501         if (wp->flags & mask)
1502             cpu_watchpoint_remove_by_ref(env, wp);
1503     }
1504 }
1505 #endif
1506
1507 /* Add a breakpoint.  */
1508 int cpu_breakpoint_insert(CPUState *env, target_ulong pc, int flags,
1509                           CPUBreakpoint **breakpoint)
1510 {
1511 #if defined(TARGET_HAS_ICE)
1512     CPUBreakpoint *bp;
1513
1514     bp = qemu_malloc(sizeof(*bp));
1515
1516     bp->pc = pc;
1517     bp->flags = flags;
1518
1519     /* keep all GDB-injected breakpoints in front */
1520     if (flags & BP_GDB)
1521         QTAILQ_INSERT_HEAD(&env->breakpoints, bp, entry);
1522     else
1523         QTAILQ_INSERT_TAIL(&env->breakpoints, bp, entry);
1524
1525     breakpoint_invalidate(env, pc);
1526
1527     if (breakpoint)
1528         *breakpoint = bp;
1529     return 0;
1530 #else
1531     return -ENOSYS;
1532 #endif
1533 }
1534
1535 /* Remove a specific breakpoint.  */
1536 int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags)
1537 {
1538 #if defined(TARGET_HAS_ICE)
1539     CPUBreakpoint *bp;
1540
1541     QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
1542         if (bp->pc == pc && bp->flags == flags) {
1543             cpu_breakpoint_remove_by_ref(env, bp);
1544             return 0;
1545         }
1546     }
1547     return -ENOENT;
1548 #else
1549     return -ENOSYS;
1550 #endif
1551 }
1552
1553 /* Remove a specific breakpoint by reference.  */
1554 void cpu_breakpoint_remove_by_ref(CPUState *env, CPUBreakpoint *breakpoint)
1555 {
1556 #if defined(TARGET_HAS_ICE)
1557     QTAILQ_REMOVE(&env->breakpoints, breakpoint, entry);
1558
1559     breakpoint_invalidate(env, breakpoint->pc);
1560
1561     qemu_free(breakpoint);
1562 #endif
1563 }
1564
1565 /* Remove all matching breakpoints. */
1566 void cpu_breakpoint_remove_all(CPUState *env, int mask)
1567 {
1568 #if defined(TARGET_HAS_ICE)
1569     CPUBreakpoint *bp, *next;
1570
1571     QTAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) {
1572         if (bp->flags & mask)
1573             cpu_breakpoint_remove_by_ref(env, bp);
1574     }
1575 #endif
1576 }
1577
1578 /* enable or disable single step mode. EXCP_DEBUG is returned by the
1579    CPU loop after each instruction */
1580 void cpu_single_step(CPUState *env, int enabled)
1581 {
1582 #if defined(TARGET_HAS_ICE)
1583     if (env->singlestep_enabled != enabled) {
1584         env->singlestep_enabled = enabled;
1585         if (kvm_enabled())
1586             kvm_update_guest_debug(env, 0);
1587         else {
1588             /* must flush all the translated code to avoid inconsistencies */
1589             /* XXX: only flush what is necessary */
1590             tb_flush(env);
1591         }
1592     }
1593 #endif
1594 }
1595
1596 /* enable or disable low levels log */
1597 void cpu_set_log(int log_flags)
1598 {
1599     loglevel = log_flags;
1600     if (loglevel && !logfile) {
1601         logfile = fopen(logfilename, log_append ? "a" : "w");
1602         if (!logfile) {
1603             perror(logfilename);
1604             _exit(1);
1605         }
1606 #if !defined(CONFIG_SOFTMMU)
1607         /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
1608         {
1609             static char logfile_buf[4096];
1610             setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
1611         }
1612 #elif !defined(_WIN32)
1613         /* Win32 doesn't support line-buffering and requires size >= 2 */
1614         setvbuf(logfile, NULL, _IOLBF, 0);
1615 #endif
1616         log_append = 1;
1617     }
1618     if (!loglevel && logfile) {
1619         fclose(logfile);
1620         logfile = NULL;
1621     }
1622 }
1623
1624 void cpu_set_log_filename(const char *filename)
1625 {
1626     logfilename = strdup(filename);
1627     if (logfile) {
1628         fclose(logfile);
1629         logfile = NULL;
1630     }
1631     cpu_set_log(loglevel);
1632 }
1633
1634 static void cpu_unlink_tb(CPUState *env)
1635 {
1636     /* FIXME: TB unchaining isn't SMP safe.  For now just ignore the
1637        problem and hope the cpu will stop of its own accord.  For userspace
1638        emulation this often isn't actually as bad as it sounds.  Often
1639        signals are used primarily to interrupt blocking syscalls.  */
1640     TranslationBlock *tb;
1641     static spinlock_t interrupt_lock = SPIN_LOCK_UNLOCKED;
1642
1643     spin_lock(&interrupt_lock);
1644     tb = env->current_tb;
1645     /* if the cpu is currently executing code, we must unlink it and
1646        all the potentially executing TB */
1647     if (tb) {
1648         env->current_tb = NULL;
1649         tb_reset_jump_recursive(tb);
1650     }
1651     spin_unlock(&interrupt_lock);
1652 }
1653
1654 /* mask must never be zero, except for A20 change call */
1655 void cpu_interrupt(CPUState *env, int mask)
1656 {
1657     int old_mask;
1658
1659     old_mask = env->interrupt_request;
1660     env->interrupt_request |= mask;
1661
1662 #ifndef CONFIG_USER_ONLY
1663     /*
1664      * If called from iothread context, wake the target cpu in
1665      * case its halted.
1666      */
1667     if (!qemu_cpu_self(env)) {
1668         qemu_cpu_kick(env);
1669         return;
1670     }
1671 #endif
1672
1673     if (use_icount) {
1674         env->icount_decr.u16.high = 0xffff;
1675 #ifndef CONFIG_USER_ONLY
1676         if (!can_do_io(env)
1677             && (mask & ~old_mask) != 0) {
1678             cpu_abort(env, "Raised interrupt while not in I/O function");
1679         }
1680 #endif
1681     } else {
1682         cpu_unlink_tb(env);
1683     }
1684 }
1685
1686 void cpu_reset_interrupt(CPUState *env, int mask)
1687 {
1688     env->interrupt_request &= ~mask;
1689 }
1690
1691 void cpu_exit(CPUState *env)
1692 {
1693     env->exit_request = 1;
1694     cpu_unlink_tb(env);
1695 }
1696
1697 const CPULogItem cpu_log_items[] = {
1698     { CPU_LOG_TB_OUT_ASM, "out_asm",
1699       "show generated host assembly code for each compiled TB" },
1700     { CPU_LOG_TB_IN_ASM, "in_asm",
1701       "show target assembly code for each compiled TB" },
1702     { CPU_LOG_TB_OP, "op",
1703       "show micro ops for each compiled TB" },
1704     { CPU_LOG_TB_OP_OPT, "op_opt",
1705       "show micro ops "
1706 #ifdef TARGET_I386
1707       "before eflags optimization and "
1708 #endif
1709       "after liveness analysis" },
1710     { CPU_LOG_INT, "int",
1711       "show interrupts/exceptions in short format" },
1712     { CPU_LOG_EXEC, "exec",
1713       "show trace before each executed TB (lots of logs)" },
1714     { CPU_LOG_TB_CPU, "cpu",
1715       "show CPU state before block translation" },
1716 #ifdef TARGET_I386
1717     { CPU_LOG_PCALL, "pcall",
1718       "show protected mode far calls/returns/exceptions" },
1719     { CPU_LOG_RESET, "cpu_reset",
1720       "show CPU state before CPU resets" },
1721 #endif
1722 #ifdef DEBUG_IOPORT
1723     { CPU_LOG_IOPORT, "ioport",
1724       "show all i/o ports accesses" },
1725 #endif
1726     { 0, NULL, NULL },
1727 };
1728
1729 #ifndef CONFIG_USER_ONLY
1730 static QLIST_HEAD(memory_client_list, CPUPhysMemoryClient) memory_client_list
1731     = QLIST_HEAD_INITIALIZER(memory_client_list);
1732
1733 static void cpu_notify_set_memory(target_phys_addr_t start_addr,
1734                                   ram_addr_t size,
1735                                   ram_addr_t phys_offset)
1736 {
1737     CPUPhysMemoryClient *client;
1738     QLIST_FOREACH(client, &memory_client_list, list) {
1739         client->set_memory(client, start_addr, size, phys_offset);
1740     }
1741 }
1742
1743 static int cpu_notify_sync_dirty_bitmap(target_phys_addr_t start,
1744                                         target_phys_addr_t end)
1745 {
1746     CPUPhysMemoryClient *client;
1747     QLIST_FOREACH(client, &memory_client_list, list) {
1748         int r = client->sync_dirty_bitmap(client, start, end);
1749         if (r < 0)
1750             return r;
1751     }
1752     return 0;
1753 }
1754
1755 static int cpu_notify_migration_log(int enable)
1756 {
1757     CPUPhysMemoryClient *client;
1758     QLIST_FOREACH(client, &memory_client_list, list) {
1759         int r = client->migration_log(client, enable);
1760         if (r < 0)
1761             return r;
1762     }
1763     return 0;
1764 }
1765
1766 static void phys_page_for_each_1(CPUPhysMemoryClient *client,
1767                                  int level, void **lp)
1768 {
1769     int i;
1770
1771     if (*lp == NULL) {
1772         return;
1773     }
1774     if (level == 0) {
1775         PhysPageDesc *pd = *lp;
1776         for (i = 0; i < L2_SIZE; ++i) {
1777             if (pd[i].phys_offset != IO_MEM_UNASSIGNED) {
1778                 client->set_memory(client, pd[i].region_offset,
1779                                    TARGET_PAGE_SIZE, pd[i].phys_offset);
1780             }
1781         }
1782     } else {
1783         void **pp = *lp;
1784         for (i = 0; i < L2_SIZE; ++i) {
1785             phys_page_for_each_1(client, level - 1, pp + i);
1786         }
1787     }
1788 }
1789
1790 static void phys_page_for_each(CPUPhysMemoryClient *client)
1791 {
1792     int i;
1793     for (i = 0; i < P_L1_SIZE; ++i) {
1794         phys_page_for_each_1(client, P_L1_SHIFT / L2_BITS - 1,
1795                              l1_phys_map + 1);
1796     }
1797 }
1798
1799 void cpu_register_phys_memory_client(CPUPhysMemoryClient *client)
1800 {
1801     QLIST_INSERT_HEAD(&memory_client_list, client, list);
1802     phys_page_for_each(client);
1803 }
1804
1805 void cpu_unregister_phys_memory_client(CPUPhysMemoryClient *client)
1806 {
1807     QLIST_REMOVE(client, list);
1808 }
1809 #endif
1810
1811 static int cmp1(const char *s1, int n, const char *s2)
1812 {
1813     if (strlen(s2) != n)
1814         return 0;
1815     return memcmp(s1, s2, n) == 0;
1816 }
1817
1818 /* takes a comma separated list of log masks. Return 0 if error. */
1819 int cpu_str_to_log_mask(const char *str)
1820 {
1821     const CPULogItem *item;
1822     int mask;
1823     const char *p, *p1;
1824
1825     p = str;
1826     mask = 0;
1827     for(;;) {
1828         p1 = strchr(p, ',');
1829         if (!p1)
1830             p1 = p + strlen(p);
1831         if(cmp1(p,p1-p,"all")) {
1832                 for(item = cpu_log_items; item->mask != 0; item++) {
1833                         mask |= item->mask;
1834                 }
1835         } else {
1836         for(item = cpu_log_items; item->mask != 0; item++) {
1837             if (cmp1(p, p1 - p, item->name))
1838                 goto found;
1839         }
1840         return 0;
1841         }
1842     found:
1843         mask |= item->mask;
1844         if (*p1 != ',')
1845             break;
1846         p = p1 + 1;
1847     }
1848     return mask;
1849 }
1850
1851 void cpu_abort(CPUState *env, const char *fmt, ...)
1852 {
1853     va_list ap;
1854     va_list ap2;
1855
1856     va_start(ap, fmt);
1857     va_copy(ap2, ap);
1858     fprintf(stderr, "qemu: fatal: ");
1859     vfprintf(stderr, fmt, ap);
1860     fprintf(stderr, "\n");
1861 #ifdef TARGET_I386
1862     cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
1863 #else
1864     cpu_dump_state(env, stderr, fprintf, 0);
1865 #endif
1866     if (qemu_log_enabled()) {
1867         qemu_log("qemu: fatal: ");
1868         qemu_log_vprintf(fmt, ap2);
1869         qemu_log("\n");
1870 #ifdef TARGET_I386
1871         log_cpu_state(env, X86_DUMP_FPU | X86_DUMP_CCOP);
1872 #else
1873         log_cpu_state(env, 0);
1874 #endif
1875         qemu_log_flush();
1876         qemu_log_close();
1877     }
1878     va_end(ap2);
1879     va_end(ap);
1880 #if defined(CONFIG_USER_ONLY)
1881     {
1882         struct sigaction act;
1883         sigfillset(&act.sa_mask);
1884         act.sa_handler = SIG_DFL;
1885         sigaction(SIGABRT, &act, NULL);
1886     }
1887 #endif
1888     abort();
1889 }
1890
1891 CPUState *cpu_copy(CPUState *env)
1892 {
1893     CPUState *new_env = cpu_init(env->cpu_model_str);
1894     CPUState *next_cpu = new_env->next_cpu;
1895     int cpu_index = new_env->cpu_index;
1896 #if defined(TARGET_HAS_ICE)
1897     CPUBreakpoint *bp;
1898     CPUWatchpoint *wp;
1899 #endif
1900
1901     memcpy(new_env, env, sizeof(CPUState));
1902
1903     /* Preserve chaining and index. */
1904     new_env->next_cpu = next_cpu;
1905     new_env->cpu_index = cpu_index;
1906
1907     /* Clone all break/watchpoints.
1908        Note: Once we support ptrace with hw-debug register access, make sure
1909        BP_CPU break/watchpoints are handled correctly on clone. */
1910     QTAILQ_INIT(&env->breakpoints);
1911     QTAILQ_INIT(&env->watchpoints);
1912 #if defined(TARGET_HAS_ICE)
1913     QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
1914         cpu_breakpoint_insert(new_env, bp->pc, bp->flags, NULL);
1915     }
1916     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
1917         cpu_watchpoint_insert(new_env, wp->vaddr, (~wp->len_mask) + 1,
1918                               wp->flags, NULL);
1919     }
1920 #endif
1921
1922     return new_env;
1923 }
1924
1925 #if !defined(CONFIG_USER_ONLY)
1926
1927 static inline void tlb_flush_jmp_cache(CPUState *env, target_ulong addr)
1928 {
1929     unsigned int i;
1930
1931     /* Discard jump cache entries for any tb which might potentially
1932        overlap the flushed page.  */
1933     i = tb_jmp_cache_hash_page(addr - TARGET_PAGE_SIZE);
1934     memset (&env->tb_jmp_cache[i], 0,
1935             TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1936
1937     i = tb_jmp_cache_hash_page(addr);
1938     memset (&env->tb_jmp_cache[i], 0,
1939             TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1940 }
1941
1942 static CPUTLBEntry s_cputlb_empty_entry = {
1943     .addr_read  = -1,
1944     .addr_write = -1,
1945     .addr_code  = -1,
1946     .addend     = -1,
1947 };
1948
1949 /* NOTE: if flush_global is true, also flush global entries (not
1950    implemented yet) */
1951 void tlb_flush(CPUState *env, int flush_global)
1952 {
1953     int i;
1954
1955 #if defined(DEBUG_TLB)
1956     printf("tlb_flush:\n");
1957 #endif
1958     /* must reset current TB so that interrupts cannot modify the
1959        links while we are modifying them */
1960     env->current_tb = NULL;
1961
1962     for(i = 0; i < CPU_TLB_SIZE; i++) {
1963         int mmu_idx;
1964         for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
1965             env->tlb_table[mmu_idx][i] = s_cputlb_empty_entry;
1966         }
1967     }
1968
1969     memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
1970
1971     env->tlb_flush_addr = -1;
1972     env->tlb_flush_mask = 0;
1973     tlb_flush_count++;
1974 }
1975
1976 static inline void tlb_flush_entry(CPUTLBEntry *tlb_entry, target_ulong addr)
1977 {
1978     if (addr == (tlb_entry->addr_read &
1979                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1980         addr == (tlb_entry->addr_write &
1981                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1982         addr == (tlb_entry->addr_code &
1983                  (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1984         *tlb_entry = s_cputlb_empty_entry;
1985     }
1986 }
1987
1988 void tlb_flush_page(CPUState *env, target_ulong addr)
1989 {
1990     int i;
1991     int mmu_idx;
1992
1993 #if defined(DEBUG_TLB)
1994     printf("tlb_flush_page: " TARGET_FMT_lx "\n", addr);
1995 #endif
1996     /* Check if we need to flush due to large pages.  */
1997     if ((addr & env->tlb_flush_mask) == env->tlb_flush_addr) {
1998 #if defined(DEBUG_TLB)
1999         printf("tlb_flush_page: forced full flush ("
2000                TARGET_FMT_lx "/" TARGET_FMT_lx ")\n",
2001                env->tlb_flush_addr, env->tlb_flush_mask);
2002 #endif
2003         tlb_flush(env, 1);
2004         return;
2005     }
2006     /* must reset current TB so that interrupts cannot modify the
2007        links while we are modifying them */
2008     env->current_tb = NULL;
2009
2010     addr &= TARGET_PAGE_MASK;
2011     i = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
2012     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++)
2013         tlb_flush_entry(&env->tlb_table[mmu_idx][i], addr);
2014
2015     tlb_flush_jmp_cache(env, addr);
2016 }
2017
2018 /* update the TLBs so that writes to code in the virtual page 'addr'
2019    can be detected */
2020 static void tlb_protect_code(ram_addr_t ram_addr)
2021 {
2022     cpu_physical_memory_reset_dirty(ram_addr,
2023                                     ram_addr + TARGET_PAGE_SIZE,
2024                                     CODE_DIRTY_FLAG);
2025 }
2026
2027 /* update the TLB so that writes in physical page 'phys_addr' are no longer
2028    tested for self modifying code */
2029 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
2030                                     target_ulong vaddr)
2031 {
2032     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] |= CODE_DIRTY_FLAG;
2033 }
2034
2035 static inline void tlb_reset_dirty_range(CPUTLBEntry *tlb_entry,
2036                                          unsigned long start, unsigned long length)
2037 {
2038     unsigned long addr;
2039     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
2040         addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
2041         if ((addr - start) < length) {
2042             tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | TLB_NOTDIRTY;
2043         }
2044     }
2045 }
2046
2047 /* Note: start and end must be within the same ram block.  */
2048 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
2049                                      int dirty_flags)
2050 {
2051     CPUState *env;
2052     unsigned long length, start1;
2053     int i, mask, len;
2054     uint8_t *p;
2055
2056     start &= TARGET_PAGE_MASK;
2057     end = TARGET_PAGE_ALIGN(end);
2058
2059     length = end - start;
2060     if (length == 0)
2061         return;
2062     len = length >> TARGET_PAGE_BITS;
2063     mask = ~dirty_flags;
2064     p = phys_ram_dirty + (start >> TARGET_PAGE_BITS);
2065     for(i = 0; i < len; i++)
2066         p[i] &= mask;
2067
2068     /* we modify the TLB cache so that the dirty bit will be set again
2069        when accessing the range */
2070     start1 = (unsigned long)qemu_get_ram_ptr(start);
2071     /* Chek that we don't span multiple blocks - this breaks the
2072        address comparisons below.  */
2073     if ((unsigned long)qemu_get_ram_ptr(end - 1) - start1
2074             != (end - 1) - start) {
2075         abort();
2076     }
2077
2078     for(env = first_cpu; env != NULL; env = env->next_cpu) {
2079         int mmu_idx;
2080         for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
2081             for(i = 0; i < CPU_TLB_SIZE; i++)
2082                 tlb_reset_dirty_range(&env->tlb_table[mmu_idx][i],
2083                                       start1, length);
2084         }
2085     }
2086 }
2087
2088 int cpu_physical_memory_set_dirty_tracking(int enable)
2089 {
2090     int ret = 0;
2091     in_migration = enable;
2092     ret = cpu_notify_migration_log(!!enable);
2093     return ret;
2094 }
2095
2096 int cpu_physical_memory_get_dirty_tracking(void)
2097 {
2098     return in_migration;
2099 }
2100
2101 int cpu_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
2102                                    target_phys_addr_t end_addr)
2103 {
2104     int ret;
2105
2106     ret = cpu_notify_sync_dirty_bitmap(start_addr, end_addr);
2107     return ret;
2108 }
2109
2110 static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry)
2111 {
2112     ram_addr_t ram_addr;
2113     void *p;
2114
2115     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
2116         p = (void *)(unsigned long)((tlb_entry->addr_write & TARGET_PAGE_MASK)
2117             + tlb_entry->addend);
2118         ram_addr = qemu_ram_addr_from_host(p);
2119         if (!cpu_physical_memory_is_dirty(ram_addr)) {
2120             tlb_entry->addr_write |= TLB_NOTDIRTY;
2121         }
2122     }
2123 }
2124
2125 /* update the TLB according to the current state of the dirty bits */
2126 void cpu_tlb_update_dirty(CPUState *env)
2127 {
2128     int i;
2129     int mmu_idx;
2130     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
2131         for(i = 0; i < CPU_TLB_SIZE; i++)
2132             tlb_update_dirty(&env->tlb_table[mmu_idx][i]);
2133     }
2134 }
2135
2136 static inline void tlb_set_dirty1(CPUTLBEntry *tlb_entry, target_ulong vaddr)
2137 {
2138     if (tlb_entry->addr_write == (vaddr | TLB_NOTDIRTY))
2139         tlb_entry->addr_write = vaddr;
2140 }
2141
2142 /* update the TLB corresponding to virtual page vaddr
2143    so that it is no longer dirty */
2144 static inline void tlb_set_dirty(CPUState *env, target_ulong vaddr)
2145 {
2146     int i;
2147     int mmu_idx;
2148
2149     vaddr &= TARGET_PAGE_MASK;
2150     i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
2151     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++)
2152         tlb_set_dirty1(&env->tlb_table[mmu_idx][i], vaddr);
2153 }
2154
2155 /* Our TLB does not support large pages, so remember the area covered by
2156    large pages and trigger a full TLB flush if these are invalidated.  */
2157 static void tlb_add_large_page(CPUState *env, target_ulong vaddr,
2158                                target_ulong size)
2159 {
2160     target_ulong mask = ~(size - 1);
2161
2162     if (env->tlb_flush_addr == (target_ulong)-1) {
2163         env->tlb_flush_addr = vaddr & mask;
2164         env->tlb_flush_mask = mask;
2165         return;
2166     }
2167     /* Extend the existing region to include the new page.
2168        This is a compromise between unnecessary flushes and the cost
2169        of maintaining a full variable size TLB.  */
2170     mask &= env->tlb_flush_mask;
2171     while (((env->tlb_flush_addr ^ vaddr) & mask) != 0) {
2172         mask <<= 1;
2173     }
2174     env->tlb_flush_addr &= mask;
2175     env->tlb_flush_mask = mask;
2176 }
2177
2178 /* Add a new TLB entry. At most one entry for a given virtual address
2179    is permitted. Only a single TARGET_PAGE_SIZE region is mapped, the
2180    supplied size is only used by tlb_flush_page.  */
2181 void tlb_set_page(CPUState *env, target_ulong vaddr,
2182                   target_phys_addr_t paddr, int prot,
2183                   int mmu_idx, target_ulong size)
2184 {
2185     PhysPageDesc *p;
2186     unsigned long pd;
2187     unsigned int index;
2188     target_ulong address;
2189     target_ulong code_address;
2190     target_phys_addr_t addend;
2191     CPUTLBEntry *te;
2192     CPUWatchpoint *wp;
2193     target_phys_addr_t iotlb;
2194
2195     assert(size >= TARGET_PAGE_SIZE);
2196     if (size != TARGET_PAGE_SIZE) {
2197         tlb_add_large_page(env, vaddr, size);
2198     }
2199     p = phys_page_find(paddr >> TARGET_PAGE_BITS);
2200     if (!p) {
2201         pd = IO_MEM_UNASSIGNED;
2202     } else {
2203         pd = p->phys_offset;
2204     }
2205 #if defined(DEBUG_TLB)
2206     printf("tlb_set_page: vaddr=" TARGET_FMT_lx " paddr=0x%08x prot=%x idx=%d smmu=%d pd=0x%08lx\n",
2207            vaddr, (int)paddr, prot, mmu_idx, is_softmmu, pd);
2208 #endif
2209
2210     address = vaddr;
2211     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) {
2212         /* IO memory case (romd handled later) */
2213         address |= TLB_MMIO;
2214     }
2215     addend = (unsigned long)qemu_get_ram_ptr(pd & TARGET_PAGE_MASK);
2216     if ((pd & ~TARGET_PAGE_MASK) <= IO_MEM_ROM) {
2217         /* Normal RAM.  */
2218         iotlb = pd & TARGET_PAGE_MASK;
2219         if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM)
2220             iotlb |= IO_MEM_NOTDIRTY;
2221         else
2222             iotlb |= IO_MEM_ROM;
2223     } else {
2224         /* IO handlers are currently passed a physical address.
2225            It would be nice to pass an offset from the base address
2226            of that region.  This would avoid having to special case RAM,
2227            and avoid full address decoding in every device.
2228            We can't use the high bits of pd for this because
2229            IO_MEM_ROMD uses these as a ram address.  */
2230         iotlb = (pd & ~TARGET_PAGE_MASK);
2231         if (p) {
2232             iotlb += p->region_offset;
2233         } else {
2234             iotlb += paddr;
2235         }
2236     }
2237
2238     code_address = address;
2239     /* Make accesses to pages with watchpoints go via the
2240        watchpoint trap routines.  */
2241     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
2242         if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) {
2243             iotlb = io_mem_watch + paddr;
2244             /* TODO: The memory case can be optimized by not trapping
2245                reads of pages with a write breakpoint.  */
2246             address |= TLB_MMIO;
2247         }
2248     }
2249
2250     index = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
2251     env->iotlb[mmu_idx][index] = iotlb - vaddr;
2252     te = &env->tlb_table[mmu_idx][index];
2253     te->addend = addend - vaddr;
2254     if (prot & PAGE_READ) {
2255         te->addr_read = address;
2256     } else {
2257         te->addr_read = -1;
2258     }
2259
2260     if (prot & PAGE_EXEC) {
2261         te->addr_code = code_address;
2262     } else {
2263         te->addr_code = -1;
2264     }
2265     if (prot & PAGE_WRITE) {
2266         if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
2267             (pd & IO_MEM_ROMD)) {
2268             /* Write access calls the I/O callback.  */
2269             te->addr_write = address | TLB_MMIO;
2270         } else if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
2271                    !cpu_physical_memory_is_dirty(pd)) {
2272             te->addr_write = address | TLB_NOTDIRTY;
2273         } else {
2274             te->addr_write = address;
2275         }
2276     } else {
2277         te->addr_write = -1;
2278     }
2279 }
2280
2281 #else
2282
2283 void tlb_flush(CPUState *env, int flush_global)
2284 {
2285 }
2286
2287 void tlb_flush_page(CPUState *env, target_ulong addr)
2288 {
2289 }
2290
2291 /*
2292  * Walks guest process memory "regions" one by one
2293  * and calls callback function 'fn' for each region.
2294  */
2295
2296 struct walk_memory_regions_data
2297 {
2298     walk_memory_regions_fn fn;
2299     void *priv;
2300     unsigned long start;
2301     int prot;
2302 };
2303
2304 static int walk_memory_regions_end(struct walk_memory_regions_data *data,
2305                                    abi_ulong end, int new_prot)
2306 {
2307     if (data->start != -1ul) {
2308         int rc = data->fn(data->priv, data->start, end, data->prot);
2309         if (rc != 0) {
2310             return rc;
2311         }
2312     }
2313
2314     data->start = (new_prot ? end : -1ul);
2315     data->prot = new_prot;
2316
2317     return 0;
2318 }
2319
2320 static int walk_memory_regions_1(struct walk_memory_regions_data *data,
2321                                  abi_ulong base, int level, void **lp)
2322 {
2323     abi_ulong pa;
2324     int i, rc;
2325
2326     if (*lp == NULL) {
2327         return walk_memory_regions_end(data, base, 0);
2328     }
2329
2330     if (level == 0) {
2331         PageDesc *pd = *lp;
2332         for (i = 0; i < L2_SIZE; ++i) {
2333             int prot = pd[i].flags;
2334
2335             pa = base | (i << TARGET_PAGE_BITS);
2336             if (prot != data->prot) {
2337                 rc = walk_memory_regions_end(data, pa, prot);
2338                 if (rc != 0) {
2339                     return rc;
2340                 }
2341             }
2342         }
2343     } else {
2344         void **pp = *lp;
2345         for (i = 0; i < L2_SIZE; ++i) {
2346             pa = base | ((abi_ulong)i <<
2347                 (TARGET_PAGE_BITS + L2_BITS * level));
2348             rc = walk_memory_regions_1(data, pa, level - 1, pp + i);
2349             if (rc != 0) {
2350                 return rc;
2351             }
2352         }
2353     }
2354
2355     return 0;
2356 }
2357
2358 int walk_memory_regions(void *priv, walk_memory_regions_fn fn)
2359 {
2360     struct walk_memory_regions_data data;
2361     unsigned long i;
2362
2363     data.fn = fn;
2364     data.priv = priv;
2365     data.start = -1ul;
2366     data.prot = 0;
2367
2368     for (i = 0; i < V_L1_SIZE; i++) {
2369         int rc = walk_memory_regions_1(&data, (abi_ulong)i << V_L1_SHIFT,
2370                                        V_L1_SHIFT / L2_BITS - 1, l1_map + i);
2371         if (rc != 0) {
2372             return rc;
2373         }
2374     }
2375
2376     return walk_memory_regions_end(&data, 0, 0);
2377 }
2378
2379 static int dump_region(void *priv, abi_ulong start,
2380     abi_ulong end, unsigned long prot)
2381 {
2382     FILE *f = (FILE *)priv;
2383
2384     (void) fprintf(f, TARGET_ABI_FMT_lx"-"TARGET_ABI_FMT_lx
2385         " "TARGET_ABI_FMT_lx" %c%c%c\n",
2386         start, end, end - start,
2387         ((prot & PAGE_READ) ? 'r' : '-'),
2388         ((prot & PAGE_WRITE) ? 'w' : '-'),
2389         ((prot & PAGE_EXEC) ? 'x' : '-'));
2390
2391     return (0);
2392 }
2393
2394 /* dump memory mappings */
2395 void page_dump(FILE *f)
2396 {
2397     (void) fprintf(f, "%-8s %-8s %-8s %s\n",
2398             "start", "end", "size", "prot");
2399     walk_memory_regions(f, dump_region);
2400 }
2401
2402 int page_get_flags(target_ulong address)
2403 {
2404     PageDesc *p;
2405
2406     p = page_find(address >> TARGET_PAGE_BITS);
2407     if (!p)
2408         return 0;
2409     return p->flags;
2410 }
2411
2412 /* Modify the flags of a page and invalidate the code if necessary.
2413    The flag PAGE_WRITE_ORG is positioned automatically depending
2414    on PAGE_WRITE.  The mmap_lock should already be held.  */
2415 void page_set_flags(target_ulong start, target_ulong end, int flags)
2416 {
2417     target_ulong addr, len;
2418
2419     /* This function should never be called with addresses outside the
2420        guest address space.  If this assert fires, it probably indicates
2421        a missing call to h2g_valid.  */
2422 #if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
2423     assert(end < ((abi_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
2424 #endif
2425     assert(start < end);
2426
2427     start = start & TARGET_PAGE_MASK;
2428     end = TARGET_PAGE_ALIGN(end);
2429
2430     if (flags & PAGE_WRITE) {
2431         flags |= PAGE_WRITE_ORG;
2432     }
2433
2434     for (addr = start, len = end - start;
2435          len != 0;
2436          len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
2437         PageDesc *p = page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
2438
2439         /* If the write protection bit is set, then we invalidate
2440            the code inside.  */
2441         if (!(p->flags & PAGE_WRITE) &&
2442             (flags & PAGE_WRITE) &&
2443             p->first_tb) {
2444             tb_invalidate_phys_page(addr, 0, NULL);
2445         }
2446         p->flags = flags;
2447     }
2448 }
2449
2450 int page_check_range(target_ulong start, target_ulong len, int flags)
2451 {
2452     PageDesc *p;
2453     target_ulong end;
2454     target_ulong addr;
2455
2456     /* This function should never be called with addresses outside the
2457        guest address space.  If this assert fires, it probably indicates
2458        a missing call to h2g_valid.  */
2459 #if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
2460     assert(start < ((abi_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
2461 #endif
2462
2463     if (start + len - 1 < start) {
2464         /* We've wrapped around.  */
2465         return -1;
2466     }
2467
2468     end = TARGET_PAGE_ALIGN(start+len); /* must do before we loose bits in the next step */
2469     start = start & TARGET_PAGE_MASK;
2470
2471     for (addr = start, len = end - start;
2472          len != 0;
2473          len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
2474         p = page_find(addr >> TARGET_PAGE_BITS);
2475         if( !p )
2476             return -1;
2477         if( !(p->flags & PAGE_VALID) )
2478             return -1;
2479
2480         if ((flags & PAGE_READ) && !(p->flags & PAGE_READ))
2481             return -1;
2482         if (flags & PAGE_WRITE) {
2483             if (!(p->flags & PAGE_WRITE_ORG))
2484                 return -1;
2485             /* unprotect the page if it was put read-only because it
2486                contains translated code */
2487             if (!(p->flags & PAGE_WRITE)) {
2488                 if (!page_unprotect(addr, 0, NULL))
2489                     return -1;
2490             }
2491             return 0;
2492         }
2493     }
2494     return 0;
2495 }
2496
2497 /* called from signal handler: invalidate the code and unprotect the
2498    page. Return TRUE if the fault was successfully handled. */
2499 int page_unprotect(target_ulong address, unsigned long pc, void *puc)
2500 {
2501     unsigned int page_index, prot, pindex;
2502     PageDesc *p, *p1;
2503     target_ulong host_start, host_end, addr;
2504
2505     /* Technically this isn't safe inside a signal handler.  However we
2506        know this only ever happens in a synchronous SEGV handler, so in
2507        practice it seems to be ok.  */
2508     mmap_lock();
2509
2510     host_start = address & qemu_host_page_mask;
2511     page_index = host_start >> TARGET_PAGE_BITS;
2512     p1 = page_find(page_index);
2513     if (!p1) {
2514         mmap_unlock();
2515         return 0;
2516     }
2517     host_end = host_start + qemu_host_page_size;
2518     p = p1;
2519     prot = 0;
2520     for(addr = host_start;addr < host_end; addr += TARGET_PAGE_SIZE) {
2521         prot |= p->flags;
2522         p++;
2523     }
2524     /* if the page was really writable, then we change its
2525        protection back to writable */
2526     if (prot & PAGE_WRITE_ORG) {
2527         pindex = (address - host_start) >> TARGET_PAGE_BITS;
2528         if (!(p1[pindex].flags & PAGE_WRITE)) {
2529             mprotect((void *)g2h(host_start), qemu_host_page_size,
2530                      (prot & PAGE_BITS) | PAGE_WRITE);
2531             p1[pindex].flags |= PAGE_WRITE;
2532             /* and since the content will be modified, we must invalidate
2533                the corresponding translated code. */
2534             tb_invalidate_phys_page(address, pc, puc);
2535 #ifdef DEBUG_TB_CHECK
2536             tb_invalidate_check(address);
2537 #endif
2538             mmap_unlock();
2539             return 1;
2540         }
2541     }
2542     mmap_unlock();
2543     return 0;
2544 }
2545
2546 static inline void tlb_set_dirty(CPUState *env,
2547                                  unsigned long addr, target_ulong vaddr)
2548 {
2549 }
2550 #endif /* defined(CONFIG_USER_ONLY) */
2551
2552 #if !defined(CONFIG_USER_ONLY)
2553
2554 #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK)
2555 typedef struct subpage_t {
2556     target_phys_addr_t base;
2557     CPUReadMemoryFunc * const *mem_read[TARGET_PAGE_SIZE][4];
2558     CPUWriteMemoryFunc * const *mem_write[TARGET_PAGE_SIZE][4];
2559     void *opaque[TARGET_PAGE_SIZE][2][4];
2560     ram_addr_t region_offset[TARGET_PAGE_SIZE][2][4];
2561 } subpage_t;
2562
2563 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
2564                              ram_addr_t memory, ram_addr_t region_offset);
2565 static void *subpage_init (target_phys_addr_t base, ram_addr_t *phys,
2566                            ram_addr_t orig_memory, ram_addr_t region_offset);
2567 #define CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2, \
2568                       need_subpage)                                     \
2569     do {                                                                \
2570         if (addr > start_addr)                                          \
2571             start_addr2 = 0;                                            \
2572         else {                                                          \
2573             start_addr2 = start_addr & ~TARGET_PAGE_MASK;               \
2574             if (start_addr2 > 0)                                        \
2575                 need_subpage = 1;                                       \
2576         }                                                               \
2577                                                                         \
2578         if ((start_addr + orig_size) - addr >= TARGET_PAGE_SIZE)        \
2579             end_addr2 = TARGET_PAGE_SIZE - 1;                           \
2580         else {                                                          \
2581             end_addr2 = (start_addr + orig_size - 1) & ~TARGET_PAGE_MASK; \
2582             if (end_addr2 < TARGET_PAGE_SIZE - 1)                       \
2583                 need_subpage = 1;                                       \
2584         }                                                               \
2585     } while (0)
2586
2587 /* register physical memory.
2588    For RAM, 'size' must be a multiple of the target page size.
2589    If (phys_offset & ~TARGET_PAGE_MASK) != 0, then it is an
2590    io memory page.  The address used when calling the IO function is
2591    the offset from the start of the region, plus region_offset.  Both
2592    start_addr and region_offset are rounded down to a page boundary
2593    before calculating this offset.  This should not be a problem unless
2594    the low bits of start_addr and region_offset differ.  */
2595 void cpu_register_physical_memory_offset(target_phys_addr_t start_addr,
2596                                          ram_addr_t size,
2597                                          ram_addr_t phys_offset,
2598                                          ram_addr_t region_offset)
2599 {
2600     target_phys_addr_t addr, end_addr;
2601     PhysPageDesc *p;
2602     CPUState *env;
2603     ram_addr_t orig_size = size;
2604     void *subpage;
2605
2606     cpu_notify_set_memory(start_addr, size, phys_offset);
2607
2608     if (phys_offset == IO_MEM_UNASSIGNED) {
2609         region_offset = start_addr;
2610     }
2611     region_offset &= TARGET_PAGE_MASK;
2612     size = (size + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK;
2613     end_addr = start_addr + (target_phys_addr_t)size;
2614     for(addr = start_addr; addr != end_addr; addr += TARGET_PAGE_SIZE) {
2615         p = phys_page_find(addr >> TARGET_PAGE_BITS);
2616         if (p && p->phys_offset != IO_MEM_UNASSIGNED) {
2617             ram_addr_t orig_memory = p->phys_offset;
2618             target_phys_addr_t start_addr2, end_addr2;
2619             int need_subpage = 0;
2620
2621             CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2,
2622                           need_subpage);
2623             if (need_subpage || phys_offset & IO_MEM_SUBWIDTH) {
2624                 if (!(orig_memory & IO_MEM_SUBPAGE)) {
2625                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2626                                            &p->phys_offset, orig_memory,
2627                                            p->region_offset);
2628                 } else {
2629                     subpage = io_mem_opaque[(orig_memory & ~TARGET_PAGE_MASK)
2630                                             >> IO_MEM_SHIFT];
2631                 }
2632                 subpage_register(subpage, start_addr2, end_addr2, phys_offset,
2633                                  region_offset);
2634                 p->region_offset = 0;
2635             } else {
2636                 p->phys_offset = phys_offset;
2637                 if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2638                     (phys_offset & IO_MEM_ROMD))
2639                     phys_offset += TARGET_PAGE_SIZE;
2640             }
2641         } else {
2642             p = phys_page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
2643             p->phys_offset = phys_offset;
2644             p->region_offset = region_offset;
2645             if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2646                 (phys_offset & IO_MEM_ROMD)) {
2647                 phys_offset += TARGET_PAGE_SIZE;
2648             } else {
2649                 target_phys_addr_t start_addr2, end_addr2;
2650                 int need_subpage = 0;
2651
2652                 CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr,
2653                               end_addr2, need_subpage);
2654
2655                 if (need_subpage || phys_offset & IO_MEM_SUBWIDTH) {
2656                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2657                                            &p->phys_offset, IO_MEM_UNASSIGNED,
2658                                            addr & TARGET_PAGE_MASK);
2659                     subpage_register(subpage, start_addr2, end_addr2,
2660                                      phys_offset, region_offset);
2661                     p->region_offset = 0;
2662                 }
2663             }
2664         }
2665         region_offset += TARGET_PAGE_SIZE;
2666     }
2667
2668     /* since each CPU stores ram addresses in its TLB cache, we must
2669        reset the modified entries */
2670     /* XXX: slow ! */
2671     for(env = first_cpu; env != NULL; env = env->next_cpu) {
2672         tlb_flush(env, 1);
2673     }
2674 }
2675
2676 /* XXX: temporary until new memory mapping API */
2677 ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr)
2678 {
2679     PhysPageDesc *p;
2680
2681     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2682     if (!p)
2683         return IO_MEM_UNASSIGNED;
2684     return p->phys_offset;
2685 }
2686
2687 void qemu_register_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size)
2688 {
2689     if (kvm_enabled())
2690         kvm_coalesce_mmio_region(addr, size);
2691 }
2692
2693 void qemu_unregister_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size)
2694 {
2695     if (kvm_enabled())
2696         kvm_uncoalesce_mmio_region(addr, size);
2697 }
2698
2699 void qemu_flush_coalesced_mmio_buffer(void)
2700 {
2701     if (kvm_enabled())
2702         kvm_flush_coalesced_mmio_buffer();
2703 }
2704
2705 #if defined(__linux__) && !defined(TARGET_S390X)
2706
2707 #include <sys/vfs.h>
2708
2709 #define HUGETLBFS_MAGIC       0x958458f6
2710
2711 static long gethugepagesize(const char *path)
2712 {
2713     struct statfs fs;
2714     int ret;
2715
2716     do {
2717             ret = statfs(path, &fs);
2718     } while (ret != 0 && errno == EINTR);
2719
2720     if (ret != 0) {
2721             perror(path);
2722             return 0;
2723     }
2724
2725     if (fs.f_type != HUGETLBFS_MAGIC)
2726             fprintf(stderr, "Warning: path not on HugeTLBFS: %s\n", path);
2727
2728     return fs.f_bsize;
2729 }
2730
2731 static void *file_ram_alloc(ram_addr_t memory, const char *path)
2732 {
2733     char *filename;
2734     void *area;
2735     int fd;
2736 #ifdef MAP_POPULATE
2737     int flags;
2738 #endif
2739     unsigned long hpagesize;
2740
2741     hpagesize = gethugepagesize(path);
2742     if (!hpagesize) {
2743         return NULL;
2744     }
2745
2746     if (memory < hpagesize) {
2747         return NULL;
2748     }
2749
2750     if (kvm_enabled() && !kvm_has_sync_mmu()) {
2751         fprintf(stderr, "host lacks kvm mmu notifiers, -mem-path unsupported\n");
2752         return NULL;
2753     }
2754
2755     if (asprintf(&filename, "%s/qemu_back_mem.XXXXXX", path) == -1) {
2756         return NULL;
2757     }
2758
2759     fd = mkstemp(filename);
2760     if (fd < 0) {
2761         perror("unable to create backing store for hugepages");
2762         free(filename);
2763         return NULL;
2764     }
2765     unlink(filename);
2766     free(filename);
2767
2768     memory = (memory+hpagesize-1) & ~(hpagesize-1);
2769
2770     /*
2771      * ftruncate is not supported by hugetlbfs in older
2772      * hosts, so don't bother bailing out on errors.
2773      * If anything goes wrong with it under other filesystems,
2774      * mmap will fail.
2775      */
2776     if (ftruncate(fd, memory))
2777         perror("ftruncate");
2778
2779 #ifdef MAP_POPULATE
2780     /* NB: MAP_POPULATE won't exhaustively alloc all phys pages in the case
2781      * MAP_PRIVATE is requested.  For mem_prealloc we mmap as MAP_SHARED
2782      * to sidestep this quirk.
2783      */
2784     flags = mem_prealloc ? MAP_POPULATE | MAP_SHARED : MAP_PRIVATE;
2785     area = mmap(0, memory, PROT_READ | PROT_WRITE, flags, fd, 0);
2786 #else
2787     area = mmap(0, memory, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
2788 #endif
2789     if (area == MAP_FAILED) {
2790         perror("file_ram_alloc: can't mmap RAM pages");
2791         close(fd);
2792         return (NULL);
2793     }
2794     return area;
2795 }
2796 #endif
2797
2798 ram_addr_t qemu_ram_alloc(ram_addr_t size)
2799 {
2800     RAMBlock *new_block;
2801
2802     size = TARGET_PAGE_ALIGN(size);
2803     new_block = qemu_malloc(sizeof(*new_block));
2804
2805     if (mem_path) {
2806 #if defined (__linux__) && !defined(TARGET_S390X)
2807         new_block->host = file_ram_alloc(size, mem_path);
2808         if (!new_block->host)
2809             exit(1);
2810 #else
2811         fprintf(stderr, "-mem-path option unsupported\n");
2812         exit(1);
2813 #endif
2814     } else {
2815 #if defined(TARGET_S390X) && defined(CONFIG_KVM)
2816         /* XXX S390 KVM requires the topmost vma of the RAM to be < 256GB */
2817         new_block->host = mmap((void*)0x1000000, size,
2818                                 PROT_EXEC|PROT_READ|PROT_WRITE,
2819                                 MAP_SHARED | MAP_ANONYMOUS, -1, 0);
2820 #else
2821         new_block->host = qemu_vmalloc(size);
2822 #endif
2823 #ifdef MADV_MERGEABLE
2824         madvise(new_block->host, size, MADV_MERGEABLE);
2825 #endif
2826     }
2827     new_block->offset = last_ram_offset;
2828     new_block->length = size;
2829
2830     new_block->next = ram_blocks;
2831     ram_blocks = new_block;
2832
2833     phys_ram_dirty = qemu_realloc(phys_ram_dirty,
2834         (last_ram_offset + size) >> TARGET_PAGE_BITS);
2835     memset(phys_ram_dirty + (last_ram_offset >> TARGET_PAGE_BITS),
2836            0xff, size >> TARGET_PAGE_BITS);
2837
2838     last_ram_offset += size;
2839
2840     if (kvm_enabled())
2841         kvm_setup_guest_memory(new_block->host, size);
2842
2843     return new_block->offset;
2844 }
2845
2846 void qemu_ram_free(ram_addr_t addr)
2847 {
2848     /* TODO: implement this.  */
2849 }
2850
2851 /* Return a host pointer to ram allocated with qemu_ram_alloc.
2852    With the exception of the softmmu code in this file, this should
2853    only be used for local memory (e.g. video ram) that the device owns,
2854    and knows it isn't going to access beyond the end of the block.
2855
2856    It should not be used for general purpose DMA.
2857    Use cpu_physical_memory_map/cpu_physical_memory_rw instead.
2858  */
2859 void *qemu_get_ram_ptr(ram_addr_t addr)
2860 {
2861     RAMBlock *prev;
2862     RAMBlock **prevp;
2863     RAMBlock *block;
2864
2865     prev = NULL;
2866     prevp = &ram_blocks;
2867     block = ram_blocks;
2868     while (block && (block->offset > addr
2869                      || block->offset + block->length <= addr)) {
2870         if (prev)
2871           prevp = &prev->next;
2872         prev = block;
2873         block = block->next;
2874     }
2875     if (!block) {
2876         fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
2877         abort();
2878     }
2879     /* Move this entry to to start of the list.  */
2880     if (prev) {
2881         prev->next = block->next;
2882         block->next = *prevp;
2883         *prevp = block;
2884     }
2885     return block->host + (addr - block->offset);
2886 }
2887
2888 /* Some of the softmmu routines need to translate from a host pointer
2889    (typically a TLB entry) back to a ram offset.  */
2890 ram_addr_t qemu_ram_addr_from_host(void *ptr)
2891 {
2892     RAMBlock *prev;
2893     RAMBlock *block;
2894     uint8_t *host = ptr;
2895
2896     prev = NULL;
2897     block = ram_blocks;
2898     while (block && (block->host > host
2899                      || block->host + block->length <= host)) {
2900         prev = block;
2901         block = block->next;
2902     }
2903     if (!block) {
2904         fprintf(stderr, "Bad ram pointer %p\n", ptr);
2905         abort();
2906     }
2907     return block->offset + (host - block->host);
2908 }
2909
2910 static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr)
2911 {
2912 #ifdef DEBUG_UNASSIGNED
2913     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
2914 #endif
2915 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
2916     do_unassigned_access(addr, 0, 0, 0, 1);
2917 #endif
2918     return 0;
2919 }
2920
2921 static uint32_t unassigned_mem_readw(void *opaque, target_phys_addr_t addr)
2922 {
2923 #ifdef DEBUG_UNASSIGNED
2924     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
2925 #endif
2926 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
2927     do_unassigned_access(addr, 0, 0, 0, 2);
2928 #endif
2929     return 0;
2930 }
2931
2932 static uint32_t unassigned_mem_readl(void *opaque, target_phys_addr_t addr)
2933 {
2934 #ifdef DEBUG_UNASSIGNED
2935     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
2936 #endif
2937 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
2938     do_unassigned_access(addr, 0, 0, 0, 4);
2939 #endif
2940     return 0;
2941 }
2942
2943 static void unassigned_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
2944 {
2945 #ifdef DEBUG_UNASSIGNED
2946     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
2947 #endif
2948 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
2949     do_unassigned_access(addr, 1, 0, 0, 1);
2950 #endif
2951 }
2952
2953 static void unassigned_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
2954 {
2955 #ifdef DEBUG_UNASSIGNED
2956     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
2957 #endif
2958 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
2959     do_unassigned_access(addr, 1, 0, 0, 2);
2960 #endif
2961 }
2962
2963 static void unassigned_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
2964 {
2965 #ifdef DEBUG_UNASSIGNED
2966     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
2967 #endif
2968 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
2969     do_unassigned_access(addr, 1, 0, 0, 4);
2970 #endif
2971 }
2972
2973 static CPUReadMemoryFunc * const unassigned_mem_read[3] = {
2974     unassigned_mem_readb,
2975     unassigned_mem_readw,
2976     unassigned_mem_readl,
2977 };
2978
2979 static CPUWriteMemoryFunc * const unassigned_mem_write[3] = {
2980     unassigned_mem_writeb,
2981     unassigned_mem_writew,
2982     unassigned_mem_writel,
2983 };
2984
2985 static void notdirty_mem_writeb(void *opaque, target_phys_addr_t ram_addr,
2986                                 uint32_t val)
2987 {
2988     int dirty_flags;
2989     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2990     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
2991 #if !defined(CONFIG_USER_ONLY)
2992         tb_invalidate_phys_page_fast(ram_addr, 1);
2993         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2994 #endif
2995     }
2996     stb_p(qemu_get_ram_ptr(ram_addr), val);
2997     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
2998     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
2999     /* we remove the notdirty callback only if the code has been
3000        flushed */
3001     if (dirty_flags == 0xff)
3002         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3003 }
3004
3005 static void notdirty_mem_writew(void *opaque, target_phys_addr_t ram_addr,
3006                                 uint32_t val)
3007 {
3008     int dirty_flags;
3009     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
3010     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
3011 #if !defined(CONFIG_USER_ONLY)
3012         tb_invalidate_phys_page_fast(ram_addr, 2);
3013         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
3014 #endif
3015     }
3016     stw_p(qemu_get_ram_ptr(ram_addr), val);
3017     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
3018     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
3019     /* we remove the notdirty callback only if the code has been
3020        flushed */
3021     if (dirty_flags == 0xff)
3022         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3023 }
3024
3025 static void notdirty_mem_writel(void *opaque, target_phys_addr_t ram_addr,
3026                                 uint32_t val)
3027 {
3028     int dirty_flags;
3029     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
3030     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
3031 #if !defined(CONFIG_USER_ONLY)
3032         tb_invalidate_phys_page_fast(ram_addr, 4);
3033         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
3034 #endif
3035     }
3036     stl_p(qemu_get_ram_ptr(ram_addr), val);
3037     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
3038     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
3039     /* we remove the notdirty callback only if the code has been
3040        flushed */
3041     if (dirty_flags == 0xff)
3042         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3043 }
3044
3045 static CPUReadMemoryFunc * const error_mem_read[3] = {
3046     NULL, /* never used */
3047     NULL, /* never used */
3048     NULL, /* never used */
3049 };
3050
3051 static CPUWriteMemoryFunc * const notdirty_mem_write[3] = {
3052     notdirty_mem_writeb,
3053     notdirty_mem_writew,
3054     notdirty_mem_writel,
3055 };
3056
3057 /* Generate a debug exception if a watchpoint has been hit.  */
3058 static void check_watchpoint(int offset, int len_mask, int flags)
3059 {
3060     CPUState *env = cpu_single_env;
3061     target_ulong pc, cs_base;
3062     TranslationBlock *tb;
3063     target_ulong vaddr;
3064     CPUWatchpoint *wp;
3065     int cpu_flags;
3066
3067     if (env->watchpoint_hit) {
3068         /* We re-entered the check after replacing the TB. Now raise
3069          * the debug interrupt so that is will trigger after the
3070          * current instruction. */
3071         cpu_interrupt(env, CPU_INTERRUPT_DEBUG);
3072         return;
3073     }
3074     vaddr = (env->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
3075     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
3076         if ((vaddr == (wp->vaddr & len_mask) ||
3077              (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) {
3078             wp->flags |= BP_WATCHPOINT_HIT;
3079             if (!env->watchpoint_hit) {
3080                 env->watchpoint_hit = wp;
3081                 tb = tb_find_pc(env->mem_io_pc);
3082                 if (!tb) {
3083                     cpu_abort(env, "check_watchpoint: could not find TB for "
3084                               "pc=%p", (void *)env->mem_io_pc);
3085                 }
3086                 cpu_restore_state(tb, env, env->mem_io_pc, NULL);
3087                 tb_phys_invalidate(tb, -1);
3088                 if (wp->flags & BP_STOP_BEFORE_ACCESS) {
3089                     env->exception_index = EXCP_DEBUG;
3090                 } else {
3091                     cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);
3092                     tb_gen_code(env, pc, cs_base, cpu_flags, 1);
3093                 }
3094                 cpu_resume_from_signal(env, NULL);
3095             }
3096         } else {
3097             wp->flags &= ~BP_WATCHPOINT_HIT;
3098         }
3099     }
3100 }
3101
3102 /* Watchpoint access routines.  Watchpoints are inserted using TLB tricks,
3103    so these check for a hit then pass through to the normal out-of-line
3104    phys routines.  */
3105 static uint32_t watch_mem_readb(void *opaque, target_phys_addr_t addr)
3106 {
3107     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x0, BP_MEM_READ);
3108     return ldub_phys(addr);
3109 }
3110
3111 static uint32_t watch_mem_readw(void *opaque, target_phys_addr_t addr)
3112 {
3113     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x1, BP_MEM_READ);
3114     return lduw_phys(addr);
3115 }
3116
3117 static uint32_t watch_mem_readl(void *opaque, target_phys_addr_t addr)
3118 {
3119     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x3, BP_MEM_READ);
3120     return ldl_phys(addr);
3121 }
3122
3123 static void watch_mem_writeb(void *opaque, target_phys_addr_t addr,
3124                              uint32_t val)
3125 {
3126     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x0, BP_MEM_WRITE);
3127     stb_phys(addr, val);
3128 }
3129
3130 static void watch_mem_writew(void *opaque, target_phys_addr_t addr,
3131                              uint32_t val)
3132 {
3133     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x1, BP_MEM_WRITE);
3134     stw_phys(addr, val);
3135 }
3136
3137 static void watch_mem_writel(void *opaque, target_phys_addr_t addr,
3138                              uint32_t val)
3139 {
3140     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x3, BP_MEM_WRITE);
3141     stl_phys(addr, val);
3142 }
3143
3144 static CPUReadMemoryFunc * const watch_mem_read[3] = {
3145     watch_mem_readb,
3146     watch_mem_readw,
3147     watch_mem_readl,
3148 };
3149
3150 static CPUWriteMemoryFunc * const watch_mem_write[3] = {
3151     watch_mem_writeb,
3152     watch_mem_writew,
3153     watch_mem_writel,
3154 };
3155
3156 static inline uint32_t subpage_readlen (subpage_t *mmio, target_phys_addr_t addr,
3157                                  unsigned int len)
3158 {
3159     uint32_t ret;
3160     unsigned int idx;
3161
3162     idx = SUBPAGE_IDX(addr);
3163 #if defined(DEBUG_SUBPAGE)
3164     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d\n", __func__,
3165            mmio, len, addr, idx);
3166 #endif
3167     ret = (**mmio->mem_read[idx][len])(mmio->opaque[idx][0][len],
3168                                        addr + mmio->region_offset[idx][0][len]);
3169
3170     return ret;
3171 }
3172
3173 static inline void subpage_writelen (subpage_t *mmio, target_phys_addr_t addr,
3174                               uint32_t value, unsigned int len)
3175 {
3176     unsigned int idx;
3177
3178     idx = SUBPAGE_IDX(addr);
3179 #if defined(DEBUG_SUBPAGE)
3180     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d value %08x\n", __func__,
3181            mmio, len, addr, idx, value);
3182 #endif
3183     (**mmio->mem_write[idx][len])(mmio->opaque[idx][1][len],
3184                                   addr + mmio->region_offset[idx][1][len],
3185                                   value);
3186 }
3187
3188 static uint32_t subpage_readb (void *opaque, target_phys_addr_t addr)
3189 {
3190 #if defined(DEBUG_SUBPAGE)
3191     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
3192 #endif
3193
3194     return subpage_readlen(opaque, addr, 0);
3195 }
3196
3197 static void subpage_writeb (void *opaque, target_phys_addr_t addr,
3198                             uint32_t value)
3199 {
3200 #if defined(DEBUG_SUBPAGE)
3201     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
3202 #endif
3203     subpage_writelen(opaque, addr, value, 0);
3204 }
3205
3206 static uint32_t subpage_readw (void *opaque, target_phys_addr_t addr)
3207 {
3208 #if defined(DEBUG_SUBPAGE)
3209     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
3210 #endif
3211
3212     return subpage_readlen(opaque, addr, 1);
3213 }
3214
3215 static void subpage_writew (void *opaque, target_phys_addr_t addr,
3216                             uint32_t value)
3217 {
3218 #if defined(DEBUG_SUBPAGE)
3219     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
3220 #endif
3221     subpage_writelen(opaque, addr, value, 1);
3222 }
3223
3224 static uint32_t subpage_readl (void *opaque, target_phys_addr_t addr)
3225 {
3226 #if defined(DEBUG_SUBPAGE)
3227     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
3228 #endif
3229
3230     return subpage_readlen(opaque, addr, 2);
3231 }
3232
3233 static void subpage_writel (void *opaque,
3234                          target_phys_addr_t addr, uint32_t value)
3235 {
3236 #if defined(DEBUG_SUBPAGE)
3237     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
3238 #endif
3239     subpage_writelen(opaque, addr, value, 2);
3240 }
3241
3242 static CPUReadMemoryFunc * const subpage_read[] = {
3243     &subpage_readb,
3244     &subpage_readw,
3245     &subpage_readl,
3246 };
3247
3248 static CPUWriteMemoryFunc * const subpage_write[] = {
3249     &subpage_writeb,
3250     &subpage_writew,
3251     &subpage_writel,
3252 };
3253
3254 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
3255                              ram_addr_t memory, ram_addr_t region_offset)
3256 {
3257     int idx, eidx;
3258     unsigned int i;
3259
3260     if (start >= TARGET_PAGE_SIZE || end >= TARGET_PAGE_SIZE)
3261         return -1;
3262     idx = SUBPAGE_IDX(start);
3263     eidx = SUBPAGE_IDX(end);
3264 #if defined(DEBUG_SUBPAGE)
3265     printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %ld\n", __func__,
3266            mmio, start, end, idx, eidx, memory);
3267 #endif
3268     memory >>= IO_MEM_SHIFT;
3269     for (; idx <= eidx; idx++) {
3270         for (i = 0; i < 4; i++) {
3271             if (io_mem_read[memory][i]) {
3272                 mmio->mem_read[idx][i] = &io_mem_read[memory][i];
3273                 mmio->opaque[idx][0][i] = io_mem_opaque[memory];
3274                 mmio->region_offset[idx][0][i] = region_offset;
3275             }
3276             if (io_mem_write[memory][i]) {
3277                 mmio->mem_write[idx][i] = &io_mem_write[memory][i];
3278                 mmio->opaque[idx][1][i] = io_mem_opaque[memory];
3279                 mmio->region_offset[idx][1][i] = region_offset;
3280             }
3281         }
3282     }
3283
3284     return 0;
3285 }
3286
3287 static void *subpage_init (target_phys_addr_t base, ram_addr_t *phys,
3288                            ram_addr_t orig_memory, ram_addr_t region_offset)
3289 {
3290     subpage_t *mmio;
3291     int subpage_memory;
3292
3293     mmio = qemu_mallocz(sizeof(subpage_t));
3294
3295     mmio->base = base;
3296     subpage_memory = cpu_register_io_memory(subpage_read, subpage_write, mmio);
3297 #if defined(DEBUG_SUBPAGE)
3298     printf("%s: %p base " TARGET_FMT_plx " len %08x %d\n", __func__,
3299            mmio, base, TARGET_PAGE_SIZE, subpage_memory);
3300 #endif
3301     *phys = subpage_memory | IO_MEM_SUBPAGE;
3302     subpage_register(mmio, 0, TARGET_PAGE_SIZE - 1, orig_memory,
3303                          region_offset);
3304
3305     return mmio;
3306 }
3307
3308 static int get_free_io_mem_idx(void)
3309 {
3310     int i;
3311
3312     for (i = 0; i<IO_MEM_NB_ENTRIES; i++)
3313         if (!io_mem_used[i]) {
3314             io_mem_used[i] = 1;
3315             return i;
3316         }
3317     fprintf(stderr, "RAN out out io_mem_idx, max %d !\n", IO_MEM_NB_ENTRIES);
3318     return -1;
3319 }
3320
3321 /* mem_read and mem_write are arrays of functions containing the
3322    function to access byte (index 0), word (index 1) and dword (index
3323    2). Functions can be omitted with a NULL function pointer.
3324    If io_index is non zero, the corresponding io zone is
3325    modified. If it is zero, a new io zone is allocated. The return
3326    value can be used with cpu_register_physical_memory(). (-1) is
3327    returned if error. */
3328 static int cpu_register_io_memory_fixed(int io_index,
3329                                         CPUReadMemoryFunc * const *mem_read,
3330                                         CPUWriteMemoryFunc * const *mem_write,
3331                                         void *opaque)
3332 {
3333     int i, subwidth = 0;
3334
3335     if (io_index <= 0) {
3336         io_index = get_free_io_mem_idx();
3337         if (io_index == -1)
3338             return io_index;
3339     } else {
3340         io_index >>= IO_MEM_SHIFT;
3341         if (io_index >= IO_MEM_NB_ENTRIES)
3342             return -1;
3343     }
3344
3345     for(i = 0;i < 3; i++) {
3346         if (!mem_read[i] || !mem_write[i])
3347             subwidth = IO_MEM_SUBWIDTH;
3348         io_mem_read[io_index][i] = mem_read[i];
3349         io_mem_write[io_index][i] = mem_write[i];
3350     }
3351     io_mem_opaque[io_index] = opaque;
3352     return (io_index << IO_MEM_SHIFT) | subwidth;
3353 }
3354
3355 int cpu_register_io_memory(CPUReadMemoryFunc * const *mem_read,
3356                            CPUWriteMemoryFunc * const *mem_write,
3357                            void *opaque)
3358 {
3359     return cpu_register_io_memory_fixed(0, mem_read, mem_write, opaque);
3360 }
3361
3362 void cpu_unregister_io_memory(int io_table_address)
3363 {
3364     int i;
3365     int io_index = io_table_address >> IO_MEM_SHIFT;
3366
3367     for (i=0;i < 3; i++) {
3368         io_mem_read[io_index][i] = unassigned_mem_read[i];
3369         io_mem_write[io_index][i] = unassigned_mem_write[i];
3370     }
3371     io_mem_opaque[io_index] = NULL;
3372     io_mem_used[io_index] = 0;
3373 }
3374
3375 static void io_mem_init(void)
3376 {
3377     int i;
3378
3379     cpu_register_io_memory_fixed(IO_MEM_ROM, error_mem_read, unassigned_mem_write, NULL);
3380     cpu_register_io_memory_fixed(IO_MEM_UNASSIGNED, unassigned_mem_read, unassigned_mem_write, NULL);
3381     cpu_register_io_memory_fixed(IO_MEM_NOTDIRTY, error_mem_read, notdirty_mem_write, NULL);
3382     for (i=0; i<5; i++)
3383         io_mem_used[i] = 1;
3384
3385     io_mem_watch = cpu_register_io_memory(watch_mem_read,
3386                                           watch_mem_write, NULL);
3387 }
3388
3389 #endif /* !defined(CONFIG_USER_ONLY) */
3390
3391 /* physical memory access (slow version, mainly for debug) */
3392 #if defined(CONFIG_USER_ONLY)
3393 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
3394                         uint8_t *buf, int len, int is_write)
3395 {
3396     int l, flags;
3397     target_ulong page;
3398     void * p;
3399
3400     while (len > 0) {
3401         page = addr & TARGET_PAGE_MASK;
3402         l = (page + TARGET_PAGE_SIZE) - addr;
3403         if (l > len)
3404             l = len;
3405         flags = page_get_flags(page);
3406         if (!(flags & PAGE_VALID))
3407             return -1;
3408         if (is_write) {
3409             if (!(flags & PAGE_WRITE))
3410                 return -1;
3411             /* XXX: this code should not depend on lock_user */
3412             if (!(p = lock_user(VERIFY_WRITE, addr, l, 0)))
3413                 return -1;
3414             memcpy(p, buf, l);
3415             unlock_user(p, addr, l);
3416         } else {
3417             if (!(flags & PAGE_READ))
3418                 return -1;
3419             /* XXX: this code should not depend on lock_user */
3420             if (!(p = lock_user(VERIFY_READ, addr, l, 1)))
3421                 return -1;
3422             memcpy(buf, p, l);
3423             unlock_user(p, addr, 0);
3424         }
3425         len -= l;
3426         buf += l;
3427         addr += l;
3428     }
3429     return 0;
3430 }
3431
3432 #else
3433 void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
3434                             int len, int is_write)
3435 {
3436     int l, io_index;
3437     uint8_t *ptr;
3438     uint32_t val;
3439     target_phys_addr_t page;
3440     unsigned long pd;
3441     PhysPageDesc *p;
3442
3443     while (len > 0) {
3444         page = addr & TARGET_PAGE_MASK;
3445         l = (page + TARGET_PAGE_SIZE) - addr;
3446         if (l > len)
3447             l = len;
3448         p = phys_page_find(page >> TARGET_PAGE_BITS);
3449         if (!p) {
3450             pd = IO_MEM_UNASSIGNED;
3451         } else {
3452             pd = p->phys_offset;
3453         }
3454
3455         if (is_write) {
3456             if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3457                 target_phys_addr_t addr1 = addr;
3458                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3459                 if (p)
3460                     addr1 = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3461                 /* XXX: could force cpu_single_env to NULL to avoid
3462                    potential bugs */
3463                 if (l >= 4 && ((addr1 & 3) == 0)) {
3464                     /* 32 bit write access */
3465                     val = ldl_p(buf);
3466                     io_mem_write[io_index][2](io_mem_opaque[io_index], addr1, val);
3467                     l = 4;
3468                 } else if (l >= 2 && ((addr1 & 1) == 0)) {
3469                     /* 16 bit write access */
3470                     val = lduw_p(buf);
3471                     io_mem_write[io_index][1](io_mem_opaque[io_index], addr1, val);
3472                     l = 2;
3473                 } else {
3474                     /* 8 bit write access */
3475                     val = ldub_p(buf);
3476                     io_mem_write[io_index][0](io_mem_opaque[io_index], addr1, val);
3477                     l = 1;
3478                 }
3479             } else {
3480                 unsigned long addr1;
3481                 addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3482                 /* RAM case */
3483                 ptr = qemu_get_ram_ptr(addr1);
3484                 memcpy(ptr, buf, l);
3485                 if (!cpu_physical_memory_is_dirty(addr1)) {
3486                     /* invalidate code */
3487                     tb_invalidate_phys_page_range(addr1, addr1 + l, 0);
3488                     /* set dirty bit */
3489                     phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
3490                         (0xff & ~CODE_DIRTY_FLAG);
3491                 }
3492             }
3493         } else {
3494             if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
3495                 !(pd & IO_MEM_ROMD)) {
3496                 target_phys_addr_t addr1 = addr;
3497                 /* I/O case */
3498                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3499                 if (p)
3500                     addr1 = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3501                 if (l >= 4 && ((addr1 & 3) == 0)) {
3502                     /* 32 bit read access */
3503                     val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr1);
3504                     stl_p(buf, val);
3505                     l = 4;
3506                 } else if (l >= 2 && ((addr1 & 1) == 0)) {
3507                     /* 16 bit read access */
3508                     val = io_mem_read[io_index][1](io_mem_opaque[io_index], addr1);
3509                     stw_p(buf, val);
3510                     l = 2;
3511                 } else {
3512                     /* 8 bit read access */
3513                     val = io_mem_read[io_index][0](io_mem_opaque[io_index], addr1);
3514                     stb_p(buf, val);
3515                     l = 1;
3516                 }
3517             } else {
3518                 /* RAM case */
3519                 ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
3520                     (addr & ~TARGET_PAGE_MASK);
3521                 memcpy(buf, ptr, l);
3522             }
3523         }
3524         len -= l;
3525         buf += l;
3526         addr += l;
3527     }
3528 }
3529
3530 /* used for ROM loading : can write in RAM and ROM */
3531 void cpu_physical_memory_write_rom(target_phys_addr_t addr,
3532                                    const uint8_t *buf, int len)
3533 {
3534     int l;
3535     uint8_t *ptr;
3536     target_phys_addr_t page;
3537     unsigned long pd;
3538     PhysPageDesc *p;
3539
3540     while (len > 0) {
3541         page = addr & TARGET_PAGE_MASK;
3542         l = (page + TARGET_PAGE_SIZE) - addr;
3543         if (l > len)
3544             l = len;
3545         p = phys_page_find(page >> TARGET_PAGE_BITS);
3546         if (!p) {
3547             pd = IO_MEM_UNASSIGNED;
3548         } else {
3549             pd = p->phys_offset;
3550         }
3551
3552         if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM &&
3553             (pd & ~TARGET_PAGE_MASK) != IO_MEM_ROM &&
3554             !(pd & IO_MEM_ROMD)) {
3555             /* do nothing */
3556         } else {
3557             unsigned long addr1;
3558             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3559             /* ROM/RAM case */
3560             ptr = qemu_get_ram_ptr(addr1);
3561             memcpy(ptr, buf, l);
3562         }
3563         len -= l;
3564         buf += l;
3565         addr += l;
3566     }
3567 }
3568
3569 typedef struct {
3570     void *buffer;
3571     target_phys_addr_t addr;
3572     target_phys_addr_t len;
3573 } BounceBuffer;
3574
3575 static BounceBuffer bounce;
3576
3577 typedef struct MapClient {
3578     void *opaque;
3579     void (*callback)(void *opaque);
3580     QLIST_ENTRY(MapClient) link;
3581 } MapClient;
3582
3583 static QLIST_HEAD(map_client_list, MapClient) map_client_list
3584     = QLIST_HEAD_INITIALIZER(map_client_list);
3585
3586 void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
3587 {
3588     MapClient *client = qemu_malloc(sizeof(*client));
3589
3590     client->opaque = opaque;
3591     client->callback = callback;
3592     QLIST_INSERT_HEAD(&map_client_list, client, link);
3593     return client;
3594 }
3595
3596 void cpu_unregister_map_client(void *_client)
3597 {
3598     MapClient *client = (MapClient *)_client;
3599
3600     QLIST_REMOVE(client, link);
3601     qemu_free(client);
3602 }
3603
3604 static void cpu_notify_map_clients(void)
3605 {
3606     MapClient *client;
3607
3608     while (!QLIST_EMPTY(&map_client_list)) {
3609         client = QLIST_FIRST(&map_client_list);
3610         client->callback(client->opaque);
3611         cpu_unregister_map_client(client);
3612     }
3613 }
3614
3615 /* Map a physical memory region into a host virtual address.
3616  * May map a subset of the requested range, given by and returned in *plen.
3617  * May return NULL if resources needed to perform the mapping are exhausted.
3618  * Use only for reads OR writes - not for read-modify-write operations.
3619  * Use cpu_register_map_client() to know when retrying the map operation is
3620  * likely to succeed.
3621  */
3622 void *cpu_physical_memory_map(target_phys_addr_t addr,
3623                               target_phys_addr_t *plen,
3624                               int is_write)
3625 {
3626     target_phys_addr_t len = *plen;
3627     target_phys_addr_t done = 0;
3628     int l;
3629     uint8_t *ret = NULL;
3630     uint8_t *ptr;
3631     target_phys_addr_t page;
3632     unsigned long pd;
3633     PhysPageDesc *p;
3634     unsigned long addr1;
3635
3636     while (len > 0) {
3637         page = addr & TARGET_PAGE_MASK;
3638         l = (page + TARGET_PAGE_SIZE) - addr;
3639         if (l > len)
3640             l = len;
3641         p = phys_page_find(page >> TARGET_PAGE_BITS);
3642         if (!p) {
3643             pd = IO_MEM_UNASSIGNED;
3644         } else {
3645             pd = p->phys_offset;
3646         }
3647
3648         if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3649             if (done || bounce.buffer) {
3650                 break;
3651             }
3652             bounce.buffer = qemu_memalign(TARGET_PAGE_SIZE, TARGET_PAGE_SIZE);
3653             bounce.addr = addr;
3654             bounce.len = l;
3655             if (!is_write) {
3656                 cpu_physical_memory_rw(addr, bounce.buffer, l, 0);
3657             }
3658             ptr = bounce.buffer;
3659         } else {
3660             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3661             ptr = qemu_get_ram_ptr(addr1);
3662         }
3663         if (!done) {
3664             ret = ptr;
3665         } else if (ret + done != ptr) {
3666             break;
3667         }
3668
3669         len -= l;
3670         addr += l;
3671         done += l;
3672     }
3673     *plen = done;
3674     return ret;
3675 }
3676
3677 /* Unmaps a memory region previously mapped by cpu_physical_memory_map().
3678  * Will also mark the memory as dirty if is_write == 1.  access_len gives
3679  * the amount of memory that was actually read or written by the caller.
3680  */
3681 void cpu_physical_memory_unmap(void *buffer, target_phys_addr_t len,
3682                                int is_write, target_phys_addr_t access_len)
3683 {
3684     if (buffer != bounce.buffer) {
3685         if (is_write) {
3686             ram_addr_t addr1 = qemu_ram_addr_from_host(buffer);
3687             while (access_len) {
3688                 unsigned l;
3689                 l = TARGET_PAGE_SIZE;
3690                 if (l > access_len)
3691                     l = access_len;
3692                 if (!cpu_physical_memory_is_dirty(addr1)) {
3693                     /* invalidate code */
3694                     tb_invalidate_phys_page_range(addr1, addr1 + l, 0);
3695                     /* set dirty bit */
3696                     phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
3697                         (0xff & ~CODE_DIRTY_FLAG);
3698                 }
3699                 addr1 += l;
3700                 access_len -= l;
3701             }
3702         }
3703         return;
3704     }
3705     if (is_write) {
3706         cpu_physical_memory_write(bounce.addr, bounce.buffer, access_len);
3707     }
3708     qemu_vfree(bounce.buffer);
3709     bounce.buffer = NULL;
3710     cpu_notify_map_clients();
3711 }
3712
3713 /* warning: addr must be aligned */
3714 uint32_t ldl_phys(target_phys_addr_t addr)
3715 {
3716     int io_index;
3717     uint8_t *ptr;
3718     uint32_t val;
3719     unsigned long pd;
3720     PhysPageDesc *p;
3721
3722     p = phys_page_find(addr >> TARGET_PAGE_BITS);
3723     if (!p) {
3724         pd = IO_MEM_UNASSIGNED;
3725     } else {
3726         pd = p->phys_offset;
3727     }
3728
3729     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
3730         !(pd & IO_MEM_ROMD)) {
3731         /* I/O case */
3732         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3733         if (p)
3734             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3735         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
3736     } else {
3737         /* RAM case */
3738         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
3739             (addr & ~TARGET_PAGE_MASK);
3740         val = ldl_p(ptr);
3741     }
3742     return val;
3743 }
3744
3745 /* warning: addr must be aligned */
3746 uint64_t ldq_phys(target_phys_addr_t addr)
3747 {
3748     int io_index;
3749     uint8_t *ptr;
3750     uint64_t val;
3751     unsigned long pd;
3752     PhysPageDesc *p;
3753
3754     p = phys_page_find(addr >> TARGET_PAGE_BITS);
3755     if (!p) {
3756         pd = IO_MEM_UNASSIGNED;
3757     } else {
3758         pd = p->phys_offset;
3759     }
3760
3761     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
3762         !(pd & IO_MEM_ROMD)) {
3763         /* I/O case */
3764         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3765         if (p)
3766             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3767 #ifdef TARGET_WORDS_BIGENDIAN
3768         val = (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr) << 32;
3769         val |= io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4);
3770 #else
3771         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
3772         val |= (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4) << 32;
3773 #endif
3774     } else {
3775         /* RAM case */
3776         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
3777             (addr & ~TARGET_PAGE_MASK);
3778         val = ldq_p(ptr);
3779     }
3780     return val;
3781 }
3782
3783 /* XXX: optimize */
3784 uint32_t ldub_phys(target_phys_addr_t addr)
3785 {
3786     uint8_t val;
3787     cpu_physical_memory_read(addr, &val, 1);
3788     return val;
3789 }
3790
3791 /* XXX: optimize */
3792 uint32_t lduw_phys(target_phys_addr_t addr)
3793 {
3794     uint16_t val;
3795     cpu_physical_memory_read(addr, (uint8_t *)&val, 2);
3796     return tswap16(val);
3797 }
3798
3799 /* warning: addr must be aligned. The ram page is not masked as dirty
3800    and the code inside is not invalidated. It is useful if the dirty
3801    bits are used to track modified PTEs */
3802 void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val)
3803 {
3804     int io_index;
3805     uint8_t *ptr;
3806     unsigned long pd;
3807     PhysPageDesc *p;
3808
3809     p = phys_page_find(addr >> TARGET_PAGE_BITS);
3810     if (!p) {
3811         pd = IO_MEM_UNASSIGNED;
3812     } else {
3813         pd = p->phys_offset;
3814     }
3815
3816     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3817         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3818         if (p)
3819             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3820         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
3821     } else {
3822         unsigned long addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3823         ptr = qemu_get_ram_ptr(addr1);
3824         stl_p(ptr, val);
3825
3826         if (unlikely(in_migration)) {
3827             if (!cpu_physical_memory_is_dirty(addr1)) {
3828                 /* invalidate code */
3829                 tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
3830                 /* set dirty bit */
3831                 phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
3832                     (0xff & ~CODE_DIRTY_FLAG);
3833             }
3834         }
3835     }
3836 }
3837
3838 void stq_phys_notdirty(target_phys_addr_t addr, uint64_t val)
3839 {
3840     int io_index;
3841     uint8_t *ptr;
3842     unsigned long pd;
3843     PhysPageDesc *p;
3844
3845     p = phys_page_find(addr >> TARGET_PAGE_BITS);
3846     if (!p) {
3847         pd = IO_MEM_UNASSIGNED;
3848     } else {
3849         pd = p->phys_offset;
3850     }
3851
3852     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3853         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3854         if (p)
3855             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3856 #ifdef TARGET_WORDS_BIGENDIAN
3857         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val >> 32);
3858         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val);
3859 #else
3860         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
3861         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val >> 32);
3862 #endif
3863     } else {
3864         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
3865             (addr & ~TARGET_PAGE_MASK);
3866         stq_p(ptr, val);
3867     }
3868 }
3869
3870 /* warning: addr must be aligned */
3871 void stl_phys(target_phys_addr_t addr, uint32_t val)
3872 {
3873     int io_index;
3874     uint8_t *ptr;
3875     unsigned long pd;
3876     PhysPageDesc *p;
3877
3878     p = phys_page_find(addr >> TARGET_PAGE_BITS);
3879     if (!p) {
3880         pd = IO_MEM_UNASSIGNED;
3881     } else {
3882         pd = p->phys_offset;
3883     }
3884
3885     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3886         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3887         if (p)
3888             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3889         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
3890     } else {
3891         unsigned long addr1;
3892         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3893         /* RAM case */
3894         ptr = qemu_get_ram_ptr(addr1);
3895         stl_p(ptr, val);
3896         if (!cpu_physical_memory_is_dirty(addr1)) {
3897             /* invalidate code */
3898             tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
3899             /* set dirty bit */
3900             phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
3901                 (0xff & ~CODE_DIRTY_FLAG);
3902         }
3903     }
3904 }
3905
3906 /* XXX: optimize */
3907 void stb_phys(target_phys_addr_t addr, uint32_t val)
3908 {
3909     uint8_t v = val;
3910     cpu_physical_memory_write(addr, &v, 1);
3911 }
3912
3913 /* XXX: optimize */
3914 void stw_phys(target_phys_addr_t addr, uint32_t val)
3915 {
3916     uint16_t v = tswap16(val);
3917     cpu_physical_memory_write(addr, (const uint8_t *)&v, 2);
3918 }
3919
3920 /* XXX: optimize */
3921 void stq_phys(target_phys_addr_t addr, uint64_t val)
3922 {
3923     val = tswap64(val);
3924     cpu_physical_memory_write(addr, (const uint8_t *)&val, 8);
3925 }
3926
3927 /* virtual memory access for debug (includes writing to ROM) */
3928 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
3929                         uint8_t *buf, int len, int is_write)
3930 {
3931     int l;
3932     target_phys_addr_t phys_addr;
3933     target_ulong page;
3934
3935     while (len > 0) {
3936         page = addr & TARGET_PAGE_MASK;
3937         phys_addr = cpu_get_phys_page_debug(env, page);
3938         /* if no physical page mapped, return an error */
3939         if (phys_addr == -1)
3940             return -1;
3941         l = (page + TARGET_PAGE_SIZE) - addr;
3942         if (l > len)
3943             l = len;
3944         phys_addr += (addr & ~TARGET_PAGE_MASK);
3945         if (is_write)
3946             cpu_physical_memory_write_rom(phys_addr, buf, l);
3947         else
3948             cpu_physical_memory_rw(phys_addr, buf, l, is_write);
3949         len -= l;
3950         buf += l;
3951         addr += l;
3952     }
3953     return 0;
3954 }
3955 #endif
3956
3957 /* in deterministic execution mode, instructions doing device I/Os
3958    must be at the end of the TB */
3959 void cpu_io_recompile(CPUState *env, void *retaddr)
3960 {
3961     TranslationBlock *tb;
3962     uint32_t n, cflags;
3963     target_ulong pc, cs_base;
3964     uint64_t flags;
3965
3966     tb = tb_find_pc((unsigned long)retaddr);
3967     if (!tb) {
3968         cpu_abort(env, "cpu_io_recompile: could not find TB for pc=%p",
3969                   retaddr);
3970     }
3971     n = env->icount_decr.u16.low + tb->icount;
3972     cpu_restore_state(tb, env, (unsigned long)retaddr, NULL);
3973     /* Calculate how many instructions had been executed before the fault
3974        occurred.  */
3975     n = n - env->icount_decr.u16.low;
3976     /* Generate a new TB ending on the I/O insn.  */
3977     n++;
3978     /* On MIPS and SH, delay slot instructions can only be restarted if
3979        they were already the first instruction in the TB.  If this is not
3980        the first instruction in a TB then re-execute the preceding
3981        branch.  */
3982 #if defined(TARGET_MIPS)
3983     if ((env->hflags & MIPS_HFLAG_BMASK) != 0 && n > 1) {
3984         env->active_tc.PC -= 4;
3985         env->icount_decr.u16.low++;
3986         env->hflags &= ~MIPS_HFLAG_BMASK;
3987     }
3988 #elif defined(TARGET_SH4)
3989     if ((env->flags & ((DELAY_SLOT | DELAY_SLOT_CONDITIONAL))) != 0
3990             && n > 1) {
3991         env->pc -= 2;
3992         env->icount_decr.u16.low++;
3993         env->flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
3994     }
3995 #endif
3996     /* This should never happen.  */
3997     if (n > CF_COUNT_MASK)
3998         cpu_abort(env, "TB too big during recompile");
3999
4000     cflags = n | CF_LAST_IO;
4001     pc = tb->pc;
4002     cs_base = tb->cs_base;
4003     flags = tb->flags;
4004     tb_phys_invalidate(tb, -1);
4005     /* FIXME: In theory this could raise an exception.  In practice
4006        we have already translated the block once so it's probably ok.  */
4007     tb_gen_code(env, pc, cs_base, flags, cflags);
4008     /* TODO: If env->pc != tb->pc (i.e. the faulting instruction was not
4009        the first in the TB) then we end up generating a whole new TB and
4010        repeating the fault, which is horribly inefficient.
4011        Better would be to execute just this insn uncached, or generate a
4012        second new TB.  */
4013     cpu_resume_from_signal(env, NULL);
4014 }
4015
4016 #if !defined(CONFIG_USER_ONLY)
4017
4018 void dump_exec_info(FILE *f,
4019                     int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
4020 {
4021     int i, target_code_size, max_target_code_size;
4022     int direct_jmp_count, direct_jmp2_count, cross_page;
4023     TranslationBlock *tb;
4024
4025     target_code_size = 0;
4026     max_target_code_size = 0;
4027     cross_page = 0;
4028     direct_jmp_count = 0;
4029     direct_jmp2_count = 0;
4030     for(i = 0; i < nb_tbs; i++) {
4031         tb = &tbs[i];
4032         target_code_size += tb->size;
4033         if (tb->size > max_target_code_size)
4034             max_target_code_size = tb->size;
4035         if (tb->page_addr[1] != -1)
4036             cross_page++;
4037         if (tb->tb_next_offset[0] != 0xffff) {
4038             direct_jmp_count++;
4039             if (tb->tb_next_offset[1] != 0xffff) {
4040                 direct_jmp2_count++;
4041             }
4042         }
4043     }
4044     /* XXX: avoid using doubles ? */
4045     cpu_fprintf(f, "Translation buffer state:\n");
4046     cpu_fprintf(f, "gen code size       %ld/%ld\n",
4047                 code_gen_ptr - code_gen_buffer, code_gen_buffer_max_size);
4048     cpu_fprintf(f, "TB count            %d/%d\n",
4049                 nb_tbs, code_gen_max_blocks);
4050     cpu_fprintf(f, "TB avg target size  %d max=%d bytes\n",
4051                 nb_tbs ? target_code_size / nb_tbs : 0,
4052                 max_target_code_size);
4053     cpu_fprintf(f, "TB avg host size    %d bytes (expansion ratio: %0.1f)\n",
4054                 nb_tbs ? (code_gen_ptr - code_gen_buffer) / nb_tbs : 0,
4055                 target_code_size ? (double) (code_gen_ptr - code_gen_buffer) / target_code_size : 0);
4056     cpu_fprintf(f, "cross page TB count %d (%d%%)\n",
4057             cross_page,
4058             nb_tbs ? (cross_page * 100) / nb_tbs : 0);
4059     cpu_fprintf(f, "direct jump count   %d (%d%%) (2 jumps=%d %d%%)\n",
4060                 direct_jmp_count,
4061                 nb_tbs ? (direct_jmp_count * 100) / nb_tbs : 0,
4062                 direct_jmp2_count,
4063                 nb_tbs ? (direct_jmp2_count * 100) / nb_tbs : 0);
4064     cpu_fprintf(f, "\nStatistics:\n");
4065     cpu_fprintf(f, "TB flush count      %d\n", tb_flush_count);
4066     cpu_fprintf(f, "TB invalidate count %d\n", tb_phys_invalidate_count);
4067     cpu_fprintf(f, "TLB flush count     %d\n", tlb_flush_count);
4068     tcg_dump_info(f, cpu_fprintf);
4069 }
4070
4071 #define MMUSUFFIX _cmmu
4072 #define GETPC() NULL
4073 #define env cpu_single_env
4074 #define SOFTMMU_CODE_ACCESS
4075
4076 #define SHIFT 0
4077 #include "softmmu_template.h"
4078
4079 #define SHIFT 1
4080 #include "softmmu_template.h"
4081
4082 #define SHIFT 2
4083 #include "softmmu_template.h"
4084
4085 #define SHIFT 3
4086 #include "softmmu_template.h"
4087
4088 #undef env
4089
4090 #endif