include/exec/ram_addr.h

   1 /*
   2  * Declarations for cpu physical memory functions
   3  *
   4  * Copyright 2011 Red Hat, Inc. and/or its affiliates
   5  *
   6  * Authors:
   7  *  Avi Kivity <avi@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or
  10  * later.  See the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 /*
  15  * This header is for use by exec.c and memory.c ONLY.  Do not include it.
  16  * The functions declared here will be removed soon.
  17  */
  18
  19 #ifndef RAM_ADDR_H
  20 #define RAM_ADDR_H
  21
  22 #ifndef CONFIG_USER_ONLY
  23 #include "hw/xen/xen.h"
  24
  25 ram_addr_t qemu_ram_alloc_from_file(ram_addr_t size, MemoryRegion *mr,
  26                                     bool share, const char *mem_path,
  27                                     Error **errp);
  28 ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host,
  29                                    MemoryRegion *mr, Error **errp);
  30 ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr, Error **errp);
  31 ram_addr_t qemu_ram_alloc_resizeable(ram_addr_t size, ram_addr_t max_size,
  32                                      void (*resized)(const char*,
  33                                                      uint64_t length,
  34                                                      void *host),
  35                                      MemoryRegion *mr, Error **errp);
  36 int qemu_get_ram_fd(ram_addr_t addr);
  37 void *qemu_get_ram_block_host_ptr(ram_addr_t addr);
  38 void *qemu_get_ram_ptr(ram_addr_t addr);
  39 void qemu_ram_free(ram_addr_t addr);
  40 void qemu_ram_free_from_ptr(ram_addr_t addr);
  41
  42 int qemu_ram_resize(ram_addr_t base, ram_addr_t newsize, Error **errp);
  43
  44 #define DIRTY_CLIENTS_ALL     ((1 << DIRTY_MEMORY_NUM) - 1)
  45 #define DIRTY_CLIENTS_NOCODE  (DIRTY_CLIENTS_ALL & ~(1 << DIRTY_MEMORY_CODE))
  46
  47 static inline bool cpu_physical_memory_get_dirty(ram_addr_t start,
  48                                                  ram_addr_t length,
  49                                                  unsigned client)
  50 {
  51     unsigned long end, page, next;
  52
  53     assert(client < DIRTY_MEMORY_NUM);
  54
  55     end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
  56     page = start >> TARGET_PAGE_BITS;
  57     next = find_next_bit(ram_list.dirty_memory[client], end, page);
  58
  59     return next < end;
  60 }
  61
  62 static inline bool cpu_physical_memory_all_dirty(ram_addr_t start,
  63                                                  ram_addr_t length,
  64                                                  unsigned client)
  65 {
  66     unsigned long end, page, next;
  67
  68     assert(client < DIRTY_MEMORY_NUM);
  69
  70     end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
  71     page = start >> TARGET_PAGE_BITS;
  72     next = find_next_zero_bit(ram_list.dirty_memory[client], end, page);
  73
  74     return next >= end;
  75 }
  76
  77 static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr,
  78                                                       unsigned client)
  79 {
  80     return cpu_physical_memory_get_dirty(addr, 1, client);
  81 }
  82
  83 static inline bool cpu_physical_memory_is_clean(ram_addr_t addr)
  84 {
  85     bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA);
  86     bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE);
  87     bool migration =
  88         cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_MIGRATION);
  89     return !(vga && code && migration);
  90 }
  91
  92 static inline uint8_t cpu_physical_memory_range_includes_clean(ram_addr_t start,
  93                                                                ram_addr_t length,
  94                                                                uint8_t mask)
  95 {
  96     uint8_t ret = 0;
  97
  98     if (mask & (1 << DIRTY_MEMORY_VGA) &&
  99         !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_VGA)) {
 100         ret |= (1 << DIRTY_MEMORY_VGA);
 101     }
 102     if (mask & (1 << DIRTY_MEMORY_CODE) &&
 103         !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_CODE)) {
 104         ret |= (1 << DIRTY_MEMORY_CODE);
 105     }
 106     if (mask & (1 << DIRTY_MEMORY_MIGRATION) &&
 107         !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_MIGRATION)) {
 108         ret |= (1 << DIRTY_MEMORY_MIGRATION);
 109     }
 110     return ret;
 111 }
 112
 113 static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr,
 114                                                       unsigned client)
 115 {
 116     assert(client < DIRTY_MEMORY_NUM);
 117     set_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]);
 118 }
 119
 120 static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start,
 121                                                        ram_addr_t length,
 122                                                        uint8_t mask)
 123 {
 124     unsigned long end, page;
 125
 126     end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
 127     page = start >> TARGET_PAGE_BITS;
 128     if (likely(mask & (1 << DIRTY_MEMORY_MIGRATION))) {
 129         bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION], page, end - page);
 130     }
 131     if (unlikely(mask & (1 << DIRTY_MEMORY_VGA))) {
 132         bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_VGA], page, end - page);
 133     }
 134     if (unlikely(mask & (1 << DIRTY_MEMORY_CODE))) {
 135         bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_CODE], page, end - page);
 136     }
 137     xen_modified_memory(start, length);
 138 }
 139
 140 #if !defined(_WIN32)
 141 static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap,
 142                                                           ram_addr_t start,
 143                                                           ram_addr_t pages)
 144 {
 145     unsigned long i, j;
 146     unsigned long page_number, c;
 147     hwaddr addr;
 148     ram_addr_t ram_addr;
 149     unsigned long len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS;
 150     unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE;
 151     unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS);
 152
 153     /* start address is aligned at the start of a word? */
 154     if ((((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) &&
 155         (hpratio == 1)) {
 156         long k;
 157         long nr = BITS_TO_LONGS(pages);
 158
 159         for (k = 0; k < nr; k++) {
 160             if (bitmap[k]) {
 161                 unsigned long temp = leul_to_cpu(bitmap[k]);
 162
 163                 ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION][page + k] |= temp;
 164                 ram_list.dirty_memory[DIRTY_MEMORY_VGA][page + k] |= temp;
 165                 ram_list.dirty_memory[DIRTY_MEMORY_CODE][page + k] |= temp;
 166             }
 167         }
 168         xen_modified_memory(start, pages << TARGET_PAGE_BITS);
 169     } else {
 170         /*
 171          * bitmap-traveling is faster than memory-traveling (for addr...)
 172          * especially when most of the memory is not dirty.
 173          */
 174         for (i = 0; i < len; i++) {
 175             if (bitmap[i] != 0) {
 176                 c = leul_to_cpu(bitmap[i]);
 177                 do {
 178                     j = ctzl(c);
 179                     c &= ~(1ul << j);
 180                     page_number = (i * HOST_LONG_BITS + j) * hpratio;
 181                     addr = page_number * TARGET_PAGE_SIZE;
 182                     ram_addr = start + addr;
 183                     cpu_physical_memory_set_dirty_range(ram_addr,
 184                                        TARGET_PAGE_SIZE * hpratio,
 185                                        DIRTY_CLIENTS_ALL);
 186                 } while (c != 0);
 187             }
 188         }
 189     }
 190 }
 191 #endif /* not _WIN32 */
 192
 193 static inline void cpu_physical_memory_clear_dirty_range_type(ram_addr_t start,
 194                                                               ram_addr_t length,
 195                                                               unsigned client)
 196 {
 197     unsigned long end, page;
 198
 199     assert(client < DIRTY_MEMORY_NUM);
 200     end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
 201     page = start >> TARGET_PAGE_BITS;
 202     bitmap_clear(ram_list.dirty_memory[client], page, end - page);
 203 }
 204
 205 static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start,
 206                                                          ram_addr_t length)
 207 {
 208     cpu_physical_memory_clear_dirty_range_type(start, length, DIRTY_MEMORY_MIGRATION);
 209     cpu_physical_memory_clear_dirty_range_type(start, length, DIRTY_MEMORY_VGA);
 210     cpu_physical_memory_clear_dirty_range_type(start, length, DIRTY_MEMORY_CODE);
 211 }
 212
 213
 214 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length,
 215                                      unsigned client);
 216
 217 #endif
 218 #endif