4 * Copyright Fujitsu, Corp. 2011, 2012
7 * Wen Congyang <wency@cn.fujitsu.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
14 #include "qemu/osdep.h"
15 #include "qemu/cutils.h"
17 #include "exec/hwaddr.h"
18 #include "monitor/monitor.h"
19 #include "sysemu/kvm.h"
20 #include "sysemu/dump.h"
21 #include "sysemu/memory_mapping.h"
22 #include "sysemu/runstate.h"
23 #include "sysemu/cpus.h"
24 #include "qapi/error.h"
25 #include "qapi/qapi-commands-dump.h"
26 #include "qapi/qapi-events-dump.h"
27 #include "qapi/qmp/qerror.h"
28 #include "qemu/error-report.h"
29 #include "qemu/main-loop.h"
30 #include "hw/misc/vmcoreinfo.h"
31 #include "migration/blocker.h"
39 #include <lzo/lzo1x.h>
44 #ifndef ELF_MACHINE_UNAME
45 #define ELF_MACHINE_UNAME "Unknown"
48 #define MAX_GUEST_NOTE_SIZE (1 << 20) /* 1MB should be enough */
50 static Error
*dump_migration_blocker
;
52 #define ELF_NOTE_SIZE(hdr_size, name_size, desc_size) \
53 ((DIV_ROUND_UP((hdr_size), 4) + \
54 DIV_ROUND_UP((name_size), 4) + \
55 DIV_ROUND_UP((desc_size), 4)) * 4)
57 static inline bool dump_is_64bit(DumpState
*s
)
59 return s
->dump_info
.d_class
== ELFCLASS64
;
62 static inline bool dump_has_filter(DumpState
*s
)
64 return s
->filter_area_length
> 0;
67 uint16_t cpu_to_dump16(DumpState
*s
, uint16_t val
)
69 if (s
->dump_info
.d_endian
== ELFDATA2LSB
) {
70 val
= cpu_to_le16(val
);
72 val
= cpu_to_be16(val
);
78 uint32_t cpu_to_dump32(DumpState
*s
, uint32_t val
)
80 if (s
->dump_info
.d_endian
== ELFDATA2LSB
) {
81 val
= cpu_to_le32(val
);
83 val
= cpu_to_be32(val
);
89 uint64_t cpu_to_dump64(DumpState
*s
, uint64_t val
)
91 if (s
->dump_info
.d_endian
== ELFDATA2LSB
) {
92 val
= cpu_to_le64(val
);
94 val
= cpu_to_be64(val
);
100 static int dump_cleanup(DumpState
*s
)
102 guest_phys_blocks_free(&s
->guest_phys_blocks
);
103 memory_mapping_list_free(&s
->list
);
105 g_free(s
->guest_note
);
106 g_array_unref(s
->string_table_buf
);
107 s
->guest_note
= NULL
;
110 qemu_mutex_lock_iothread();
114 qemu_mutex_unlock_iothread();
117 migrate_del_blocker(dump_migration_blocker
);
122 static int fd_write_vmcore(const void *buf
, size_t size
, void *opaque
)
124 DumpState
*s
= opaque
;
127 written_size
= qemu_write_full(s
->fd
, buf
, size
);
128 if (written_size
!= size
) {
135 static void prepare_elf64_header(DumpState
*s
, Elf64_Ehdr
*elf_header
)
138 * phnum in the elf header is 16 bit, if we have more segments we
139 * set phnum to PN_XNUM and write the real number of segments to a
142 uint16_t phnum
= MIN(s
->phdr_num
, PN_XNUM
);
144 memset(elf_header
, 0, sizeof(Elf64_Ehdr
));
145 memcpy(elf_header
, ELFMAG
, SELFMAG
);
146 elf_header
->e_ident
[EI_CLASS
] = ELFCLASS64
;
147 elf_header
->e_ident
[EI_DATA
] = s
->dump_info
.d_endian
;
148 elf_header
->e_ident
[EI_VERSION
] = EV_CURRENT
;
149 elf_header
->e_type
= cpu_to_dump16(s
, ET_CORE
);
150 elf_header
->e_machine
= cpu_to_dump16(s
, s
->dump_info
.d_machine
);
151 elf_header
->e_version
= cpu_to_dump32(s
, EV_CURRENT
);
152 elf_header
->e_ehsize
= cpu_to_dump16(s
, sizeof(elf_header
));
153 elf_header
->e_phoff
= cpu_to_dump64(s
, s
->phdr_offset
);
154 elf_header
->e_phentsize
= cpu_to_dump16(s
, sizeof(Elf64_Phdr
));
155 elf_header
->e_phnum
= cpu_to_dump16(s
, phnum
);
156 elf_header
->e_shoff
= cpu_to_dump64(s
, s
->shdr_offset
);
157 elf_header
->e_shentsize
= cpu_to_dump16(s
, sizeof(Elf64_Shdr
));
158 elf_header
->e_shnum
= cpu_to_dump16(s
, s
->shdr_num
);
159 elf_header
->e_shstrndx
= cpu_to_dump16(s
, s
->shdr_num
- 1);
162 static void prepare_elf32_header(DumpState
*s
, Elf32_Ehdr
*elf_header
)
165 * phnum in the elf header is 16 bit, if we have more segments we
166 * set phnum to PN_XNUM and write the real number of segments to a
169 uint16_t phnum
= MIN(s
->phdr_num
, PN_XNUM
);
171 memset(elf_header
, 0, sizeof(Elf32_Ehdr
));
172 memcpy(elf_header
, ELFMAG
, SELFMAG
);
173 elf_header
->e_ident
[EI_CLASS
] = ELFCLASS32
;
174 elf_header
->e_ident
[EI_DATA
] = s
->dump_info
.d_endian
;
175 elf_header
->e_ident
[EI_VERSION
] = EV_CURRENT
;
176 elf_header
->e_type
= cpu_to_dump16(s
, ET_CORE
);
177 elf_header
->e_machine
= cpu_to_dump16(s
, s
->dump_info
.d_machine
);
178 elf_header
->e_version
= cpu_to_dump32(s
, EV_CURRENT
);
179 elf_header
->e_ehsize
= cpu_to_dump16(s
, sizeof(elf_header
));
180 elf_header
->e_phoff
= cpu_to_dump32(s
, s
->phdr_offset
);
181 elf_header
->e_phentsize
= cpu_to_dump16(s
, sizeof(Elf32_Phdr
));
182 elf_header
->e_phnum
= cpu_to_dump16(s
, phnum
);
183 elf_header
->e_shoff
= cpu_to_dump32(s
, s
->shdr_offset
);
184 elf_header
->e_shentsize
= cpu_to_dump16(s
, sizeof(Elf32_Shdr
));
185 elf_header
->e_shnum
= cpu_to_dump16(s
, s
->shdr_num
);
186 elf_header
->e_shstrndx
= cpu_to_dump16(s
, s
->shdr_num
- 1);
189 static void write_elf_header(DumpState
*s
, Error
**errp
)
191 Elf32_Ehdr elf32_header
;
192 Elf64_Ehdr elf64_header
;
197 /* The NULL header and the shstrtab are always defined */
198 assert(s
->shdr_num
>= 2);
199 if (dump_is_64bit(s
)) {
200 prepare_elf64_header(s
, &elf64_header
);
201 header_size
= sizeof(elf64_header
);
202 header_ptr
= &elf64_header
;
204 prepare_elf32_header(s
, &elf32_header
);
205 header_size
= sizeof(elf32_header
);
206 header_ptr
= &elf32_header
;
209 ret
= fd_write_vmcore(header_ptr
, header_size
, s
);
211 error_setg_errno(errp
, -ret
, "dump: failed to write elf header");
215 static void write_elf64_load(DumpState
*s
, MemoryMapping
*memory_mapping
,
216 int phdr_index
, hwaddr offset
,
217 hwaddr filesz
, Error
**errp
)
222 memset(&phdr
, 0, sizeof(Elf64_Phdr
));
223 phdr
.p_type
= cpu_to_dump32(s
, PT_LOAD
);
224 phdr
.p_offset
= cpu_to_dump64(s
, offset
);
225 phdr
.p_paddr
= cpu_to_dump64(s
, memory_mapping
->phys_addr
);
226 phdr
.p_filesz
= cpu_to_dump64(s
, filesz
);
227 phdr
.p_memsz
= cpu_to_dump64(s
, memory_mapping
->length
);
228 phdr
.p_vaddr
= cpu_to_dump64(s
, memory_mapping
->virt_addr
) ?: phdr
.p_paddr
;
230 assert(memory_mapping
->length
>= filesz
);
232 ret
= fd_write_vmcore(&phdr
, sizeof(Elf64_Phdr
), s
);
234 error_setg_errno(errp
, -ret
,
235 "dump: failed to write program header table");
239 static void write_elf32_load(DumpState
*s
, MemoryMapping
*memory_mapping
,
240 int phdr_index
, hwaddr offset
,
241 hwaddr filesz
, Error
**errp
)
246 memset(&phdr
, 0, sizeof(Elf32_Phdr
));
247 phdr
.p_type
= cpu_to_dump32(s
, PT_LOAD
);
248 phdr
.p_offset
= cpu_to_dump32(s
, offset
);
249 phdr
.p_paddr
= cpu_to_dump32(s
, memory_mapping
->phys_addr
);
250 phdr
.p_filesz
= cpu_to_dump32(s
, filesz
);
251 phdr
.p_memsz
= cpu_to_dump32(s
, memory_mapping
->length
);
253 cpu_to_dump32(s
, memory_mapping
->virt_addr
) ?: phdr
.p_paddr
;
255 assert(memory_mapping
->length
>= filesz
);
257 ret
= fd_write_vmcore(&phdr
, sizeof(Elf32_Phdr
), s
);
259 error_setg_errno(errp
, -ret
,
260 "dump: failed to write program header table");
264 static void prepare_elf64_phdr_note(DumpState
*s
, Elf64_Phdr
*phdr
)
266 memset(phdr
, 0, sizeof(*phdr
));
267 phdr
->p_type
= cpu_to_dump32(s
, PT_NOTE
);
268 phdr
->p_offset
= cpu_to_dump64(s
, s
->note_offset
);
270 phdr
->p_filesz
= cpu_to_dump64(s
, s
->note_size
);
271 phdr
->p_memsz
= cpu_to_dump64(s
, s
->note_size
);
275 static inline int cpu_index(CPUState
*cpu
)
277 return cpu
->cpu_index
+ 1;
280 static void write_guest_note(WriteCoreDumpFunction f
, DumpState
*s
,
286 ret
= f(s
->guest_note
, s
->guest_note_size
, s
);
288 error_setg(errp
, "dump: failed to write guest note");
293 static void write_elf64_notes(WriteCoreDumpFunction f
, DumpState
*s
,
302 ret
= cpu_write_elf64_note(f
, cpu
, id
, s
);
304 error_setg(errp
, "dump: failed to write elf notes");
310 ret
= cpu_write_elf64_qemunote(f
, cpu
, s
);
312 error_setg(errp
, "dump: failed to write CPU status");
317 write_guest_note(f
, s
, errp
);
320 static void prepare_elf32_phdr_note(DumpState
*s
, Elf32_Phdr
*phdr
)
322 memset(phdr
, 0, sizeof(*phdr
));
323 phdr
->p_type
= cpu_to_dump32(s
, PT_NOTE
);
324 phdr
->p_offset
= cpu_to_dump32(s
, s
->note_offset
);
326 phdr
->p_filesz
= cpu_to_dump32(s
, s
->note_size
);
327 phdr
->p_memsz
= cpu_to_dump32(s
, s
->note_size
);
331 static void write_elf32_notes(WriteCoreDumpFunction f
, DumpState
*s
,
340 ret
= cpu_write_elf32_note(f
, cpu
, id
, s
);
342 error_setg(errp
, "dump: failed to write elf notes");
348 ret
= cpu_write_elf32_qemunote(f
, cpu
, s
);
350 error_setg(errp
, "dump: failed to write CPU status");
355 write_guest_note(f
, s
, errp
);
358 static void write_elf_phdr_note(DumpState
*s
, Error
**errp
)
367 if (dump_is_64bit(s
)) {
368 prepare_elf64_phdr_note(s
, &phdr64
);
369 size
= sizeof(phdr64
);
372 prepare_elf32_phdr_note(s
, &phdr32
);
373 size
= sizeof(phdr32
);
377 ret
= fd_write_vmcore(phdr
, size
, s
);
379 error_setg_errno(errp
, -ret
,
380 "dump: failed to write program header table");
384 static void prepare_elf_section_hdr_zero(DumpState
*s
)
386 if (dump_is_64bit(s
)) {
387 Elf64_Shdr
*shdr64
= s
->elf_section_hdrs
;
389 shdr64
->sh_info
= cpu_to_dump32(s
, s
->phdr_num
);
391 Elf32_Shdr
*shdr32
= s
->elf_section_hdrs
;
393 shdr32
->sh_info
= cpu_to_dump32(s
, s
->phdr_num
);
397 static void prepare_elf_section_hdr_string(DumpState
*s
, void *buff
)
399 uint64_t index
= s
->string_table_buf
->len
;
400 const char strtab
[] = ".shstrtab";
401 Elf32_Shdr shdr32
= {};
402 Elf64_Shdr shdr64
= {};
406 g_array_append_vals(s
->string_table_buf
, strtab
, sizeof(strtab
));
407 if (dump_is_64bit(s
)) {
408 shdr_size
= sizeof(Elf64_Shdr
);
409 shdr64
.sh_type
= SHT_STRTAB
;
410 shdr64
.sh_offset
= s
->section_offset
+ s
->elf_section_data_size
;
411 shdr64
.sh_name
= index
;
412 shdr64
.sh_size
= s
->string_table_buf
->len
;
415 shdr_size
= sizeof(Elf32_Shdr
);
416 shdr32
.sh_type
= SHT_STRTAB
;
417 shdr32
.sh_offset
= s
->section_offset
+ s
->elf_section_data_size
;
418 shdr32
.sh_name
= index
;
419 shdr32
.sh_size
= s
->string_table_buf
->len
;
422 memcpy(buff
, shdr
, shdr_size
);
425 static bool prepare_elf_section_hdrs(DumpState
*s
, Error
**errp
)
427 size_t len
, sizeof_shdr
;
433 * - Arch section hdrs
436 sizeof_shdr
= dump_is_64bit(s
) ? sizeof(Elf64_Shdr
) : sizeof(Elf32_Shdr
);
437 len
= sizeof_shdr
* s
->shdr_num
;
438 s
->elf_section_hdrs
= g_malloc0(len
);
439 buff_hdr
= s
->elf_section_hdrs
;
442 * The first section header is ALWAYS a special initial section
445 * The header should be 0 with one exception being that if
446 * phdr_num is PN_XNUM then the sh_info field contains the real
447 * number of segment entries.
449 * As we zero allocate the buffer we will only need to modify
450 * sh_info for the PN_XNUM case.
452 if (s
->phdr_num
>= PN_XNUM
) {
453 prepare_elf_section_hdr_zero(s
);
455 buff_hdr
+= sizeof_shdr
;
457 /* Add architecture defined section headers */
458 if (s
->dump_info
.arch_sections_write_hdr_fn
459 && s
->shdr_num
> 2) {
460 buff_hdr
+= s
->dump_info
.arch_sections_write_hdr_fn(s
, buff_hdr
);
462 if (s
->shdr_num
>= SHN_LORESERVE
) {
463 error_setg_errno(errp
, EINVAL
,
464 "dump: too many architecture defined sections");
470 * String table is the last section since strings are added via
471 * arch_sections_write_hdr().
473 prepare_elf_section_hdr_string(s
, buff_hdr
);
477 static void write_elf_section_headers(DumpState
*s
, Error
**errp
)
479 size_t sizeof_shdr
= dump_is_64bit(s
) ? sizeof(Elf64_Shdr
) : sizeof(Elf32_Shdr
);
482 if (!prepare_elf_section_hdrs(s
, errp
)) {
486 ret
= fd_write_vmcore(s
->elf_section_hdrs
, s
->shdr_num
* sizeof_shdr
, s
);
488 error_setg_errno(errp
, -ret
, "dump: failed to write section headers");
491 g_free(s
->elf_section_hdrs
);
494 static void write_elf_sections(DumpState
*s
, Error
**errp
)
498 if (s
->elf_section_data_size
) {
499 /* Write architecture section data */
500 ret
= fd_write_vmcore(s
->elf_section_data
,
501 s
->elf_section_data_size
, s
);
503 error_setg_errno(errp
, -ret
,
504 "dump: failed to write architecture section data");
509 /* Write string table */
510 ret
= fd_write_vmcore(s
->string_table_buf
->data
,
511 s
->string_table_buf
->len
, s
);
513 error_setg_errno(errp
, -ret
, "dump: failed to write string table data");
517 static void write_data(DumpState
*s
, void *buf
, int length
, Error
**errp
)
521 ret
= fd_write_vmcore(buf
, length
, s
);
523 error_setg_errno(errp
, -ret
, "dump: failed to save memory");
525 s
->written_size
+= length
;
529 /* write the memory to vmcore. 1 page per I/O. */
530 static void write_memory(DumpState
*s
, GuestPhysBlock
*block
, ram_addr_t start
,
531 int64_t size
, Error
**errp
)
536 for (i
= 0; i
< size
/ s
->dump_info
.page_size
; i
++) {
537 write_data(s
, block
->host_addr
+ start
+ i
* s
->dump_info
.page_size
,
538 s
->dump_info
.page_size
, errp
);
544 if ((size
% s
->dump_info
.page_size
) != 0) {
545 write_data(s
, block
->host_addr
+ start
+ i
* s
->dump_info
.page_size
,
546 size
% s
->dump_info
.page_size
, errp
);
553 /* get the memory's offset and size in the vmcore */
554 static void get_offset_range(hwaddr phys_addr
,
555 ram_addr_t mapping_length
,
560 GuestPhysBlock
*block
;
561 hwaddr offset
= s
->memory_offset
;
562 int64_t size_in_block
, start
;
564 /* When the memory is not stored into vmcore, offset will be -1 */
568 if (dump_has_filter(s
)) {
569 if (phys_addr
< s
->filter_area_begin
||
570 phys_addr
>= s
->filter_area_begin
+ s
->filter_area_length
) {
575 QTAILQ_FOREACH(block
, &s
->guest_phys_blocks
.head
, next
) {
576 if (dump_has_filter(s
)) {
577 if (block
->target_start
>= s
->filter_area_begin
+ s
->filter_area_length
||
578 block
->target_end
<= s
->filter_area_begin
) {
579 /* This block is out of the range */
583 if (s
->filter_area_begin
<= block
->target_start
) {
584 start
= block
->target_start
;
586 start
= s
->filter_area_begin
;
589 size_in_block
= block
->target_end
- start
;
590 if (s
->filter_area_begin
+ s
->filter_area_length
< block
->target_end
) {
591 size_in_block
-= block
->target_end
- (s
->filter_area_begin
+ s
->filter_area_length
);
594 start
= block
->target_start
;
595 size_in_block
= block
->target_end
- block
->target_start
;
598 if (phys_addr
>= start
&& phys_addr
< start
+ size_in_block
) {
599 *p_offset
= phys_addr
- start
+ offset
;
601 /* The offset range mapped from the vmcore file must not spill over
602 * the GuestPhysBlock, clamp it. The rest of the mapping will be
603 * zero-filled in memory at load time; see
604 * <http://refspecs.linuxbase.org/elf/gabi4+/ch5.pheader.html>.
606 *p_filesz
= phys_addr
+ mapping_length
<= start
+ size_in_block
?
608 size_in_block
- (phys_addr
- start
);
612 offset
+= size_in_block
;
616 static void write_elf_phdr_loads(DumpState
*s
, Error
**errp
)
619 hwaddr offset
, filesz
;
620 MemoryMapping
*memory_mapping
;
621 uint32_t phdr_index
= 1;
623 QTAILQ_FOREACH(memory_mapping
, &s
->list
.head
, next
) {
624 get_offset_range(memory_mapping
->phys_addr
,
625 memory_mapping
->length
,
626 s
, &offset
, &filesz
);
627 if (dump_is_64bit(s
)) {
628 write_elf64_load(s
, memory_mapping
, phdr_index
++, offset
,
631 write_elf32_load(s
, memory_mapping
, phdr_index
++, offset
,
639 if (phdr_index
>= s
->phdr_num
) {
645 static void write_elf_notes(DumpState
*s
, Error
**errp
)
647 if (dump_is_64bit(s
)) {
648 write_elf64_notes(fd_write_vmcore
, s
, errp
);
650 write_elf32_notes(fd_write_vmcore
, s
, errp
);
654 /* write elf header, PT_NOTE and elf note to vmcore. */
655 static void dump_begin(DumpState
*s
, Error
**errp
)
660 * the vmcore's format is:
679 * we only know where the memory is saved after we write elf note into
683 /* write elf header to vmcore */
684 write_elf_header(s
, errp
);
689 /* write section headers to vmcore */
690 write_elf_section_headers(s
, errp
);
695 /* write PT_NOTE to vmcore */
696 write_elf_phdr_note(s
, errp
);
701 /* write all PT_LOADs to vmcore */
702 write_elf_phdr_loads(s
, errp
);
707 /* write notes to vmcore */
708 write_elf_notes(s
, errp
);
711 int64_t dump_filtered_memblock_size(GuestPhysBlock
*block
,
712 int64_t filter_area_start
,
713 int64_t filter_area_length
)
715 int64_t size
, left
, right
;
717 /* No filter, return full size */
718 if (!filter_area_length
) {
719 return block
->target_end
- block
->target_start
;
722 /* calculate the overlapped region. */
723 left
= MAX(filter_area_start
, block
->target_start
);
724 right
= MIN(filter_area_start
+ filter_area_length
, block
->target_end
);
726 size
= size
> 0 ? size
: 0;
731 int64_t dump_filtered_memblock_start(GuestPhysBlock
*block
,
732 int64_t filter_area_start
,
733 int64_t filter_area_length
)
735 if (filter_area_length
) {
736 /* return -1 if the block is not within filter area */
737 if (block
->target_start
>= filter_area_start
+ filter_area_length
||
738 block
->target_end
<= filter_area_start
) {
742 if (filter_area_start
> block
->target_start
) {
743 return filter_area_start
- block
->target_start
;
750 /* write all memory to vmcore */
751 static void dump_iterate(DumpState
*s
, Error
**errp
)
754 GuestPhysBlock
*block
;
755 int64_t memblock_size
, memblock_start
;
757 QTAILQ_FOREACH(block
, &s
->guest_phys_blocks
.head
, next
) {
758 memblock_start
= dump_filtered_memblock_start(block
, s
->filter_area_begin
, s
->filter_area_length
);
759 if (memblock_start
== -1) {
763 memblock_size
= dump_filtered_memblock_size(block
, s
->filter_area_begin
, s
->filter_area_length
);
765 /* Write the memory to file */
766 write_memory(s
, block
, memblock_start
, memblock_size
, errp
);
773 static void dump_end(DumpState
*s
, Error
**errp
)
778 if (s
->elf_section_data_size
) {
779 s
->elf_section_data
= g_malloc0(s
->elf_section_data_size
);
782 /* Adds the architecture defined section data to s->elf_section_data */
783 if (s
->dump_info
.arch_sections_write_fn
&&
784 s
->elf_section_data_size
) {
785 rc
= s
->dump_info
.arch_sections_write_fn(s
, s
->elf_section_data
);
787 error_setg_errno(errp
, rc
,
788 "dump: failed to get arch section data");
789 g_free(s
->elf_section_data
);
794 /* write sections to vmcore */
795 write_elf_sections(s
, errp
);
798 static void create_vmcore(DumpState
*s
, Error
**errp
)
807 /* Iterate over memory and dump it to file */
808 dump_iterate(s
, errp
);
813 /* Write the section data */
817 static int write_start_flat_header(int fd
)
819 MakedumpfileHeader
*mh
;
822 QEMU_BUILD_BUG_ON(sizeof *mh
> MAX_SIZE_MDF_HEADER
);
823 mh
= g_malloc0(MAX_SIZE_MDF_HEADER
);
825 memcpy(mh
->signature
, MAKEDUMPFILE_SIGNATURE
,
826 MIN(sizeof mh
->signature
, sizeof MAKEDUMPFILE_SIGNATURE
));
828 mh
->type
= cpu_to_be64(TYPE_FLAT_HEADER
);
829 mh
->version
= cpu_to_be64(VERSION_FLAT_HEADER
);
832 written_size
= qemu_write_full(fd
, mh
, MAX_SIZE_MDF_HEADER
);
833 if (written_size
!= MAX_SIZE_MDF_HEADER
) {
841 static int write_end_flat_header(int fd
)
843 MakedumpfileDataHeader mdh
;
845 mdh
.offset
= END_FLAG_FLAT_HEADER
;
846 mdh
.buf_size
= END_FLAG_FLAT_HEADER
;
849 written_size
= qemu_write_full(fd
, &mdh
, sizeof(mdh
));
850 if (written_size
!= sizeof(mdh
)) {
857 static int write_buffer(int fd
, off_t offset
, const void *buf
, size_t size
)
860 MakedumpfileDataHeader mdh
;
862 mdh
.offset
= cpu_to_be64(offset
);
863 mdh
.buf_size
= cpu_to_be64(size
);
865 written_size
= qemu_write_full(fd
, &mdh
, sizeof(mdh
));
866 if (written_size
!= sizeof(mdh
)) {
870 written_size
= qemu_write_full(fd
, buf
, size
);
871 if (written_size
!= size
) {
878 static int buf_write_note(const void *buf
, size_t size
, void *opaque
)
880 DumpState
*s
= opaque
;
882 /* note_buf is not enough */
883 if (s
->note_buf_offset
+ size
> s
->note_size
) {
887 memcpy(s
->note_buf
+ s
->note_buf_offset
, buf
, size
);
889 s
->note_buf_offset
+= size
;
895 * This function retrieves various sizes from an elf header.
897 * @note has to be a valid ELF note. The return sizes are unmodified
898 * (not padded or rounded up to be multiple of 4).
900 static void get_note_sizes(DumpState
*s
, const void *note
,
901 uint64_t *note_head_size
,
905 uint64_t note_head_sz
;
909 if (dump_is_64bit(s
)) {
910 const Elf64_Nhdr
*hdr
= note
;
911 note_head_sz
= sizeof(Elf64_Nhdr
);
912 name_sz
= tswap64(hdr
->n_namesz
);
913 desc_sz
= tswap64(hdr
->n_descsz
);
915 const Elf32_Nhdr
*hdr
= note
;
916 note_head_sz
= sizeof(Elf32_Nhdr
);
917 name_sz
= tswap32(hdr
->n_namesz
);
918 desc_sz
= tswap32(hdr
->n_descsz
);
921 if (note_head_size
) {
922 *note_head_size
= note_head_sz
;
925 *name_size
= name_sz
;
928 *desc_size
= desc_sz
;
932 static bool note_name_equal(DumpState
*s
,
933 const uint8_t *note
, const char *name
)
935 int len
= strlen(name
) + 1;
936 uint64_t head_size
, name_size
;
938 get_note_sizes(s
, note
, &head_size
, &name_size
, NULL
);
939 head_size
= ROUND_UP(head_size
, 4);
941 return name_size
== len
&& memcmp(note
+ head_size
, name
, len
) == 0;
944 /* write common header, sub header and elf note to vmcore */
945 static void create_header32(DumpState
*s
, Error
**errp
)
948 DiskDumpHeader32
*dh
= NULL
;
949 KdumpSubHeader32
*kh
= NULL
;
952 uint32_t sub_hdr_size
;
953 uint32_t bitmap_blocks
;
955 uint64_t offset_note
;
957 /* write common header, the version of kdump-compressed format is 6th */
958 size
= sizeof(DiskDumpHeader32
);
959 dh
= g_malloc0(size
);
961 memcpy(dh
->signature
, KDUMP_SIGNATURE
, SIG_LEN
);
962 dh
->header_version
= cpu_to_dump32(s
, 6);
963 block_size
= s
->dump_info
.page_size
;
964 dh
->block_size
= cpu_to_dump32(s
, block_size
);
965 sub_hdr_size
= sizeof(struct KdumpSubHeader32
) + s
->note_size
;
966 sub_hdr_size
= DIV_ROUND_UP(sub_hdr_size
, block_size
);
967 dh
->sub_hdr_size
= cpu_to_dump32(s
, sub_hdr_size
);
968 /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
969 dh
->max_mapnr
= cpu_to_dump32(s
, MIN(s
->max_mapnr
, UINT_MAX
));
970 dh
->nr_cpus
= cpu_to_dump32(s
, s
->nr_cpus
);
971 bitmap_blocks
= DIV_ROUND_UP(s
->len_dump_bitmap
, block_size
) * 2;
972 dh
->bitmap_blocks
= cpu_to_dump32(s
, bitmap_blocks
);
973 strncpy(dh
->utsname
.machine
, ELF_MACHINE_UNAME
, sizeof(dh
->utsname
.machine
));
975 if (s
->flag_compress
& DUMP_DH_COMPRESSED_ZLIB
) {
976 status
|= DUMP_DH_COMPRESSED_ZLIB
;
979 if (s
->flag_compress
& DUMP_DH_COMPRESSED_LZO
) {
980 status
|= DUMP_DH_COMPRESSED_LZO
;
984 if (s
->flag_compress
& DUMP_DH_COMPRESSED_SNAPPY
) {
985 status
|= DUMP_DH_COMPRESSED_SNAPPY
;
988 dh
->status
= cpu_to_dump32(s
, status
);
990 if (write_buffer(s
->fd
, 0, dh
, size
) < 0) {
991 error_setg(errp
, "dump: failed to write disk dump header");
995 /* write sub header */
996 size
= sizeof(KdumpSubHeader32
);
997 kh
= g_malloc0(size
);
999 /* 64bit max_mapnr_64 */
1000 kh
->max_mapnr_64
= cpu_to_dump64(s
, s
->max_mapnr
);
1001 kh
->phys_base
= cpu_to_dump32(s
, s
->dump_info
.phys_base
);
1002 kh
->dump_level
= cpu_to_dump32(s
, DUMP_LEVEL
);
1004 offset_note
= DISKDUMP_HEADER_BLOCKS
* block_size
+ size
;
1005 if (s
->guest_note
&&
1006 note_name_equal(s
, s
->guest_note
, "VMCOREINFO")) {
1007 uint64_t hsize
, name_size
, size_vmcoreinfo_desc
, offset_vmcoreinfo
;
1009 get_note_sizes(s
, s
->guest_note
,
1010 &hsize
, &name_size
, &size_vmcoreinfo_desc
);
1011 offset_vmcoreinfo
= offset_note
+ s
->note_size
- s
->guest_note_size
+
1012 (DIV_ROUND_UP(hsize
, 4) + DIV_ROUND_UP(name_size
, 4)) * 4;
1013 kh
->offset_vmcoreinfo
= cpu_to_dump64(s
, offset_vmcoreinfo
);
1014 kh
->size_vmcoreinfo
= cpu_to_dump32(s
, size_vmcoreinfo_desc
);
1017 kh
->offset_note
= cpu_to_dump64(s
, offset_note
);
1018 kh
->note_size
= cpu_to_dump32(s
, s
->note_size
);
1020 if (write_buffer(s
->fd
, DISKDUMP_HEADER_BLOCKS
*
1021 block_size
, kh
, size
) < 0) {
1022 error_setg(errp
, "dump: failed to write kdump sub header");
1027 s
->note_buf
= g_malloc0(s
->note_size
);
1028 s
->note_buf_offset
= 0;
1030 /* use s->note_buf to store notes temporarily */
1031 write_elf32_notes(buf_write_note
, s
, errp
);
1035 if (write_buffer(s
->fd
, offset_note
, s
->note_buf
,
1036 s
->note_size
) < 0) {
1037 error_setg(errp
, "dump: failed to write notes");
1041 /* get offset of dump_bitmap */
1042 s
->offset_dump_bitmap
= (DISKDUMP_HEADER_BLOCKS
+ sub_hdr_size
) *
1045 /* get offset of page */
1046 s
->offset_page
= (DISKDUMP_HEADER_BLOCKS
+ sub_hdr_size
+ bitmap_blocks
) *
1052 g_free(s
->note_buf
);
1055 /* write common header, sub header and elf note to vmcore */
1056 static void create_header64(DumpState
*s
, Error
**errp
)
1059 DiskDumpHeader64
*dh
= NULL
;
1060 KdumpSubHeader64
*kh
= NULL
;
1062 uint32_t block_size
;
1063 uint32_t sub_hdr_size
;
1064 uint32_t bitmap_blocks
;
1065 uint32_t status
= 0;
1066 uint64_t offset_note
;
1068 /* write common header, the version of kdump-compressed format is 6th */
1069 size
= sizeof(DiskDumpHeader64
);
1070 dh
= g_malloc0(size
);
1072 memcpy(dh
->signature
, KDUMP_SIGNATURE
, SIG_LEN
);
1073 dh
->header_version
= cpu_to_dump32(s
, 6);
1074 block_size
= s
->dump_info
.page_size
;
1075 dh
->block_size
= cpu_to_dump32(s
, block_size
);
1076 sub_hdr_size
= sizeof(struct KdumpSubHeader64
) + s
->note_size
;
1077 sub_hdr_size
= DIV_ROUND_UP(sub_hdr_size
, block_size
);
1078 dh
->sub_hdr_size
= cpu_to_dump32(s
, sub_hdr_size
);
1079 /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
1080 dh
->max_mapnr
= cpu_to_dump32(s
, MIN(s
->max_mapnr
, UINT_MAX
));
1081 dh
->nr_cpus
= cpu_to_dump32(s
, s
->nr_cpus
);
1082 bitmap_blocks
= DIV_ROUND_UP(s
->len_dump_bitmap
, block_size
) * 2;
1083 dh
->bitmap_blocks
= cpu_to_dump32(s
, bitmap_blocks
);
1084 strncpy(dh
->utsname
.machine
, ELF_MACHINE_UNAME
, sizeof(dh
->utsname
.machine
));
1086 if (s
->flag_compress
& DUMP_DH_COMPRESSED_ZLIB
) {
1087 status
|= DUMP_DH_COMPRESSED_ZLIB
;
1090 if (s
->flag_compress
& DUMP_DH_COMPRESSED_LZO
) {
1091 status
|= DUMP_DH_COMPRESSED_LZO
;
1094 #ifdef CONFIG_SNAPPY
1095 if (s
->flag_compress
& DUMP_DH_COMPRESSED_SNAPPY
) {
1096 status
|= DUMP_DH_COMPRESSED_SNAPPY
;
1099 dh
->status
= cpu_to_dump32(s
, status
);
1101 if (write_buffer(s
->fd
, 0, dh
, size
) < 0) {
1102 error_setg(errp
, "dump: failed to write disk dump header");
1106 /* write sub header */
1107 size
= sizeof(KdumpSubHeader64
);
1108 kh
= g_malloc0(size
);
1110 /* 64bit max_mapnr_64 */
1111 kh
->max_mapnr_64
= cpu_to_dump64(s
, s
->max_mapnr
);
1112 kh
->phys_base
= cpu_to_dump64(s
, s
->dump_info
.phys_base
);
1113 kh
->dump_level
= cpu_to_dump32(s
, DUMP_LEVEL
);
1115 offset_note
= DISKDUMP_HEADER_BLOCKS
* block_size
+ size
;
1116 if (s
->guest_note
&&
1117 note_name_equal(s
, s
->guest_note
, "VMCOREINFO")) {
1118 uint64_t hsize
, name_size
, size_vmcoreinfo_desc
, offset_vmcoreinfo
;
1120 get_note_sizes(s
, s
->guest_note
,
1121 &hsize
, &name_size
, &size_vmcoreinfo_desc
);
1122 offset_vmcoreinfo
= offset_note
+ s
->note_size
- s
->guest_note_size
+
1123 (DIV_ROUND_UP(hsize
, 4) + DIV_ROUND_UP(name_size
, 4)) * 4;
1124 kh
->offset_vmcoreinfo
= cpu_to_dump64(s
, offset_vmcoreinfo
);
1125 kh
->size_vmcoreinfo
= cpu_to_dump64(s
, size_vmcoreinfo_desc
);
1128 kh
->offset_note
= cpu_to_dump64(s
, offset_note
);
1129 kh
->note_size
= cpu_to_dump64(s
, s
->note_size
);
1131 if (write_buffer(s
->fd
, DISKDUMP_HEADER_BLOCKS
*
1132 block_size
, kh
, size
) < 0) {
1133 error_setg(errp
, "dump: failed to write kdump sub header");
1138 s
->note_buf
= g_malloc0(s
->note_size
);
1139 s
->note_buf_offset
= 0;
1141 /* use s->note_buf to store notes temporarily */
1142 write_elf64_notes(buf_write_note
, s
, errp
);
1147 if (write_buffer(s
->fd
, offset_note
, s
->note_buf
,
1148 s
->note_size
) < 0) {
1149 error_setg(errp
, "dump: failed to write notes");
1153 /* get offset of dump_bitmap */
1154 s
->offset_dump_bitmap
= (DISKDUMP_HEADER_BLOCKS
+ sub_hdr_size
) *
1157 /* get offset of page */
1158 s
->offset_page
= (DISKDUMP_HEADER_BLOCKS
+ sub_hdr_size
+ bitmap_blocks
) *
1164 g_free(s
->note_buf
);
1167 static void write_dump_header(DumpState
*s
, Error
**errp
)
1169 if (dump_is_64bit(s
)) {
1170 create_header64(s
, errp
);
1172 create_header32(s
, errp
);
1176 static size_t dump_bitmap_get_bufsize(DumpState
*s
)
1178 return s
->dump_info
.page_size
;
1182 * set dump_bitmap sequencely. the bit before last_pfn is not allowed to be
1183 * rewritten, so if need to set the first bit, set last_pfn and pfn to 0.
1184 * set_dump_bitmap will always leave the recently set bit un-sync. And setting
1185 * (last bit + sizeof(buf) * 8) to 0 will do flushing the content in buf into
1186 * vmcore, ie. synchronizing un-sync bit into vmcore.
1188 static int set_dump_bitmap(uint64_t last_pfn
, uint64_t pfn
, bool value
,
1189 uint8_t *buf
, DumpState
*s
)
1191 off_t old_offset
, new_offset
;
1192 off_t offset_bitmap1
, offset_bitmap2
;
1194 size_t bitmap_bufsize
= dump_bitmap_get_bufsize(s
);
1195 size_t bits_per_buf
= bitmap_bufsize
* CHAR_BIT
;
1197 /* should not set the previous place */
1198 assert(last_pfn
<= pfn
);
1201 * if the bit needed to be set is not cached in buf, flush the data in buf
1202 * to vmcore firstly.
1203 * making new_offset be bigger than old_offset can also sync remained data
1206 old_offset
= bitmap_bufsize
* (last_pfn
/ bits_per_buf
);
1207 new_offset
= bitmap_bufsize
* (pfn
/ bits_per_buf
);
1209 while (old_offset
< new_offset
) {
1210 /* calculate the offset and write dump_bitmap */
1211 offset_bitmap1
= s
->offset_dump_bitmap
+ old_offset
;
1212 if (write_buffer(s
->fd
, offset_bitmap1
, buf
,
1213 bitmap_bufsize
) < 0) {
1217 /* dump level 1 is chosen, so 1st and 2nd bitmap are same */
1218 offset_bitmap2
= s
->offset_dump_bitmap
+ s
->len_dump_bitmap
+
1220 if (write_buffer(s
->fd
, offset_bitmap2
, buf
,
1221 bitmap_bufsize
) < 0) {
1225 memset(buf
, 0, bitmap_bufsize
);
1226 old_offset
+= bitmap_bufsize
;
1229 /* get the exact place of the bit in the buf, and set it */
1230 byte
= (pfn
% bits_per_buf
) / CHAR_BIT
;
1231 bit
= (pfn
% bits_per_buf
) % CHAR_BIT
;
1233 buf
[byte
] |= 1u << bit
;
1235 buf
[byte
] &= ~(1u << bit
);
1241 static uint64_t dump_paddr_to_pfn(DumpState
*s
, uint64_t addr
)
1243 int target_page_shift
= ctz32(s
->dump_info
.page_size
);
1245 return (addr
>> target_page_shift
) - ARCH_PFN_OFFSET
;
1248 static uint64_t dump_pfn_to_paddr(DumpState
*s
, uint64_t pfn
)
1250 int target_page_shift
= ctz32(s
->dump_info
.page_size
);
1252 return (pfn
+ ARCH_PFN_OFFSET
) << target_page_shift
;
1256 * Return the page frame number and the page content in *bufptr. bufptr can be
1257 * NULL. If not NULL, *bufptr must contains a target page size of pre-allocated
1258 * memory. This is not necessarily the memory returned.
1260 static bool get_next_page(GuestPhysBlock
**blockptr
, uint64_t *pfnptr
,
1261 uint8_t **bufptr
, DumpState
*s
)
1263 GuestPhysBlock
*block
= *blockptr
;
1264 uint32_t page_size
= s
->dump_info
.page_size
;
1265 uint8_t *buf
= NULL
, *hbuf
;
1268 /* block == NULL means the start of the iteration */
1270 block
= QTAILQ_FIRST(&s
->guest_phys_blocks
.head
);
1272 addr
= block
->target_start
;
1273 *pfnptr
= dump_paddr_to_pfn(s
, addr
);
1276 addr
= dump_pfn_to_paddr(s
, *pfnptr
);
1278 assert(block
!= NULL
);
1281 if (addr
>= block
->target_start
&& addr
< block
->target_end
) {
1282 size_t n
= MIN(block
->target_end
- addr
, page_size
- addr
% page_size
);
1283 hbuf
= block
->host_addr
+ (addr
- block
->target_start
);
1285 if (n
== page_size
) {
1286 /* this is a whole target page, go for it */
1287 assert(addr
% page_size
== 0);
1290 } else if (bufptr
) {
1293 memset(buf
, 0, page_size
);
1299 memcpy(buf
+ addr
% page_size
, hbuf
, n
);
1301 if (addr
% page_size
== 0) {
1302 /* we filled up the page */
1306 /* the next page is in the next block */
1307 *blockptr
= block
= QTAILQ_NEXT(block
, next
);
1312 addr
= block
->target_start
;
1313 /* are we still in the same page? */
1314 if (dump_paddr_to_pfn(s
, addr
) != *pfnptr
) {
1316 /* no, but we already filled something earlier, return it */
1319 /* else continue from there */
1320 *pfnptr
= dump_paddr_to_pfn(s
, addr
);
1333 static void write_dump_bitmap(DumpState
*s
, Error
**errp
)
1336 uint64_t last_pfn
, pfn
;
1337 void *dump_bitmap_buf
;
1338 size_t num_dumpable
;
1339 GuestPhysBlock
*block_iter
= NULL
;
1340 size_t bitmap_bufsize
= dump_bitmap_get_bufsize(s
);
1341 size_t bits_per_buf
= bitmap_bufsize
* CHAR_BIT
;
1343 /* dump_bitmap_buf is used to store dump_bitmap temporarily */
1344 dump_bitmap_buf
= g_malloc0(bitmap_bufsize
);
1350 * exam memory page by page, and set the bit in dump_bitmap corresponded
1351 * to the existing page.
1353 while (get_next_page(&block_iter
, &pfn
, NULL
, s
)) {
1354 ret
= set_dump_bitmap(last_pfn
, pfn
, true, dump_bitmap_buf
, s
);
1356 error_setg(errp
, "dump: failed to set dump_bitmap");
1365 * set_dump_bitmap will always leave the recently set bit un-sync. Here we
1366 * set the remaining bits from last_pfn to the end of the bitmap buffer to
1367 * 0. With those set, the un-sync bit will be synchronized into the vmcore.
1369 if (num_dumpable
> 0) {
1370 ret
= set_dump_bitmap(last_pfn
, last_pfn
+ bits_per_buf
, false,
1371 dump_bitmap_buf
, s
);
1373 error_setg(errp
, "dump: failed to sync dump_bitmap");
1378 /* number of dumpable pages that will be dumped later */
1379 s
->num_dumpable
= num_dumpable
;
1382 g_free(dump_bitmap_buf
);
1385 static void prepare_data_cache(DataCache
*data_cache
, DumpState
*s
,
1388 data_cache
->fd
= s
->fd
;
1389 data_cache
->data_size
= 0;
1390 data_cache
->buf_size
= 4 * dump_bitmap_get_bufsize(s
);
1391 data_cache
->buf
= g_malloc0(data_cache
->buf_size
);
1392 data_cache
->offset
= offset
;
1395 static int write_cache(DataCache
*dc
, const void *buf
, size_t size
,
1399 * dc->buf_size should not be less than size, otherwise dc will never be
1402 assert(size
<= dc
->buf_size
);
1405 * if flag_sync is set, synchronize data in dc->buf into vmcore.
1406 * otherwise check if the space is enough for caching data in buf, if not,
1407 * write the data in dc->buf to dc->fd and reset dc->buf
1409 if ((!flag_sync
&& dc
->data_size
+ size
> dc
->buf_size
) ||
1410 (flag_sync
&& dc
->data_size
> 0)) {
1411 if (write_buffer(dc
->fd
, dc
->offset
, dc
->buf
, dc
->data_size
) < 0) {
1415 dc
->offset
+= dc
->data_size
;
1420 memcpy(dc
->buf
+ dc
->data_size
, buf
, size
);
1421 dc
->data_size
+= size
;
1427 static void free_data_cache(DataCache
*data_cache
)
1429 g_free(data_cache
->buf
);
1432 static size_t get_len_buf_out(size_t page_size
, uint32_t flag_compress
)
1434 switch (flag_compress
) {
1435 case DUMP_DH_COMPRESSED_ZLIB
:
1436 return compressBound(page_size
);
1438 case DUMP_DH_COMPRESSED_LZO
:
1440 * LZO will expand incompressible data by a little amount. Please check
1441 * the following URL to see the expansion calculation:
1442 * http://www.oberhumer.com/opensource/lzo/lzofaq.php
1444 return page_size
+ page_size
/ 16 + 64 + 3;
1446 #ifdef CONFIG_SNAPPY
1447 case DUMP_DH_COMPRESSED_SNAPPY
:
1448 return snappy_max_compressed_length(page_size
);
1454 static void write_dump_pages(DumpState
*s
, Error
**errp
)
1457 DataCache page_desc
, page_data
;
1458 size_t len_buf_out
, size_out
;
1460 lzo_bytep wrkmem
= NULL
;
1462 uint8_t *buf_out
= NULL
;
1463 off_t offset_desc
, offset_data
;
1464 PageDescriptor pd
, pd_zero
;
1466 GuestPhysBlock
*block_iter
= NULL
;
1468 g_autofree
uint8_t *page
= NULL
;
1470 /* get offset of page_desc and page_data in dump file */
1471 offset_desc
= s
->offset_page
;
1472 offset_data
= offset_desc
+ sizeof(PageDescriptor
) * s
->num_dumpable
;
1474 prepare_data_cache(&page_desc
, s
, offset_desc
);
1475 prepare_data_cache(&page_data
, s
, offset_data
);
1477 /* prepare buffer to store compressed data */
1478 len_buf_out
= get_len_buf_out(s
->dump_info
.page_size
, s
->flag_compress
);
1479 assert(len_buf_out
!= 0);
1482 wrkmem
= g_malloc(LZO1X_1_MEM_COMPRESS
);
1485 buf_out
= g_malloc(len_buf_out
);
1488 * init zero page's page_desc and page_data, because every zero page
1489 * uses the same page_data
1491 pd_zero
.size
= cpu_to_dump32(s
, s
->dump_info
.page_size
);
1492 pd_zero
.flags
= cpu_to_dump32(s
, 0);
1493 pd_zero
.offset
= cpu_to_dump64(s
, offset_data
);
1494 pd_zero
.page_flags
= cpu_to_dump64(s
, 0);
1495 buf
= g_malloc0(s
->dump_info
.page_size
);
1496 ret
= write_cache(&page_data
, buf
, s
->dump_info
.page_size
, false);
1499 error_setg(errp
, "dump: failed to write page data (zero page)");
1503 offset_data
+= s
->dump_info
.page_size
;
1504 page
= g_malloc(s
->dump_info
.page_size
);
1507 * dump memory to vmcore page by page. zero page will all be resided in the
1508 * first page of page section
1510 for (buf
= page
; get_next_page(&block_iter
, &pfn_iter
, &buf
, s
); buf
= page
) {
1511 /* check zero page */
1512 if (buffer_is_zero(buf
, s
->dump_info
.page_size
)) {
1513 ret
= write_cache(&page_desc
, &pd_zero
, sizeof(PageDescriptor
),
1516 error_setg(errp
, "dump: failed to write page desc");
1521 * not zero page, then:
1522 * 1. compress the page
1523 * 2. write the compressed page into the cache of page_data
1524 * 3. get page desc of the compressed page and write it into the
1525 * cache of page_desc
1527 * only one compression format will be used here, for
1528 * s->flag_compress is set. But when compression fails to work,
1529 * we fall back to save in plaintext.
1531 size_out
= len_buf_out
;
1532 if ((s
->flag_compress
& DUMP_DH_COMPRESSED_ZLIB
) &&
1533 (compress2(buf_out
, (uLongf
*)&size_out
, buf
,
1534 s
->dump_info
.page_size
, Z_BEST_SPEED
) == Z_OK
) &&
1535 (size_out
< s
->dump_info
.page_size
)) {
1536 pd
.flags
= cpu_to_dump32(s
, DUMP_DH_COMPRESSED_ZLIB
);
1537 pd
.size
= cpu_to_dump32(s
, size_out
);
1539 ret
= write_cache(&page_data
, buf_out
, size_out
, false);
1541 error_setg(errp
, "dump: failed to write page data");
1545 } else if ((s
->flag_compress
& DUMP_DH_COMPRESSED_LZO
) &&
1546 (lzo1x_1_compress(buf
, s
->dump_info
.page_size
, buf_out
,
1547 (lzo_uint
*)&size_out
, wrkmem
) == LZO_E_OK
) &&
1548 (size_out
< s
->dump_info
.page_size
)) {
1549 pd
.flags
= cpu_to_dump32(s
, DUMP_DH_COMPRESSED_LZO
);
1550 pd
.size
= cpu_to_dump32(s
, size_out
);
1552 ret
= write_cache(&page_data
, buf_out
, size_out
, false);
1554 error_setg(errp
, "dump: failed to write page data");
1558 #ifdef CONFIG_SNAPPY
1559 } else if ((s
->flag_compress
& DUMP_DH_COMPRESSED_SNAPPY
) &&
1560 (snappy_compress((char *)buf
, s
->dump_info
.page_size
,
1561 (char *)buf_out
, &size_out
) == SNAPPY_OK
) &&
1562 (size_out
< s
->dump_info
.page_size
)) {
1563 pd
.flags
= cpu_to_dump32(s
, DUMP_DH_COMPRESSED_SNAPPY
);
1564 pd
.size
= cpu_to_dump32(s
, size_out
);
1566 ret
= write_cache(&page_data
, buf_out
, size_out
, false);
1568 error_setg(errp
, "dump: failed to write page data");
1574 * fall back to save in plaintext, size_out should be
1575 * assigned the target's page size
1577 pd
.flags
= cpu_to_dump32(s
, 0);
1578 size_out
= s
->dump_info
.page_size
;
1579 pd
.size
= cpu_to_dump32(s
, size_out
);
1581 ret
= write_cache(&page_data
, buf
,
1582 s
->dump_info
.page_size
, false);
1584 error_setg(errp
, "dump: failed to write page data");
1589 /* get and write page desc here */
1590 pd
.page_flags
= cpu_to_dump64(s
, 0);
1591 pd
.offset
= cpu_to_dump64(s
, offset_data
);
1592 offset_data
+= size_out
;
1594 ret
= write_cache(&page_desc
, &pd
, sizeof(PageDescriptor
), false);
1596 error_setg(errp
, "dump: failed to write page desc");
1600 s
->written_size
+= s
->dump_info
.page_size
;
1603 ret
= write_cache(&page_desc
, NULL
, 0, true);
1605 error_setg(errp
, "dump: failed to sync cache for page_desc");
1608 ret
= write_cache(&page_data
, NULL
, 0, true);
1610 error_setg(errp
, "dump: failed to sync cache for page_data");
1615 free_data_cache(&page_desc
);
1616 free_data_cache(&page_data
);
1625 static void create_kdump_vmcore(DumpState
*s
, Error
**errp
)
1631 * the kdump-compressed format is:
1633 * +------------------------------------------+ 0x0
1634 * | main header (struct disk_dump_header) |
1635 * |------------------------------------------+ block 1
1636 * | sub header (struct kdump_sub_header) |
1637 * |------------------------------------------+ block 2
1638 * | 1st-dump_bitmap |
1639 * |------------------------------------------+ block 2 + X blocks
1640 * | 2nd-dump_bitmap | (aligned by block)
1641 * |------------------------------------------+ block 2 + 2 * X blocks
1642 * | page desc for pfn 0 (struct page_desc) | (aligned by block)
1643 * | page desc for pfn 1 (struct page_desc) |
1645 * |------------------------------------------| (not aligned by block)
1646 * | page data (pfn 0) |
1647 * | page data (pfn 1) |
1649 * +------------------------------------------+
1652 ret
= write_start_flat_header(s
->fd
);
1654 error_setg(errp
, "dump: failed to write start flat header");
1658 write_dump_header(s
, errp
);
1663 write_dump_bitmap(s
, errp
);
1668 write_dump_pages(s
, errp
);
1673 ret
= write_end_flat_header(s
->fd
);
1675 error_setg(errp
, "dump: failed to write end flat header");
1680 static int validate_start_block(DumpState
*s
)
1682 GuestPhysBlock
*block
;
1684 if (!dump_has_filter(s
)) {
1688 QTAILQ_FOREACH(block
, &s
->guest_phys_blocks
.head
, next
) {
1689 /* This block is out of the range */
1690 if (block
->target_start
>= s
->filter_area_begin
+ s
->filter_area_length
||
1691 block
->target_end
<= s
->filter_area_begin
) {
1700 static void get_max_mapnr(DumpState
*s
)
1702 GuestPhysBlock
*last_block
;
1704 last_block
= QTAILQ_LAST(&s
->guest_phys_blocks
.head
);
1705 s
->max_mapnr
= dump_paddr_to_pfn(s
, last_block
->target_end
);
1708 static DumpState dump_state_global
= { .status
= DUMP_STATUS_NONE
};
1710 static void dump_state_prepare(DumpState
*s
)
1712 /* zero the struct, setting status to active */
1713 *s
= (DumpState
) { .status
= DUMP_STATUS_ACTIVE
};
1716 bool qemu_system_dump_in_progress(void)
1718 DumpState
*state
= &dump_state_global
;
1719 return (qatomic_read(&state
->status
) == DUMP_STATUS_ACTIVE
);
1723 * calculate total size of memory to be dumped (taking filter into
1726 static int64_t dump_calculate_size(DumpState
*s
)
1728 GuestPhysBlock
*block
;
1731 QTAILQ_FOREACH(block
, &s
->guest_phys_blocks
.head
, next
) {
1732 total
+= dump_filtered_memblock_size(block
,
1733 s
->filter_area_begin
,
1734 s
->filter_area_length
);
1740 static void vmcoreinfo_update_phys_base(DumpState
*s
)
1742 uint64_t size
, note_head_size
, name_size
, phys_base
;
1747 if (!note_name_equal(s
, s
->guest_note
, "VMCOREINFO")) {
1751 get_note_sizes(s
, s
->guest_note
, ¬e_head_size
, &name_size
, &size
);
1752 note_head_size
= ROUND_UP(note_head_size
, 4);
1754 vmci
= s
->guest_note
+ note_head_size
+ ROUND_UP(name_size
, 4);
1755 *(vmci
+ size
) = '\0';
1757 lines
= g_strsplit((char *)vmci
, "\n", -1);
1758 for (i
= 0; lines
[i
]; i
++) {
1759 const char *prefix
= NULL
;
1761 if (s
->dump_info
.d_machine
== EM_X86_64
) {
1762 prefix
= "NUMBER(phys_base)=";
1763 } else if (s
->dump_info
.d_machine
== EM_AARCH64
) {
1764 prefix
= "NUMBER(PHYS_OFFSET)=";
1767 if (prefix
&& g_str_has_prefix(lines
[i
], prefix
)) {
1768 if (qemu_strtou64(lines
[i
] + strlen(prefix
), NULL
, 16,
1770 warn_report("Failed to read %s", prefix
);
1772 s
->dump_info
.phys_base
= phys_base
;
1781 static void dump_init(DumpState
*s
, int fd
, bool has_format
,
1782 DumpGuestMemoryFormat format
, bool paging
, bool has_filter
,
1783 int64_t begin
, int64_t length
, Error
**errp
)
1786 VMCoreInfoState
*vmci
= vmcoreinfo_find();
1791 s
->has_format
= has_format
;
1793 s
->written_size
= 0;
1795 /* kdump-compressed is conflict with paging and filter */
1796 if (has_format
&& format
!= DUMP_GUEST_MEMORY_FORMAT_ELF
) {
1797 assert(!paging
&& !has_filter
);
1800 if (runstate_is_running()) {
1801 vm_stop(RUN_STATE_SAVE_VM
);
1807 /* If we use KVM, we should synchronize the registers before we get dump
1808 * info or physmap info.
1810 cpu_synchronize_all_states();
1817 if (has_filter
&& !length
) {
1818 error_setg(errp
, QERR_INVALID_PARAMETER
, "length");
1821 s
->filter_area_begin
= begin
;
1822 s
->filter_area_length
= length
;
1824 /* First index is 0, it's the special null name */
1825 s
->string_table_buf
= g_array_new(FALSE
, TRUE
, 1);
1827 * Allocate the null name, due to the clearing option set to true
1830 g_array_set_size(s
->string_table_buf
, 1);
1832 memory_mapping_list_init(&s
->list
);
1834 guest_phys_blocks_init(&s
->guest_phys_blocks
);
1835 guest_phys_blocks_append(&s
->guest_phys_blocks
);
1836 s
->total_size
= dump_calculate_size(s
);
1837 #ifdef DEBUG_DUMP_GUEST_MEMORY
1838 fprintf(stderr
, "DUMP: total memory to dump: %lu\n", s
->total_size
);
1841 /* it does not make sense to dump non-existent memory */
1842 if (!s
->total_size
) {
1843 error_setg(errp
, "dump: no guest memory to dump");
1847 /* Is the filter filtering everything? */
1848 if (validate_start_block(s
) == -1) {
1849 error_setg(errp
, QERR_INVALID_PARAMETER
, "begin");
1853 /* get dump info: endian, class and architecture.
1854 * If the target architecture is not supported, cpu_get_dump_info() will
1857 ret
= cpu_get_dump_info(&s
->dump_info
, &s
->guest_phys_blocks
);
1859 error_setg(errp
, QERR_UNSUPPORTED
);
1863 if (!s
->dump_info
.page_size
) {
1864 s
->dump_info
.page_size
= TARGET_PAGE_SIZE
;
1867 s
->note_size
= cpu_get_note_size(s
->dump_info
.d_class
,
1868 s
->dump_info
.d_machine
, nr_cpus
);
1869 if (s
->note_size
< 0) {
1870 error_setg(errp
, QERR_UNSUPPORTED
);
1875 * The goal of this block is to (a) update the previously guessed
1876 * phys_base, (b) copy the guest note out of the guest.
1877 * Failure to do so is not fatal for dumping.
1880 uint64_t addr
, note_head_size
, name_size
, desc_size
;
1884 note_head_size
= dump_is_64bit(s
) ?
1885 sizeof(Elf64_Nhdr
) : sizeof(Elf32_Nhdr
);
1887 format
= le16_to_cpu(vmci
->vmcoreinfo
.guest_format
);
1888 size
= le32_to_cpu(vmci
->vmcoreinfo
.size
);
1889 addr
= le64_to_cpu(vmci
->vmcoreinfo
.paddr
);
1890 if (!vmci
->has_vmcoreinfo
) {
1891 warn_report("guest note is not present");
1892 } else if (size
< note_head_size
|| size
> MAX_GUEST_NOTE_SIZE
) {
1893 warn_report("guest note size is invalid: %" PRIu32
, size
);
1894 } else if (format
!= FW_CFG_VMCOREINFO_FORMAT_ELF
) {
1895 warn_report("guest note format is unsupported: %" PRIu16
, format
);
1897 s
->guest_note
= g_malloc(size
+ 1); /* +1 for adding \0 */
1898 cpu_physical_memory_read(addr
, s
->guest_note
, size
);
1900 get_note_sizes(s
, s
->guest_note
, NULL
, &name_size
, &desc_size
);
1901 s
->guest_note_size
= ELF_NOTE_SIZE(note_head_size
, name_size
,
1903 if (name_size
> MAX_GUEST_NOTE_SIZE
||
1904 desc_size
> MAX_GUEST_NOTE_SIZE
||
1905 s
->guest_note_size
> size
) {
1906 warn_report("Invalid guest note header");
1907 g_free(s
->guest_note
);
1908 s
->guest_note
= NULL
;
1910 vmcoreinfo_update_phys_base(s
);
1911 s
->note_size
+= s
->guest_note_size
;
1916 /* get memory mapping */
1918 qemu_get_guest_memory_mapping(&s
->list
, &s
->guest_phys_blocks
, errp
);
1923 qemu_get_guest_simple_memory_mapping(&s
->list
, &s
->guest_phys_blocks
);
1926 s
->nr_cpus
= nr_cpus
;
1931 tmp
= DIV_ROUND_UP(DIV_ROUND_UP(s
->max_mapnr
, CHAR_BIT
),
1932 s
->dump_info
.page_size
);
1933 s
->len_dump_bitmap
= tmp
* s
->dump_info
.page_size
;
1935 /* init for kdump-compressed format */
1936 if (has_format
&& format
!= DUMP_GUEST_MEMORY_FORMAT_ELF
) {
1938 case DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB
:
1939 s
->flag_compress
= DUMP_DH_COMPRESSED_ZLIB
;
1942 case DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO
:
1944 if (lzo_init() != LZO_E_OK
) {
1945 error_setg(errp
, "failed to initialize the LZO library");
1949 s
->flag_compress
= DUMP_DH_COMPRESSED_LZO
;
1952 case DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY
:
1953 s
->flag_compress
= DUMP_DH_COMPRESSED_SNAPPY
;
1957 s
->flag_compress
= 0;
1963 if (dump_has_filter(s
)) {
1964 memory_mapping_filter(&s
->list
, s
->filter_area_begin
, s
->filter_area_length
);
1968 * The first section header is always a special one in which most
1969 * fields are 0. The section header string table is also always
1975 * Adds the number of architecture sections to shdr_num and sets
1976 * elf_section_data_size so we know the offsets and sizes of all
1979 if (s
->dump_info
.arch_sections_add_fn
) {
1980 s
->dump_info
.arch_sections_add_fn(s
);
1984 * calculate shdr_num so we know the offsets and sizes of all
1986 * Calculate phdr_num
1988 * The absolute maximum amount of phdrs is UINT32_MAX - 1 as
1989 * sh_info is 32 bit. There's special handling once we go over
1990 * UINT16_MAX - 1 but that is handled in the ehdr and section
1993 s
->phdr_num
= 1; /* Reserve PT_NOTE */
1994 if (s
->list
.num
<= UINT32_MAX
- 1) {
1995 s
->phdr_num
+= s
->list
.num
;
1997 s
->phdr_num
= UINT32_MAX
;
2001 * Now that the number of section and program headers is known we
2002 * can calculate the offsets of the headers and data.
2004 if (dump_is_64bit(s
)) {
2005 s
->shdr_offset
= sizeof(Elf64_Ehdr
);
2006 s
->phdr_offset
= s
->shdr_offset
+ sizeof(Elf64_Shdr
) * s
->shdr_num
;
2007 s
->note_offset
= s
->phdr_offset
+ sizeof(Elf64_Phdr
) * s
->phdr_num
;
2009 s
->shdr_offset
= sizeof(Elf32_Ehdr
);
2010 s
->phdr_offset
= s
->shdr_offset
+ sizeof(Elf32_Shdr
) * s
->shdr_num
;
2011 s
->note_offset
= s
->phdr_offset
+ sizeof(Elf32_Phdr
) * s
->phdr_num
;
2013 s
->memory_offset
= s
->note_offset
+ s
->note_size
;
2014 s
->section_offset
= s
->memory_offset
+ s
->total_size
;
2022 /* this operation might be time consuming. */
2023 static void dump_process(DumpState
*s
, Error
**errp
)
2026 DumpQueryResult
*result
= NULL
;
2028 if (s
->has_format
&& s
->format
== DUMP_GUEST_MEMORY_FORMAT_WIN_DMP
) {
2029 #ifdef TARGET_X86_64
2030 create_win_dump(s
, errp
);
2032 } else if (s
->has_format
&& s
->format
!= DUMP_GUEST_MEMORY_FORMAT_ELF
) {
2033 create_kdump_vmcore(s
, errp
);
2035 create_vmcore(s
, errp
);
2038 /* make sure status is written after written_size updates */
2040 qatomic_set(&s
->status
,
2041 (*errp
? DUMP_STATUS_FAILED
: DUMP_STATUS_COMPLETED
));
2043 /* send DUMP_COMPLETED message (unconditionally) */
2044 result
= qmp_query_dump(NULL
);
2045 /* should never fail */
2047 qapi_event_send_dump_completed(result
, !!*errp
, (*errp
?
2048 error_get_pretty(*errp
) : NULL
));
2049 qapi_free_DumpQueryResult(result
);
2054 static void *dump_thread(void *data
)
2056 DumpState
*s
= (DumpState
*)data
;
2057 dump_process(s
, NULL
);
2061 DumpQueryResult
*qmp_query_dump(Error
**errp
)
2063 DumpQueryResult
*result
= g_new(DumpQueryResult
, 1);
2064 DumpState
*state
= &dump_state_global
;
2065 result
->status
= qatomic_read(&state
->status
);
2066 /* make sure we are reading status and written_size in order */
2068 result
->completed
= state
->written_size
;
2069 result
->total
= state
->total_size
;
2073 void qmp_dump_guest_memory(bool paging
, const char *file
,
2074 bool has_detach
, bool detach
,
2075 bool has_begin
, int64_t begin
, bool has_length
,
2076 int64_t length
, bool has_format
,
2077 DumpGuestMemoryFormat format
, Error
**errp
)
2083 bool detach_p
= false;
2085 if (runstate_check(RUN_STATE_INMIGRATE
)) {
2086 error_setg(errp
, "Dump not allowed during incoming migration.");
2090 /* if there is a dump in background, we should wait until the dump
2092 if (qemu_system_dump_in_progress()) {
2093 error_setg(errp
, "There is a dump in process, please wait.");
2098 * kdump-compressed format need the whole memory dumped, so paging or
2099 * filter is not supported here.
2101 if ((has_format
&& format
!= DUMP_GUEST_MEMORY_FORMAT_ELF
) &&
2102 (paging
|| has_begin
|| has_length
)) {
2103 error_setg(errp
, "kdump-compressed format doesn't support paging or "
2107 if (has_begin
&& !has_length
) {
2108 error_setg(errp
, QERR_MISSING_PARAMETER
, "length");
2111 if (!has_begin
&& has_length
) {
2112 error_setg(errp
, QERR_MISSING_PARAMETER
, "begin");
2119 /* check whether lzo/snappy is supported */
2121 if (has_format
&& format
== DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO
) {
2122 error_setg(errp
, "kdump-lzo is not available now");
2127 #ifndef CONFIG_SNAPPY
2128 if (has_format
&& format
== DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY
) {
2129 error_setg(errp
, "kdump-snappy is not available now");
2134 #ifndef TARGET_X86_64
2135 if (has_format
&& format
== DUMP_GUEST_MEMORY_FORMAT_WIN_DMP
) {
2136 error_setg(errp
, "Windows dump is only available for x86-64");
2142 if (strstart(file
, "fd:", &p
)) {
2143 fd
= monitor_get_fd(monitor_cur(), p
, errp
);
2150 if (strstart(file
, "file:", &p
)) {
2151 fd
= qemu_open_old(p
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, S_IRUSR
);
2153 error_setg_file_open(errp
, errno
, p
);
2159 error_setg(errp
, QERR_INVALID_PARAMETER
, "protocol");
2163 if (!dump_migration_blocker
) {
2164 error_setg(&dump_migration_blocker
,
2165 "Live migration disabled: dump-guest-memory in progress");
2169 * Allows even for -only-migratable, but forbid migration during the
2170 * process of dump guest memory.
2172 if (migrate_add_blocker_internal(dump_migration_blocker
, errp
)) {
2173 /* Remember to release the fd before passing it over to dump state */
2178 s
= &dump_state_global
;
2179 dump_state_prepare(s
);
2181 dump_init(s
, fd
, has_format
, format
, paging
, has_begin
,
2182 begin
, length
, errp
);
2184 qatomic_set(&s
->status
, DUMP_STATUS_FAILED
);
2191 qemu_thread_create(&s
->dump_thread
, "dump_thread", dump_thread
,
2192 s
, QEMU_THREAD_DETACHED
);
2195 dump_process(s
, errp
);
2199 DumpGuestMemoryCapability
*qmp_query_dump_guest_memory_capability(Error
**errp
)
2201 DumpGuestMemoryCapability
*cap
=
2202 g_new0(DumpGuestMemoryCapability
, 1);
2203 DumpGuestMemoryFormatList
**tail
= &cap
->formats
;
2205 /* elf is always available */
2206 QAPI_LIST_APPEND(tail
, DUMP_GUEST_MEMORY_FORMAT_ELF
);
2208 /* kdump-zlib is always available */
2209 QAPI_LIST_APPEND(tail
, DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB
);
2211 /* add new item if kdump-lzo is available */
2213 QAPI_LIST_APPEND(tail
, DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO
);
2216 /* add new item if kdump-snappy is available */
2217 #ifdef CONFIG_SNAPPY
2218 QAPI_LIST_APPEND(tail
, DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY
);
2221 /* Windows dump is available only if target is x86_64 */
2222 #ifdef TARGET_X86_64
2223 QAPI_LIST_APPEND(tail
, DUMP_GUEST_MEMORY_FORMAT_WIN_DMP
);