]>
Commit | Line | Data |
---|---|---|
794e8f30 MT |
1 | /* |
2 | * Support for RAM backed by mmaped host memory. | |
3 | * | |
4 | * Copyright (c) 2015 Red Hat, Inc. | |
5 | * | |
6 | * Authors: | |
7 | * Michael S. Tsirkin <mst@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 | */ | |
a9c94277 | 12 | |
119906af ZY |
13 | #ifdef CONFIG_LINUX |
14 | #include <linux/mman.h> | |
15 | #else /* !CONFIG_LINUX */ | |
16 | #define MAP_SYNC 0x0 | |
17 | #define MAP_SHARED_VALIDATE 0x0 | |
18 | #endif /* CONFIG_LINUX */ | |
19 | ||
aafd7584 | 20 | #include "qemu/osdep.h" |
a9c94277 | 21 | #include "qemu/mmap-alloc.h" |
4a3ecf20 | 22 | #include "qemu/host-utils.h" |
d94e0bc9 | 23 | #include "qemu/cutils.h" |
8dbe22c6 | 24 | #include "qemu/error-report.h" |
794e8f30 | 25 | |
7197fb40 MT |
26 | #define HUGETLBFS_MAGIC 0x958458f6 |
27 | ||
28 | #ifdef CONFIG_LINUX | |
29 | #include <sys/vfs.h> | |
30 | #endif | |
31 | ||
32 | size_t qemu_fd_getpagesize(int fd) | |
33 | { | |
34 | #ifdef CONFIG_LINUX | |
35 | struct statfs fs; | |
36 | int ret; | |
37 | ||
38 | if (fd != -1) { | |
39 | do { | |
40 | ret = fstatfs(fd, &fs); | |
41 | } while (ret != 0 && errno == EINTR); | |
42 | ||
43 | if (ret == 0 && fs.f_type == HUGETLBFS_MAGIC) { | |
44 | return fs.f_bsize; | |
45 | } | |
46 | } | |
57d1f6d7 PM |
47 | #ifdef __sparc__ |
48 | /* SPARC Linux needs greater alignment than the pagesize */ | |
49 | return QEMU_VMALLOC_ALIGN; | |
50 | #endif | |
7197fb40 MT |
51 | #endif |
52 | ||
8e3b0cbb | 53 | return qemu_real_host_page_size(); |
7197fb40 MT |
54 | } |
55 | ||
9c607668 AK |
56 | size_t qemu_mempath_getpagesize(const char *mem_path) |
57 | { | |
58 | #ifdef CONFIG_LINUX | |
59 | struct statfs fs; | |
60 | int ret; | |
61 | ||
0de6e2a3 DG |
62 | if (mem_path) { |
63 | do { | |
64 | ret = statfs(mem_path, &fs); | |
65 | } while (ret != 0 && errno == EINTR); | |
9c607668 | 66 | |
0de6e2a3 DG |
67 | if (ret != 0) { |
68 | fprintf(stderr, "Couldn't statfs() memory path: %s\n", | |
69 | strerror(errno)); | |
70 | exit(1); | |
71 | } | |
9c607668 | 72 | |
0de6e2a3 DG |
73 | if (fs.f_type == HUGETLBFS_MAGIC) { |
74 | /* It's hugepage, return the huge page size */ | |
75 | return fs.f_bsize; | |
76 | } | |
9c607668 | 77 | } |
57d1f6d7 PM |
78 | #ifdef __sparc__ |
79 | /* SPARC Linux needs greater alignment than the pagesize */ | |
80 | return QEMU_VMALLOC_ALIGN; | |
81 | #endif | |
9c607668 AK |
82 | #endif |
83 | ||
8e3b0cbb | 84 | return qemu_real_host_page_size(); |
9c607668 AK |
85 | } |
86 | ||
d94e0bc9 DH |
87 | #define OVERCOMMIT_MEMORY_PATH "/proc/sys/vm/overcommit_memory" |
88 | static bool map_noreserve_effective(int fd, uint32_t qemu_map_flags) | |
89 | { | |
90 | #if defined(__linux__) | |
91 | const bool readonly = qemu_map_flags & QEMU_MAP_READONLY; | |
92 | const bool shared = qemu_map_flags & QEMU_MAP_SHARED; | |
93 | gchar *content = NULL; | |
94 | const char *endptr; | |
95 | unsigned int tmp; | |
96 | ||
97 | /* | |
98 | * hugeltb accounting is different than ordinary swap reservation: | |
99 | * a) Hugetlb pages from the pool are reserved for both private and | |
100 | * shared mappings. For shared mappings, all mappers have to specify | |
101 | * MAP_NORESERVE. | |
102 | * b) MAP_NORESERVE is not affected by /proc/sys/vm/overcommit_memory. | |
103 | */ | |
8e3b0cbb | 104 | if (qemu_fd_getpagesize(fd) != qemu_real_host_page_size()) { |
d94e0bc9 DH |
105 | return true; |
106 | } | |
107 | ||
108 | /* | |
109 | * Accountable mappings in the kernel that can be affected by MAP_NORESEVE | |
110 | * are private writable mappings (see mm/mmap.c:accountable_mapping() in | |
111 | * Linux). For all shared or readonly mappings, MAP_NORESERVE is always | |
112 | * implicitly active -- no reservation; this includes shmem. The only | |
113 | * exception is shared anonymous memory, it is accounted like private | |
114 | * anonymous memory. | |
115 | */ | |
116 | if (readonly || (shared && fd >= 0)) { | |
117 | return true; | |
118 | } | |
119 | ||
120 | /* | |
121 | * MAP_NORESERVE is globally ignored for applicable !hugetlb mappings when | |
122 | * memory overcommit is set to "never". Sparse memory regions aren't really | |
123 | * possible in this system configuration. | |
124 | * | |
125 | * Bail out now instead of silently committing way more memory than | |
126 | * currently desired by the user. | |
127 | */ | |
128 | if (g_file_get_contents(OVERCOMMIT_MEMORY_PATH, &content, NULL, NULL) && | |
129 | !qemu_strtoui(content, &endptr, 0, &tmp) && | |
130 | (!endptr || *endptr == '\n')) { | |
131 | if (tmp == 2) { | |
132 | error_report("Skipping reservation of swap space is not supported:" | |
133 | " \"" OVERCOMMIT_MEMORY_PATH "\" is \"2\""); | |
134 | return false; | |
135 | } | |
136 | return true; | |
137 | } | |
138 | /* this interface has been around since Linux 2.6 */ | |
139 | error_report("Skipping reservation of swap space is not supported:" | |
140 | " Could not read: \"" OVERCOMMIT_MEMORY_PATH "\""); | |
141 | return false; | |
142 | #endif | |
143 | /* | |
144 | * E.g., FreeBSD used to define MAP_NORESERVE, never implemented it, | |
145 | * and removed it a while ago. | |
146 | */ | |
147 | error_report("Skipping reservation of swap space is not supported"); | |
148 | return false; | |
149 | } | |
150 | ||
01c26ad6 DH |
151 | /* |
152 | * Reserve a new memory region of the requested size to be used for mapping | |
153 | * from the given fd (if any). | |
154 | */ | |
155 | static void *mmap_reserve(size_t size, int fd) | |
156 | { | |
157 | int flags = MAP_PRIVATE; | |
158 | ||
159 | #if defined(__powerpc64__) && defined(__linux__) | |
160 | /* | |
161 | * On ppc64 mappings in the same segment (aka slice) must share the same | |
162 | * page size. Since we will be re-allocating part of this segment | |
163 | * from the supplied fd, we should make sure to use the same page size, to | |
164 | * this end we mmap the supplied fd. In this case, set MAP_NORESERVE to | |
165 | * avoid allocating backing store memory. | |
166 | * We do this unless we are using the system page size, in which case | |
167 | * anonymous memory is OK. | |
168 | */ | |
8e3b0cbb | 169 | if (fd == -1 || qemu_fd_getpagesize(fd) == qemu_real_host_page_size()) { |
01c26ad6 DH |
170 | fd = -1; |
171 | flags |= MAP_ANONYMOUS; | |
172 | } else { | |
173 | flags |= MAP_NORESERVE; | |
174 | } | |
175 | #else | |
176 | fd = -1; | |
177 | flags |= MAP_ANONYMOUS; | |
178 | #endif | |
179 | ||
180 | return mmap(0, size, PROT_NONE, flags, fd, 0); | |
181 | } | |
182 | ||
d01cbf82 DH |
183 | /* |
184 | * Activate memory in a reserved region from the given fd (if any), to make | |
185 | * it accessible. | |
186 | */ | |
b444f5c0 DH |
187 | static void *mmap_activate(void *ptr, size_t size, int fd, |
188 | uint32_t qemu_map_flags, off_t map_offset) | |
d01cbf82 | 189 | { |
8dbe22c6 | 190 | const bool noreserve = qemu_map_flags & QEMU_MAP_NORESERVE; |
b444f5c0 DH |
191 | const bool readonly = qemu_map_flags & QEMU_MAP_READONLY; |
192 | const bool shared = qemu_map_flags & QEMU_MAP_SHARED; | |
193 | const bool sync = qemu_map_flags & QEMU_MAP_SYNC; | |
d01cbf82 DH |
194 | const int prot = PROT_READ | (readonly ? 0 : PROT_WRITE); |
195 | int map_sync_flags = 0; | |
196 | int flags = MAP_FIXED; | |
197 | void *activated_ptr; | |
198 | ||
d94e0bc9 | 199 | if (noreserve && !map_noreserve_effective(fd, qemu_map_flags)) { |
8dbe22c6 DH |
200 | return MAP_FAILED; |
201 | } | |
202 | ||
d01cbf82 DH |
203 | flags |= fd == -1 ? MAP_ANONYMOUS : 0; |
204 | flags |= shared ? MAP_SHARED : MAP_PRIVATE; | |
d94e0bc9 | 205 | flags |= noreserve ? MAP_NORESERVE : 0; |
b444f5c0 | 206 | if (shared && sync) { |
d01cbf82 DH |
207 | map_sync_flags = MAP_SYNC | MAP_SHARED_VALIDATE; |
208 | } | |
209 | ||
210 | activated_ptr = mmap(ptr, size, prot, flags | map_sync_flags, fd, | |
211 | map_offset); | |
212 | if (activated_ptr == MAP_FAILED && map_sync_flags) { | |
213 | if (errno == ENOTSUP) { | |
214 | char *proc_link = g_strdup_printf("/proc/self/fd/%d", fd); | |
215 | char *file_name = g_malloc0(PATH_MAX); | |
216 | int len = readlink(proc_link, file_name, PATH_MAX - 1); | |
217 | ||
218 | if (len < 0) { | |
219 | len = 0; | |
220 | } | |
221 | file_name[len] = '\0'; | |
222 | fprintf(stderr, "Warning: requesting persistence across crashes " | |
223 | "for backend file %s failed. Proceeding without " | |
224 | "persistence, data might become corrupted in case of host " | |
225 | "crash.\n", file_name); | |
226 | g_free(proc_link); | |
227 | g_free(file_name); | |
cdcf766d IM |
228 | warn_report("Using non DAX backing file with 'pmem=on' option" |
229 | " is deprecated"); | |
d01cbf82 DH |
230 | } |
231 | /* | |
232 | * If mmap failed with MAP_SHARED_VALIDATE | MAP_SYNC, we will try | |
233 | * again without these flags to handle backwards compatibility. | |
234 | */ | |
235 | activated_ptr = mmap(ptr, size, prot, flags, fd, map_offset); | |
236 | } | |
237 | return activated_ptr; | |
238 | } | |
239 | ||
adad0b3a DH |
240 | static inline size_t mmap_guard_pagesize(int fd) |
241 | { | |
242 | #if defined(__powerpc64__) && defined(__linux__) | |
243 | /* Mappings in the same segment must share the same page size */ | |
244 | return qemu_fd_getpagesize(fd); | |
245 | #else | |
8e3b0cbb | 246 | return qemu_real_host_page_size(); |
adad0b3a DH |
247 | #endif |
248 | } | |
249 | ||
2ac0f162 ZY |
250 | void *qemu_ram_mmap(int fd, |
251 | size_t size, | |
252 | size_t align, | |
b444f5c0 | 253 | uint32_t qemu_map_flags, |
44a4ff31 | 254 | off_t map_offset) |
794e8f30 | 255 | { |
adad0b3a | 256 | const size_t guard_pagesize = mmap_guard_pagesize(fd); |
d01cbf82 DH |
257 | size_t offset, total; |
258 | void *ptr, *guardptr; | |
2044c3e7 | 259 | |
794e8f30 MT |
260 | /* |
261 | * Note: this always allocates at least one extra page of virtual address | |
262 | * space, even if size is already aligned. | |
263 | */ | |
2044c3e7 MOA |
264 | total = size + align; |
265 | ||
01c26ad6 | 266 | guardptr = mmap_reserve(total, fd); |
2044c3e7 | 267 | if (guardptr == MAP_FAILED) { |
9d4ec937 | 268 | return MAP_FAILED; |
794e8f30 MT |
269 | } |
270 | ||
4a3ecf20 | 271 | assert(is_power_of_2(align)); |
794e8f30 | 272 | /* Always align to host page size */ |
adad0b3a | 273 | assert(align >= guard_pagesize); |
794e8f30 | 274 | |
2044c3e7 MOA |
275 | offset = QEMU_ALIGN_UP((uintptr_t)guardptr, align) - (uintptr_t)guardptr; |
276 | ||
b444f5c0 | 277 | ptr = mmap_activate(guardptr + offset, size, fd, qemu_map_flags, |
d01cbf82 | 278 | map_offset); |
2044c3e7 MOA |
279 | if (ptr == MAP_FAILED) { |
280 | munmap(guardptr, total); | |
9d4ec937 | 281 | return MAP_FAILED; |
794e8f30 MT |
282 | } |
283 | ||
794e8f30 | 284 | if (offset > 0) { |
2044c3e7 | 285 | munmap(guardptr, offset); |
794e8f30 MT |
286 | } |
287 | ||
288 | /* | |
289 | * Leave a single PROT_NONE page allocated after the RAM block, to serve as | |
290 | * a guard page guarding against potential buffer overflows. | |
291 | */ | |
6e4c890e | 292 | total -= offset; |
adad0b3a DH |
293 | if (total > size + guard_pagesize) { |
294 | munmap(ptr + size + guard_pagesize, total - size - guard_pagesize); | |
794e8f30 MT |
295 | } |
296 | ||
2044c3e7 | 297 | return ptr; |
794e8f30 MT |
298 | } |
299 | ||
53adb9d4 | 300 | void qemu_ram_munmap(int fd, void *ptr, size_t size) |
794e8f30 MT |
301 | { |
302 | if (ptr) { | |
303 | /* Unmap both the RAM block and the guard page */ | |
adad0b3a | 304 | munmap(ptr, size + mmap_guard_pagesize(fd)); |
794e8f30 MT |
305 | } |
306 | } |