cpu: Move icount_extra field from CPU_COMMON to CPUState
[qemu.git] / 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