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_ptr(ram_addr_t size, void *host,
  26                                    MemoryRegion *mr);
  27 ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr);
  28 void *qemu_get_ram_ptr(ram_addr_t addr);
  29 void qemu_ram_free(ram_addr_t addr);
  30 void qemu_ram_free_from_ptr(ram_addr_t addr);
  31
  32 static inline bool cpu_physical_memory_get_dirty(ram_addr_t start,
  33                                                  ram_addr_t length,
  34                                                  unsigned client)
  35 {
  36     unsigned long end, page, next;
  37
  38     assert(client < DIRTY_MEMORY_NUM);
  39
  40     end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
  41     page = start >> TARGET_PAGE_BITS;
  42     next = find_next_bit(ram_list.dirty_memory[client], end, page);
  43
  44     return next < end;
  45 }
  46
  47 static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr,
  48                                                       unsigned client)
  49 {
  50     return cpu_physical_memory_get_dirty(addr, 1, client);
  51 }
  52
  53 static inline bool cpu_physical_memory_is_clean(ram_addr_t addr)
  54 {
  55     bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA);
  56     bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE);
  57     bool migration =
  58         cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_MIGRATION);
  59     return !(vga && code && migration);
  60 }
  61
  62 static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr,
  63                                                       unsigned client)
  64 {
  65     assert(client < DIRTY_MEMORY_NUM);
  66     set_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]);
  67 }
  68
  69 static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start,
  70                                                        ram_addr_t length)
  71 {
  72     unsigned long end, page;
  73
  74     end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
  75     page = start >> TARGET_PAGE_BITS;
  76     bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION], page, end - page);
  77     bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_VGA], page, end - page);
  78     bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_CODE], page, end - page);
  79     xen_modified_memory(start, length);
  80 }
  81
  82 #if !defined(_WIN32)
  83 static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap,
  84                                                           ram_addr_t start,
  85                                                           ram_addr_t pages)
  86 {
  87     unsigned long i, j;
  88     unsigned long page_number, c;
  89     hwaddr addr;
  90     ram_addr_t ram_addr;
  91     unsigned long len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS;
  92     unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE;
  93     unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS);
  94
  95     /* start address is aligned at the start of a word? */
  96     if ((((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) &&
  97         (hpratio == 1)) {
  98         long k;
  99         long nr = BITS_TO_LONGS(pages);
 100
 101         for (k = 0; k < nr; k++) {
 102             if (bitmap[k]) {
 103                 unsigned long temp = leul_to_cpu(bitmap[k]);
 104
 105                 ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION][page + k] |= temp;
 106                 ram_list.dirty_memory[DIRTY_MEMORY_VGA][page + k] |= temp;
 107                 ram_list.dirty_memory[DIRTY_MEMORY_CODE][page + k] |= temp;
 108             }
 109         }
 110         xen_modified_memory(start, pages);
 111     } else {
 112         /*
 113          * bitmap-traveling is faster than memory-traveling (for addr...)
 114          * especially when most of the memory is not dirty.
 115          */
 116         for (i = 0; i < len; i++) {
 117             if (bitmap[i] != 0) {
 118                 c = leul_to_cpu(bitmap[i]);
 119                 do {
 120                     j = ffsl(c) - 1;
 121                     c &= ~(1ul << j);
 122                     page_number = (i * HOST_LONG_BITS + j) * hpratio;
 123                     addr = page_number * TARGET_PAGE_SIZE;
 124                     ram_addr = start + addr;
 125                     cpu_physical_memory_set_dirty_range(ram_addr,
 126                                        TARGET_PAGE_SIZE * hpratio);
 127                 } while (c != 0);
 128             }
 129         }
 130     }
 131 }
 132 #endif /* not _WIN32 */
 133
 134 static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start,
 135                                                          ram_addr_t length,
 136                                                          unsigned client)
 137 {
 138     unsigned long end, page;
 139
 140     assert(client < DIRTY_MEMORY_NUM);
 141     end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
 142     page = start >> TARGET_PAGE_BITS;
 143     bitmap_clear(ram_list.dirty_memory[client], page, end - page);
 144 }
 145
 146 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length,
 147                                      unsigned client);
 148
 149 #endif
 150 #endif