Diff for /qemu/exec.c between versions 1.1.1.15 and 1.1.1.16

version 1.1.1.15, 2018/04/24 18:56:22 version 1.1.1.16, 2018/04/24 19:17:27
Line 33 Line 33
 #include "kvm.h"  #include "kvm.h"
 #include "hw/xen.h"  #include "hw/xen.h"
 #include "qemu-timer.h"  #include "qemu-timer.h"
   #include "memory.h"
   #include "exec-memory.h"
 #if defined(CONFIG_USER_ONLY)  #if defined(CONFIG_USER_ONLY)
 #include <qemu.h>  #include <qemu.h>
 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)  #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
Line 108  static uint8_t *code_gen_ptr; Line 110  static uint8_t *code_gen_ptr;
 int phys_ram_fd;  int phys_ram_fd;
 static int in_migration;  static int in_migration;
   
 RAMList ram_list = { .blocks = QLIST_HEAD_INITIALIZER(ram_list) };  RAMList ram_list = { .blocks = QLIST_HEAD_INITIALIZER(ram_list.blocks) };
   
   static MemoryRegion *system_memory;
   static MemoryRegion *system_io;
   
 #endif  #endif
   
 CPUState *first_cpu;  CPUState *first_cpu;
 /* current CPU in the current thread. It is only valid inside  /* current CPU in the current thread. It is only valid inside
    cpu_exec() */     cpu_exec() */
 CPUState *cpu_single_env;  DEFINE_TLS(CPUState *,cpu_single_env);
 /* 0 = Do not count executed instructions.  /* 0 = Do not count executed instructions.
    1 = Precise instruction counting.     1 = Precise instruction counting.
    2 = Adaptive rate instruction counting.  */     2 = Adaptive rate instruction counting.  */
 int use_icount = 0;  int use_icount = 0;
 /* Current instruction counter.  While executing translated code this may  
    include some instructions that have not yet been executed.  */  
 int64_t qemu_icount;  
   
 typedef struct PageDesc {  typedef struct PageDesc {
     /* list of TBs intersecting this ram page */      /* list of TBs intersecting this ram page */
Line 177  typedef struct PageDesc { Line 180  typedef struct PageDesc {
 #define V_L1_SHIFT (L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS - V_L1_BITS)  #define V_L1_SHIFT (L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS - V_L1_BITS)
   
 unsigned long qemu_real_host_page_size;  unsigned long qemu_real_host_page_size;
 unsigned long qemu_host_page_bits;  
 unsigned long qemu_host_page_size;  unsigned long qemu_host_page_size;
 unsigned long qemu_host_page_mask;  unsigned long qemu_host_page_mask;
   
Line 197  typedef struct PhysPageDesc { Line 199  typedef struct PhysPageDesc {
 static void *l1_phys_map[P_L1_SIZE];  static void *l1_phys_map[P_L1_SIZE];
   
 static void io_mem_init(void);  static void io_mem_init(void);
   static void memory_map_init(void);
   
 /* io memory support */  /* io memory support */
 CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];  CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
Line 267  static void page_init(void) Line 270  static void page_init(void)
         qemu_host_page_size = qemu_real_host_page_size;          qemu_host_page_size = qemu_real_host_page_size;
     if (qemu_host_page_size < TARGET_PAGE_SIZE)      if (qemu_host_page_size < TARGET_PAGE_SIZE)
         qemu_host_page_size = TARGET_PAGE_SIZE;          qemu_host_page_size = TARGET_PAGE_SIZE;
     qemu_host_page_bits = 0;  
     while ((1 << qemu_host_page_bits) < qemu_host_page_size)  
         qemu_host_page_bits++;  
     qemu_host_page_mask = ~(qemu_host_page_size - 1);      qemu_host_page_mask = ~(qemu_host_page_size - 1);
   
 #if defined(CONFIG_BSD) && defined(CONFIG_USER_ONLY)  #if defined(CONFIG_BSD) && defined(CONFIG_USER_ONLY)
Line 345  static PageDesc *page_find_alloc(tb_page Line 345  static PageDesc *page_find_alloc(tb_page
     int i;      int i;
   
 #if defined(CONFIG_USER_ONLY)  #if defined(CONFIG_USER_ONLY)
     /* We can't use qemu_malloc because it may recurse into a locked mutex. */      /* We can't use g_malloc because it may recurse into a locked mutex. */
 # define ALLOC(P, SIZE)                                 \  # define ALLOC(P, SIZE)                                 \
     do {                                                \      do {                                                \
         P = mmap(NULL, SIZE, PROT_READ | PROT_WRITE,    \          P = mmap(NULL, SIZE, PROT_READ | PROT_WRITE,    \
Line 353  static PageDesc *page_find_alloc(tb_page Line 353  static PageDesc *page_find_alloc(tb_page
     } while (0)      } while (0)
 #else  #else
 # define ALLOC(P, SIZE) \  # define ALLOC(P, SIZE) \
     do { P = qemu_mallocz(SIZE); } while (0)      do { P = g_malloc0(SIZE); } while (0)
 #endif  #endif
   
     /* Level 1.  Always allocated.  */      /* Level 1.  Always allocated.  */
Line 410  static PhysPageDesc *phys_page_find_allo Line 410  static PhysPageDesc *phys_page_find_allo
             if (!alloc) {              if (!alloc) {
                 return NULL;                  return NULL;
             }              }
             *lp = p = qemu_mallocz(sizeof(void *) * L2_SIZE);              *lp = p = g_malloc0(sizeof(void *) * L2_SIZE);
         }          }
         lp = p + ((index >> (i * L2_BITS)) & (L2_SIZE - 1));          lp = p + ((index >> (i * L2_BITS)) & (L2_SIZE - 1));
     }      }
Line 423  static PhysPageDesc *phys_page_find_allo Line 423  static PhysPageDesc *phys_page_find_allo
             return NULL;              return NULL;
         }          }
   
         *lp = pd = qemu_malloc(sizeof(PhysPageDesc) * L2_SIZE);          *lp = pd = g_malloc(sizeof(PhysPageDesc) * L2_SIZE);
   
         for (i = 0; i < L2_SIZE; i++) {          for (i = 0; i < L2_SIZE; i++) {
             pd[i].phys_offset = IO_MEM_UNASSIGNED;              pd[i].phys_offset = IO_MEM_UNASSIGNED;
Line 469  static void code_gen_alloc(unsigned long Line 469  static void code_gen_alloc(unsigned long
     code_gen_buffer_size = tb_size;      code_gen_buffer_size = tb_size;
     if (code_gen_buffer_size == 0) {      if (code_gen_buffer_size == 0) {
 #if defined(CONFIG_USER_ONLY)  #if defined(CONFIG_USER_ONLY)
         /* in user mode, phys_ram_size is not meaningful */  
         code_gen_buffer_size = DEFAULT_CODE_GEN_BUFFER_SIZE;          code_gen_buffer_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
 #else  #else
         /* XXX: needs adjustments */          /* XXX: needs adjustments */
Line 520  static void code_gen_alloc(unsigned long Line 519  static void code_gen_alloc(unsigned long
         }          }
     }      }
 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \  #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
     || defined(__DragonFly__) || defined(__OpenBSD__)      || defined(__DragonFly__) || defined(__OpenBSD__) \
       || defined(__NetBSD__)
     {      {
         int flags;          int flags;
         void *addr = NULL;          void *addr = NULL;
Line 550  static void code_gen_alloc(unsigned long Line 550  static void code_gen_alloc(unsigned long
         }          }
     }      }
 #else  #else
     code_gen_buffer = qemu_malloc(code_gen_buffer_size);      code_gen_buffer = g_malloc(code_gen_buffer_size);
     map_exec(code_gen_buffer, code_gen_buffer_size);      map_exec(code_gen_buffer, code_gen_buffer_size);
 #endif  #endif
 #endif /* !USE_STATIC_CODE_GEN_BUFFER */  #endif /* !USE_STATIC_CODE_GEN_BUFFER */
Line 558  static void code_gen_alloc(unsigned long Line 558  static void code_gen_alloc(unsigned long
     code_gen_buffer_max_size = code_gen_buffer_size -      code_gen_buffer_max_size = code_gen_buffer_size -
         (TCG_MAX_OP_SIZE * OPC_BUF_SIZE);          (TCG_MAX_OP_SIZE * OPC_BUF_SIZE);
     code_gen_max_blocks = code_gen_buffer_size / CODE_GEN_AVG_BLOCK_SIZE;      code_gen_max_blocks = code_gen_buffer_size / CODE_GEN_AVG_BLOCK_SIZE;
     tbs = qemu_malloc(code_gen_max_blocks * sizeof(TranslationBlock));      tbs = g_malloc(code_gen_max_blocks * sizeof(TranslationBlock));
 }  }
   
 /* Must be called before using the QEMU cpus. 'tb_size' is the size  /* Must be called before using the QEMU cpus. 'tb_size' is the size
    (in bytes) allocated to the translation buffer. Zero means default     (in bytes) allocated to the translation buffer. Zero means default
    size. */     size. */
 void cpu_exec_init_all(unsigned long tb_size)  void tcg_exec_init(unsigned long tb_size)
 {  {
     cpu_gen_init();      cpu_gen_init();
     code_gen_alloc(tb_size);      code_gen_alloc(tb_size);
     code_gen_ptr = code_gen_buffer;      code_gen_ptr = code_gen_buffer;
     page_init();      page_init();
 #if !defined(CONFIG_USER_ONLY)  
     io_mem_init();  
 #endif  
 #if !defined(CONFIG_USER_ONLY) || !defined(CONFIG_USE_GUEST_BASE)  #if !defined(CONFIG_USER_ONLY) || !defined(CONFIG_USE_GUEST_BASE)
     /* There's no guest base to take into account, so go ahead and      /* There's no guest base to take into account, so go ahead and
        initialize the prologue now.  */         initialize the prologue now.  */
Line 580  void cpu_exec_init_all(unsigned long tb_ Line 577  void cpu_exec_init_all(unsigned long tb_
 #endif  #endif
 }  }
   
   bool tcg_enabled(void)
   {
       return code_gen_buffer != NULL;
   }
   
   void cpu_exec_init_all(void)
   {
   #if !defined(CONFIG_USER_ONLY)
       memory_map_init();
       io_mem_init();
   #endif
   }
   
 #if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)  #if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
   
 static int cpu_common_post_load(void *opaque, int version_id)  static int cpu_common_post_load(void *opaque, int version_id)
Line 683  void tb_free(TranslationBlock *tb) Line 693  void tb_free(TranslationBlock *tb)
 static inline void invalidate_page_bitmap(PageDesc *p)  static inline void invalidate_page_bitmap(PageDesc *p)
 {  {
     if (p->code_bitmap) {      if (p->code_bitmap) {
         qemu_free(p->code_bitmap);          g_free(p->code_bitmap);
         p->code_bitmap = NULL;          p->code_bitmap = NULL;
     }      }
     p->code_write_count = 0;      p->code_write_count = 0;
Line 943  static void build_page_bitmap(PageDesc * Line 953  static void build_page_bitmap(PageDesc *
     int n, tb_start, tb_end;      int n, tb_start, tb_end;
     TranslationBlock *tb;      TranslationBlock *tb;
   
     p->code_bitmap = qemu_mallocz(TARGET_PAGE_SIZE / 8);      p->code_bitmap = g_malloc0(TARGET_PAGE_SIZE / 8);
   
     tb = p->first_tb;      tb = p->first_tb;
     while (tb != NULL) {      while (tb != NULL) {
Line 1430  int cpu_watchpoint_insert(CPUState *env, Line 1440  int cpu_watchpoint_insert(CPUState *env,
                 TARGET_FMT_lx ", len=" TARGET_FMT_lu "\n", addr, len);                  TARGET_FMT_lx ", len=" TARGET_FMT_lu "\n", addr, len);
         return -EINVAL;          return -EINVAL;
     }      }
     wp = qemu_malloc(sizeof(*wp));      wp = g_malloc(sizeof(*wp));
   
     wp->vaddr = addr;      wp->vaddr = addr;
     wp->len_mask = len_mask;      wp->len_mask = len_mask;
Line 1473  void cpu_watchpoint_remove_by_ref(CPUSta Line 1483  void cpu_watchpoint_remove_by_ref(CPUSta
   
     tlb_flush_page(env, watchpoint->vaddr);      tlb_flush_page(env, watchpoint->vaddr);
   
     qemu_free(watchpoint);      g_free(watchpoint);
 }  }
   
 /* Remove all matching watchpoints.  */  /* Remove all matching watchpoints.  */
Line 1495  int cpu_breakpoint_insert(CPUState *env, Line 1505  int cpu_breakpoint_insert(CPUState *env,
 #if defined(TARGET_HAS_ICE)  #if defined(TARGET_HAS_ICE)
     CPUBreakpoint *bp;      CPUBreakpoint *bp;
   
     bp = qemu_malloc(sizeof(*bp));      bp = g_malloc(sizeof(*bp));
   
     bp->pc = pc;      bp->pc = pc;
     bp->flags = flags;      bp->flags = flags;
Line 1542  void cpu_breakpoint_remove_by_ref(CPUSta Line 1552  void cpu_breakpoint_remove_by_ref(CPUSta
   
     breakpoint_invalidate(env, breakpoint->pc);      breakpoint_invalidate(env, breakpoint->pc);
   
     qemu_free(breakpoint);      g_free(breakpoint);
 #endif  #endif
 }  }
   
Line 2863  static void *file_ram_alloc(RAMBlock *bl Line 2873  static void *file_ram_alloc(RAMBlock *bl
 static ram_addr_t find_ram_offset(ram_addr_t size)  static ram_addr_t find_ram_offset(ram_addr_t size)
 {  {
     RAMBlock *block, *next_block;      RAMBlock *block, *next_block;
     ram_addr_t offset = 0, mingap = ULONG_MAX;      ram_addr_t offset = RAM_ADDR_MAX, mingap = RAM_ADDR_MAX;
   
     if (QLIST_EMPTY(&ram_list.blocks))      if (QLIST_EMPTY(&ram_list.blocks))
         return 0;          return 0;
   
     QLIST_FOREACH(block, &ram_list.blocks, next) {      QLIST_FOREACH(block, &ram_list.blocks, next) {
         ram_addr_t end, next = ULONG_MAX;          ram_addr_t end, next = RAM_ADDR_MAX;
   
         end = block->offset + block->length;          end = block->offset + block->length;
   
Line 2879  static ram_addr_t find_ram_offset(ram_ad Line 2889  static ram_addr_t find_ram_offset(ram_ad
             }              }
         }          }
         if (next - end >= size && next - end < mingap) {          if (next - end >= size && next - end < mingap) {
             offset =  end;              offset = end;
             mingap = next - end;              mingap = next - end;
         }          }
     }      }
   
       if (offset == RAM_ADDR_MAX) {
           fprintf(stderr, "Failed to find gap of requested size: %" PRIu64 "\n",
                   (uint64_t)size);
           abort();
       }
   
     return offset;      return offset;
 }  }
   
Line 2903  ram_addr_t qemu_ram_alloc_from_ptr(Devic Line 2920  ram_addr_t qemu_ram_alloc_from_ptr(Devic
     RAMBlock *new_block, *block;      RAMBlock *new_block, *block;
   
     size = TARGET_PAGE_ALIGN(size);      size = TARGET_PAGE_ALIGN(size);
     new_block = qemu_mallocz(sizeof(*new_block));      new_block = g_malloc0(sizeof(*new_block));
   
     if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {      if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
         char *id = dev->parent_bus->info->get_dev_path(dev);          char *id = dev->parent_bus->info->get_dev_path(dev);
         if (id) {          if (id) {
             snprintf(new_block->idstr, sizeof(new_block->idstr), "%s/", id);              snprintf(new_block->idstr, sizeof(new_block->idstr), "%s/", id);
             qemu_free(id);              g_free(id);
         }          }
     }      }
     pstrcat(new_block->idstr, sizeof(new_block->idstr), name);      pstrcat(new_block->idstr, sizeof(new_block->idstr), name);
Line 2966  ram_addr_t qemu_ram_alloc_from_ptr(Devic Line 2983  ram_addr_t qemu_ram_alloc_from_ptr(Devic
   
     QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);      QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);
   
     ram_list.phys_dirty = qemu_realloc(ram_list.phys_dirty,      ram_list.phys_dirty = g_realloc(ram_list.phys_dirty,
                                        last_ram_offset() >> TARGET_PAGE_BITS);                                         last_ram_offset() >> TARGET_PAGE_BITS);
     memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),      memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
            0xff, size >> TARGET_PAGE_BITS);             0xff, size >> TARGET_PAGE_BITS);
Line 2989  void qemu_ram_free_from_ptr(ram_addr_t a Line 3006  void qemu_ram_free_from_ptr(ram_addr_t a
     QLIST_FOREACH(block, &ram_list.blocks, next) {      QLIST_FOREACH(block, &ram_list.blocks, next) {
         if (addr == block->offset) {          if (addr == block->offset) {
             QLIST_REMOVE(block, next);              QLIST_REMOVE(block, next);
             qemu_free(block);              g_free(block);
             return;              return;
         }          }
     }      }
Line 3026  void qemu_ram_free(ram_addr_t addr) Line 3043  void qemu_ram_free(ram_addr_t addr)
                 }                  }
 #endif  #endif
             }              }
             qemu_free(block);              g_free(block);
             return;              return;
         }          }
     }      }
Line 3081  void qemu_ram_remap(ram_addr_t addr, ram Line 3098  void qemu_ram_remap(ram_addr_t addr, ram
 #endif  #endif
                 }                  }
                 if (area != vaddr) {                  if (area != vaddr) {
                     fprintf(stderr, "Could not remap addr: %lx@%lx\n",                      fprintf(stderr, "Could not remap addr: "
                               RAM_ADDR_FMT "@" RAM_ADDR_FMT "\n",
                             length, addr);                              length, addr);
                     exit(1);                      exit(1);
                 }                  }
Line 3552  static CPUWriteMemoryFunc * const subpag Line 3570  static CPUWriteMemoryFunc * const subpag
     &subpage_writel,      &subpage_writel,
 };  };
   
   static uint32_t subpage_ram_readb(void *opaque, target_phys_addr_t addr)
   {
       ram_addr_t raddr = addr;
       void *ptr = qemu_get_ram_ptr(raddr);
       return ldub_p(ptr);
   }
   
   static void subpage_ram_writeb(void *opaque, target_phys_addr_t addr,
                                  uint32_t value)
   {
       ram_addr_t raddr = addr;
       void *ptr = qemu_get_ram_ptr(raddr);
       stb_p(ptr, value);
   }
   
   static uint32_t subpage_ram_readw(void *opaque, target_phys_addr_t addr)
   {
       ram_addr_t raddr = addr;
       void *ptr = qemu_get_ram_ptr(raddr);
       return lduw_p(ptr);
   }
   
   static void subpage_ram_writew(void *opaque, target_phys_addr_t addr,
                                  uint32_t value)
   {
       ram_addr_t raddr = addr;
       void *ptr = qemu_get_ram_ptr(raddr);
       stw_p(ptr, value);
   }
   
   static uint32_t subpage_ram_readl(void *opaque, target_phys_addr_t addr)
   {
       ram_addr_t raddr = addr;
       void *ptr = qemu_get_ram_ptr(raddr);
       return ldl_p(ptr);
   }
   
   static void subpage_ram_writel(void *opaque, target_phys_addr_t addr,
                                  uint32_t value)
   {
       ram_addr_t raddr = addr;
       void *ptr = qemu_get_ram_ptr(raddr);
       stl_p(ptr, value);
   }
   
   static CPUReadMemoryFunc * const subpage_ram_read[] = {
       &subpage_ram_readb,
       &subpage_ram_readw,
       &subpage_ram_readl,
   };
   
   static CPUWriteMemoryFunc * const subpage_ram_write[] = {
       &subpage_ram_writeb,
       &subpage_ram_writew,
       &subpage_ram_writel,
   };
   
 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,  static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
                              ram_addr_t memory, ram_addr_t region_offset)                               ram_addr_t memory, ram_addr_t region_offset)
 {  {
Line 3565  static int subpage_register (subpage_t * Line 3640  static int subpage_register (subpage_t *
     printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %ld\n", __func__,      printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %ld\n", __func__,
            mmio, start, end, idx, eidx, memory);             mmio, start, end, idx, eidx, memory);
 #endif  #endif
     if ((memory & ~TARGET_PAGE_MASK) == IO_MEM_RAM)      if ((memory & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
         memory = IO_MEM_UNASSIGNED;          memory = IO_MEM_SUBPAGE_RAM;
       }
     memory = (memory >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);      memory = (memory >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
     for (; idx <= eidx; idx++) {      for (; idx <= eidx; idx++) {
         mmio->sub_io_index[idx] = memory;          mmio->sub_io_index[idx] = memory;
Line 3583  static subpage_t *subpage_init (target_p Line 3659  static subpage_t *subpage_init (target_p
     subpage_t *mmio;      subpage_t *mmio;
     int subpage_memory;      int subpage_memory;
   
     mmio = qemu_mallocz(sizeof(subpage_t));      mmio = g_malloc0(sizeof(subpage_t));
   
     mmio->base = base;      mmio->base = base;
     subpage_memory = cpu_register_io_memory(subpage_read, subpage_write, mmio,      subpage_memory = cpu_register_io_memory(subpage_read, subpage_write, mmio,
Line 3689  static CPUWriteMemoryFunc * const swapen Line 3765  static CPUWriteMemoryFunc * const swapen
   
 static void swapendian_init(int io_index)  static void swapendian_init(int io_index)
 {  {
     SwapEndianContainer *c = qemu_malloc(sizeof(SwapEndianContainer));      SwapEndianContainer *c = g_malloc(sizeof(SwapEndianContainer));
     int i;      int i;
   
     /* Swap mmio for big endian targets */      /* Swap mmio for big endian targets */
Line 3707  static void swapendian_init(int io_index Line 3783  static void swapendian_init(int io_index
 static void swapendian_del(int io_index)  static void swapendian_del(int io_index)
 {  {
     if (io_mem_read[io_index][0] == swapendian_readfn[0]) {      if (io_mem_read[io_index][0] == swapendian_readfn[0]) {
         qemu_free(io_mem_opaque[io_index]);          g_free(io_mem_opaque[io_index]);
     }      }
 }  }
   
Line 3799  static void io_mem_init(void) Line 3875  static void io_mem_init(void)
     cpu_register_io_memory_fixed(IO_MEM_NOTDIRTY, error_mem_read,      cpu_register_io_memory_fixed(IO_MEM_NOTDIRTY, error_mem_read,
                                  notdirty_mem_write, NULL,                                   notdirty_mem_write, NULL,
                                  DEVICE_NATIVE_ENDIAN);                                   DEVICE_NATIVE_ENDIAN);
       cpu_register_io_memory_fixed(IO_MEM_SUBPAGE_RAM, subpage_ram_read,
                                    subpage_ram_write, NULL,
                                    DEVICE_NATIVE_ENDIAN);
     for (i=0; i<5; i++)      for (i=0; i<5; i++)
         io_mem_used[i] = 1;          io_mem_used[i] = 1;
   
Line 3807  static void io_mem_init(void) Line 3886  static void io_mem_init(void)
                                           DEVICE_NATIVE_ENDIAN);                                            DEVICE_NATIVE_ENDIAN);
 }  }
   
   static void memory_map_init(void)
   {
       system_memory = g_malloc(sizeof(*system_memory));
       memory_region_init(system_memory, "system", INT64_MAX);
       set_system_memory_map(system_memory);
   
       system_io = g_malloc(sizeof(*system_io));
       memory_region_init(system_io, "io", 65536);
       set_system_io_map(system_io);
   }
   
   MemoryRegion *get_system_memory(void)
   {
       return system_memory;
   }
   
   MemoryRegion *get_system_io(void)
   {
       return system_io;
   }
   
 #endif /* !defined(CONFIG_USER_ONLY) */  #endif /* !defined(CONFIG_USER_ONLY) */
   
 /* physical memory access (slow version, mainly for debug) */  /* physical memory access (slow version, mainly for debug) */
Line 3858  void cpu_physical_memory_rw(target_phys_ Line 3958  void cpu_physical_memory_rw(target_phys_
     uint8_t *ptr;      uint8_t *ptr;
     uint32_t val;      uint32_t val;
     target_phys_addr_t page;      target_phys_addr_t page;
     unsigned long pd;      ram_addr_t pd;
     PhysPageDesc *p;      PhysPageDesc *p;
   
     while (len > 0) {      while (len > 0) {
Line 3898  void cpu_physical_memory_rw(target_phys_ Line 3998  void cpu_physical_memory_rw(target_phys_
                     l = 1;                      l = 1;
                 }                  }
             } else {              } else {
                 unsigned long addr1;                  ram_addr_t addr1;
                 addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);                  addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
                 /* RAM case */                  /* RAM case */
                 ptr = qemu_get_ram_ptr(addr1);                  ptr = qemu_get_ram_ptr(addr1);
Line 4008  static QLIST_HEAD(map_client_list, MapCl Line 4108  static QLIST_HEAD(map_client_list, MapCl
   
 void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))  void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
 {  {
     MapClient *client = qemu_malloc(sizeof(*client));      MapClient *client = g_malloc(sizeof(*client));
   
     client->opaque = opaque;      client->opaque = opaque;
     client->callback = callback;      client->callback = callback;
Line 4021  void cpu_unregister_map_client(void *_cl Line 4121  void cpu_unregister_map_client(void *_cl
     MapClient *client = (MapClient *)_client;      MapClient *client = (MapClient *)_client;
   
     QLIST_REMOVE(client, link);      QLIST_REMOVE(client, link);
     qemu_free(client);      g_free(client);
 }  }
   
 static void cpu_notify_map_clients(void)  static void cpu_notify_map_clients(void)
Line 4052  void *cpu_physical_memory_map(target_phy Line 4152  void *cpu_physical_memory_map(target_phy
     target_phys_addr_t page;      target_phys_addr_t page;
     unsigned long pd;      unsigned long pd;
     PhysPageDesc *p;      PhysPageDesc *p;
     ram_addr_t raddr = ULONG_MAX;      ram_addr_t raddr = RAM_ADDR_MAX;
     ram_addr_t rlen;      ram_addr_t rlen;
     void *ret;      void *ret;
   
Line 4727  void dump_exec_info(FILE *f, fprintf_fun Line 4827  void dump_exec_info(FILE *f, fprintf_fun
 }  }
   
 #define MMUSUFFIX _cmmu  #define MMUSUFFIX _cmmu
   #undef GETPC
 #define GETPC() NULL  #define GETPC() NULL
 #define env cpu_single_env  #define env cpu_single_env
 #define SOFTMMU_CODE_ACCESS  #define SOFTMMU_CODE_ACCESS

Removed from v.1.1.1.15  
changed lines
  Added in v.1.1.1.16


unix.superglobalmegacorp.com