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