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-common.h"
18 #include "exec/cpu-all.h"
19 #include "exec/hwaddr.h"
20 #include "monitor/monitor.h"
21 #include "sysemu/kvm.h"
22 #include "sysemu/dump.h"
23 #include "sysemu/sysemu.h"
24 #include "sysemu/memory_mapping.h"
25 #include "sysemu/cpus.h"
26 #include "qapi/qmp/qerror.h"
27 #include "qmp-commands.h"
31 #include <lzo/lzo1x.h>
36 #ifndef ELF_MACHINE_UNAME
37 #define ELF_MACHINE_UNAME "Unknown"
40 uint16_t cpu_to_dump16(DumpState
*s
, uint16_t val
)
42 if (s
->dump_info
.d_endian
== ELFDATA2LSB
) {
43 val
= cpu_to_le16(val
);
45 val
= cpu_to_be16(val
);
51 uint32_t cpu_to_dump32(DumpState
*s
, uint32_t val
)
53 if (s
->dump_info
.d_endian
== ELFDATA2LSB
) {
54 val
= cpu_to_le32(val
);
56 val
= cpu_to_be32(val
);
62 uint64_t cpu_to_dump64(DumpState
*s
, uint64_t val
)
64 if (s
->dump_info
.d_endian
== ELFDATA2LSB
) {
65 val
= cpu_to_le64(val
);
67 val
= cpu_to_be64(val
);
73 static int dump_cleanup(DumpState
*s
)
75 guest_phys_blocks_free(&s
->guest_phys_blocks
);
76 memory_mapping_list_free(&s
->list
);
85 static int fd_write_vmcore(const void *buf
, size_t size
, void *opaque
)
87 DumpState
*s
= opaque
;
90 written_size
= qemu_write_full(s
->fd
, buf
, size
);
91 if (written_size
!= size
) {
98 static void write_elf64_header(DumpState
*s
, Error
**errp
)
100 Elf64_Ehdr elf_header
;
103 memset(&elf_header
, 0, sizeof(Elf64_Ehdr
));
104 memcpy(&elf_header
, ELFMAG
, SELFMAG
);
105 elf_header
.e_ident
[EI_CLASS
] = ELFCLASS64
;
106 elf_header
.e_ident
[EI_DATA
] = s
->dump_info
.d_endian
;
107 elf_header
.e_ident
[EI_VERSION
] = EV_CURRENT
;
108 elf_header
.e_type
= cpu_to_dump16(s
, ET_CORE
);
109 elf_header
.e_machine
= cpu_to_dump16(s
, s
->dump_info
.d_machine
);
110 elf_header
.e_version
= cpu_to_dump32(s
, EV_CURRENT
);
111 elf_header
.e_ehsize
= cpu_to_dump16(s
, sizeof(elf_header
));
112 elf_header
.e_phoff
= cpu_to_dump64(s
, sizeof(Elf64_Ehdr
));
113 elf_header
.e_phentsize
= cpu_to_dump16(s
, sizeof(Elf64_Phdr
));
114 elf_header
.e_phnum
= cpu_to_dump16(s
, s
->phdr_num
);
115 if (s
->have_section
) {
116 uint64_t shoff
= sizeof(Elf64_Ehdr
) + sizeof(Elf64_Phdr
) * s
->sh_info
;
118 elf_header
.e_shoff
= cpu_to_dump64(s
, shoff
);
119 elf_header
.e_shentsize
= cpu_to_dump16(s
, sizeof(Elf64_Shdr
));
120 elf_header
.e_shnum
= cpu_to_dump16(s
, 1);
123 ret
= fd_write_vmcore(&elf_header
, sizeof(elf_header
), s
);
125 error_setg(errp
, "dump: failed to write elf header");
129 static void write_elf32_header(DumpState
*s
, Error
**errp
)
131 Elf32_Ehdr elf_header
;
134 memset(&elf_header
, 0, sizeof(Elf32_Ehdr
));
135 memcpy(&elf_header
, ELFMAG
, SELFMAG
);
136 elf_header
.e_ident
[EI_CLASS
] = ELFCLASS32
;
137 elf_header
.e_ident
[EI_DATA
] = s
->dump_info
.d_endian
;
138 elf_header
.e_ident
[EI_VERSION
] = EV_CURRENT
;
139 elf_header
.e_type
= cpu_to_dump16(s
, ET_CORE
);
140 elf_header
.e_machine
= cpu_to_dump16(s
, s
->dump_info
.d_machine
);
141 elf_header
.e_version
= cpu_to_dump32(s
, EV_CURRENT
);
142 elf_header
.e_ehsize
= cpu_to_dump16(s
, sizeof(elf_header
));
143 elf_header
.e_phoff
= cpu_to_dump32(s
, sizeof(Elf32_Ehdr
));
144 elf_header
.e_phentsize
= cpu_to_dump16(s
, sizeof(Elf32_Phdr
));
145 elf_header
.e_phnum
= cpu_to_dump16(s
, s
->phdr_num
);
146 if (s
->have_section
) {
147 uint32_t shoff
= sizeof(Elf32_Ehdr
) + sizeof(Elf32_Phdr
) * s
->sh_info
;
149 elf_header
.e_shoff
= cpu_to_dump32(s
, shoff
);
150 elf_header
.e_shentsize
= cpu_to_dump16(s
, sizeof(Elf32_Shdr
));
151 elf_header
.e_shnum
= cpu_to_dump16(s
, 1);
154 ret
= fd_write_vmcore(&elf_header
, sizeof(elf_header
), s
);
156 error_setg(errp
, "dump: failed to write elf header");
160 static void write_elf64_load(DumpState
*s
, MemoryMapping
*memory_mapping
,
161 int phdr_index
, hwaddr offset
,
162 hwaddr filesz
, Error
**errp
)
167 memset(&phdr
, 0, sizeof(Elf64_Phdr
));
168 phdr
.p_type
= cpu_to_dump32(s
, PT_LOAD
);
169 phdr
.p_offset
= cpu_to_dump64(s
, offset
);
170 phdr
.p_paddr
= cpu_to_dump64(s
, memory_mapping
->phys_addr
);
171 phdr
.p_filesz
= cpu_to_dump64(s
, filesz
);
172 phdr
.p_memsz
= cpu_to_dump64(s
, memory_mapping
->length
);
173 phdr
.p_vaddr
= cpu_to_dump64(s
, memory_mapping
->virt_addr
);
175 assert(memory_mapping
->length
>= filesz
);
177 ret
= fd_write_vmcore(&phdr
, sizeof(Elf64_Phdr
), s
);
179 error_setg(errp
, "dump: failed to write program header table");
183 static void write_elf32_load(DumpState
*s
, MemoryMapping
*memory_mapping
,
184 int phdr_index
, hwaddr offset
,
185 hwaddr filesz
, Error
**errp
)
190 memset(&phdr
, 0, sizeof(Elf32_Phdr
));
191 phdr
.p_type
= cpu_to_dump32(s
, PT_LOAD
);
192 phdr
.p_offset
= cpu_to_dump32(s
, offset
);
193 phdr
.p_paddr
= cpu_to_dump32(s
, memory_mapping
->phys_addr
);
194 phdr
.p_filesz
= cpu_to_dump32(s
, filesz
);
195 phdr
.p_memsz
= cpu_to_dump32(s
, memory_mapping
->length
);
196 phdr
.p_vaddr
= cpu_to_dump32(s
, memory_mapping
->virt_addr
);
198 assert(memory_mapping
->length
>= filesz
);
200 ret
= fd_write_vmcore(&phdr
, sizeof(Elf32_Phdr
), s
);
202 error_setg(errp
, "dump: failed to write program header table");
206 static void write_elf64_note(DumpState
*s
, Error
**errp
)
209 hwaddr begin
= s
->memory_offset
- s
->note_size
;
212 memset(&phdr
, 0, sizeof(Elf64_Phdr
));
213 phdr
.p_type
= cpu_to_dump32(s
, PT_NOTE
);
214 phdr
.p_offset
= cpu_to_dump64(s
, begin
);
216 phdr
.p_filesz
= cpu_to_dump64(s
, s
->note_size
);
217 phdr
.p_memsz
= cpu_to_dump64(s
, s
->note_size
);
220 ret
= fd_write_vmcore(&phdr
, sizeof(Elf64_Phdr
), s
);
222 error_setg(errp
, "dump: failed to write program header table");
226 static inline int cpu_index(CPUState
*cpu
)
228 return cpu
->cpu_index
+ 1;
231 static void write_elf64_notes(WriteCoreDumpFunction f
, DumpState
*s
,
240 ret
= cpu_write_elf64_note(f
, cpu
, id
, s
);
242 error_setg(errp
, "dump: failed to write elf notes");
248 ret
= cpu_write_elf64_qemunote(f
, cpu
, s
);
250 error_setg(errp
, "dump: failed to write CPU status");
256 static void write_elf32_note(DumpState
*s
, Error
**errp
)
258 hwaddr begin
= s
->memory_offset
- s
->note_size
;
262 memset(&phdr
, 0, sizeof(Elf32_Phdr
));
263 phdr
.p_type
= cpu_to_dump32(s
, PT_NOTE
);
264 phdr
.p_offset
= cpu_to_dump32(s
, begin
);
266 phdr
.p_filesz
= cpu_to_dump32(s
, s
->note_size
);
267 phdr
.p_memsz
= cpu_to_dump32(s
, s
->note_size
);
270 ret
= fd_write_vmcore(&phdr
, sizeof(Elf32_Phdr
), s
);
272 error_setg(errp
, "dump: failed to write program header table");
276 static void write_elf32_notes(WriteCoreDumpFunction f
, DumpState
*s
,
285 ret
= cpu_write_elf32_note(f
, cpu
, id
, s
);
287 error_setg(errp
, "dump: failed to write elf notes");
293 ret
= cpu_write_elf32_qemunote(f
, cpu
, s
);
295 error_setg(errp
, "dump: failed to write CPU status");
301 static void write_elf_section(DumpState
*s
, int type
, Error
**errp
)
310 shdr_size
= sizeof(Elf32_Shdr
);
311 memset(&shdr32
, 0, shdr_size
);
312 shdr32
.sh_info
= cpu_to_dump32(s
, s
->sh_info
);
315 shdr_size
= sizeof(Elf64_Shdr
);
316 memset(&shdr64
, 0, shdr_size
);
317 shdr64
.sh_info
= cpu_to_dump32(s
, s
->sh_info
);
321 ret
= fd_write_vmcore(&shdr
, shdr_size
, s
);
323 error_setg(errp
, "dump: failed to write section header table");
327 static void write_data(DumpState
*s
, void *buf
, int length
, Error
**errp
)
331 ret
= fd_write_vmcore(buf
, length
, s
);
333 error_setg(errp
, "dump: failed to save memory");
335 s
->written_size
+= length
;
339 /* write the memory to vmcore. 1 page per I/O. */
340 static void write_memory(DumpState
*s
, GuestPhysBlock
*block
, ram_addr_t start
,
341 int64_t size
, Error
**errp
)
344 Error
*local_err
= NULL
;
346 for (i
= 0; i
< size
/ s
->dump_info
.page_size
; i
++) {
347 write_data(s
, block
->host_addr
+ start
+ i
* s
->dump_info
.page_size
,
348 s
->dump_info
.page_size
, &local_err
);
350 error_propagate(errp
, local_err
);
355 if ((size
% s
->dump_info
.page_size
) != 0) {
356 write_data(s
, block
->host_addr
+ start
+ i
* s
->dump_info
.page_size
,
357 size
% s
->dump_info
.page_size
, &local_err
);
359 error_propagate(errp
, local_err
);
365 /* get the memory's offset and size in the vmcore */
366 static void get_offset_range(hwaddr phys_addr
,
367 ram_addr_t mapping_length
,
372 GuestPhysBlock
*block
;
373 hwaddr offset
= s
->memory_offset
;
374 int64_t size_in_block
, start
;
376 /* When the memory is not stored into vmcore, offset will be -1 */
381 if (phys_addr
< s
->begin
|| phys_addr
>= s
->begin
+ s
->length
) {
386 QTAILQ_FOREACH(block
, &s
->guest_phys_blocks
.head
, next
) {
388 if (block
->target_start
>= s
->begin
+ s
->length
||
389 block
->target_end
<= s
->begin
) {
390 /* This block is out of the range */
394 if (s
->begin
<= block
->target_start
) {
395 start
= block
->target_start
;
400 size_in_block
= block
->target_end
- start
;
401 if (s
->begin
+ s
->length
< block
->target_end
) {
402 size_in_block
-= block
->target_end
- (s
->begin
+ s
->length
);
405 start
= block
->target_start
;
406 size_in_block
= block
->target_end
- block
->target_start
;
409 if (phys_addr
>= start
&& phys_addr
< start
+ size_in_block
) {
410 *p_offset
= phys_addr
- start
+ offset
;
412 /* The offset range mapped from the vmcore file must not spill over
413 * the GuestPhysBlock, clamp it. The rest of the mapping will be
414 * zero-filled in memory at load time; see
415 * <http://refspecs.linuxbase.org/elf/gabi4+/ch5.pheader.html>.
417 *p_filesz
= phys_addr
+ mapping_length
<= start
+ size_in_block
?
419 size_in_block
- (phys_addr
- start
);
423 offset
+= size_in_block
;
427 static void write_elf_loads(DumpState
*s
, Error
**errp
)
429 hwaddr offset
, filesz
;
430 MemoryMapping
*memory_mapping
;
431 uint32_t phdr_index
= 1;
433 Error
*local_err
= NULL
;
435 if (s
->have_section
) {
436 max_index
= s
->sh_info
;
438 max_index
= s
->phdr_num
;
441 QTAILQ_FOREACH(memory_mapping
, &s
->list
.head
, next
) {
442 get_offset_range(memory_mapping
->phys_addr
,
443 memory_mapping
->length
,
444 s
, &offset
, &filesz
);
445 if (s
->dump_info
.d_class
== ELFCLASS64
) {
446 write_elf64_load(s
, memory_mapping
, phdr_index
++, offset
,
449 write_elf32_load(s
, memory_mapping
, phdr_index
++, offset
,
454 error_propagate(errp
, local_err
);
458 if (phdr_index
>= max_index
) {
464 /* write elf header, PT_NOTE and elf note to vmcore. */
465 static void dump_begin(DumpState
*s
, Error
**errp
)
467 Error
*local_err
= NULL
;
470 * the vmcore's format is:
489 * we only know where the memory is saved after we write elf note into
493 /* write elf header to vmcore */
494 if (s
->dump_info
.d_class
== ELFCLASS64
) {
495 write_elf64_header(s
, &local_err
);
497 write_elf32_header(s
, &local_err
);
500 error_propagate(errp
, local_err
);
504 if (s
->dump_info
.d_class
== ELFCLASS64
) {
505 /* write PT_NOTE to vmcore */
506 write_elf64_note(s
, &local_err
);
508 error_propagate(errp
, local_err
);
512 /* write all PT_LOAD to vmcore */
513 write_elf_loads(s
, &local_err
);
515 error_propagate(errp
, local_err
);
519 /* write section to vmcore */
520 if (s
->have_section
) {
521 write_elf_section(s
, 1, &local_err
);
523 error_propagate(errp
, local_err
);
528 /* write notes to vmcore */
529 write_elf64_notes(fd_write_vmcore
, s
, &local_err
);
531 error_propagate(errp
, local_err
);
535 /* write PT_NOTE to vmcore */
536 write_elf32_note(s
, &local_err
);
538 error_propagate(errp
, local_err
);
542 /* write all PT_LOAD to vmcore */
543 write_elf_loads(s
, &local_err
);
545 error_propagate(errp
, local_err
);
549 /* write section to vmcore */
550 if (s
->have_section
) {
551 write_elf_section(s
, 0, &local_err
);
553 error_propagate(errp
, local_err
);
558 /* write notes to vmcore */
559 write_elf32_notes(fd_write_vmcore
, s
, &local_err
);
561 error_propagate(errp
, local_err
);
567 static int get_next_block(DumpState
*s
, GuestPhysBlock
*block
)
570 block
= QTAILQ_NEXT(block
, next
);
577 s
->next_block
= block
;
579 if (block
->target_start
>= s
->begin
+ s
->length
||
580 block
->target_end
<= s
->begin
) {
581 /* This block is out of the range */
585 if (s
->begin
> block
->target_start
) {
586 s
->start
= s
->begin
- block
->target_start
;
594 /* write all memory to vmcore */
595 static void dump_iterate(DumpState
*s
, Error
**errp
)
597 GuestPhysBlock
*block
;
599 Error
*local_err
= NULL
;
602 block
= s
->next_block
;
604 size
= block
->target_end
- block
->target_start
;
607 if (s
->begin
+ s
->length
< block
->target_end
) {
608 size
-= block
->target_end
- (s
->begin
+ s
->length
);
611 write_memory(s
, block
, s
->start
, size
, &local_err
);
613 error_propagate(errp
, local_err
);
617 } while (!get_next_block(s
, block
));
620 static void create_vmcore(DumpState
*s
, Error
**errp
)
622 Error
*local_err
= NULL
;
624 dump_begin(s
, &local_err
);
626 error_propagate(errp
, local_err
);
630 dump_iterate(s
, errp
);
633 static int write_start_flat_header(int fd
)
635 MakedumpfileHeader
*mh
;
638 QEMU_BUILD_BUG_ON(sizeof *mh
> MAX_SIZE_MDF_HEADER
);
639 mh
= g_malloc0(MAX_SIZE_MDF_HEADER
);
641 memcpy(mh
->signature
, MAKEDUMPFILE_SIGNATURE
,
642 MIN(sizeof mh
->signature
, sizeof MAKEDUMPFILE_SIGNATURE
));
644 mh
->type
= cpu_to_be64(TYPE_FLAT_HEADER
);
645 mh
->version
= cpu_to_be64(VERSION_FLAT_HEADER
);
648 written_size
= qemu_write_full(fd
, mh
, MAX_SIZE_MDF_HEADER
);
649 if (written_size
!= MAX_SIZE_MDF_HEADER
) {
657 static int write_end_flat_header(int fd
)
659 MakedumpfileDataHeader mdh
;
661 mdh
.offset
= END_FLAG_FLAT_HEADER
;
662 mdh
.buf_size
= END_FLAG_FLAT_HEADER
;
665 written_size
= qemu_write_full(fd
, &mdh
, sizeof(mdh
));
666 if (written_size
!= sizeof(mdh
)) {
673 static int write_buffer(int fd
, off_t offset
, const void *buf
, size_t size
)
676 MakedumpfileDataHeader mdh
;
678 mdh
.offset
= cpu_to_be64(offset
);
679 mdh
.buf_size
= cpu_to_be64(size
);
681 written_size
= qemu_write_full(fd
, &mdh
, sizeof(mdh
));
682 if (written_size
!= sizeof(mdh
)) {
686 written_size
= qemu_write_full(fd
, buf
, size
);
687 if (written_size
!= size
) {
694 static int buf_write_note(const void *buf
, size_t size
, void *opaque
)
696 DumpState
*s
= opaque
;
698 /* note_buf is not enough */
699 if (s
->note_buf_offset
+ size
> s
->note_size
) {
703 memcpy(s
->note_buf
+ s
->note_buf_offset
, buf
, size
);
705 s
->note_buf_offset
+= size
;
710 /* write common header, sub header and elf note to vmcore */
711 static void create_header32(DumpState
*s
, Error
**errp
)
713 DiskDumpHeader32
*dh
= NULL
;
714 KdumpSubHeader32
*kh
= NULL
;
717 uint32_t sub_hdr_size
;
718 uint32_t bitmap_blocks
;
720 uint64_t offset_note
;
721 Error
*local_err
= NULL
;
723 /* write common header, the version of kdump-compressed format is 6th */
724 size
= sizeof(DiskDumpHeader32
);
725 dh
= g_malloc0(size
);
727 strncpy(dh
->signature
, KDUMP_SIGNATURE
, strlen(KDUMP_SIGNATURE
));
728 dh
->header_version
= cpu_to_dump32(s
, 6);
729 block_size
= s
->dump_info
.page_size
;
730 dh
->block_size
= cpu_to_dump32(s
, block_size
);
731 sub_hdr_size
= sizeof(struct KdumpSubHeader32
) + s
->note_size
;
732 sub_hdr_size
= DIV_ROUND_UP(sub_hdr_size
, block_size
);
733 dh
->sub_hdr_size
= cpu_to_dump32(s
, sub_hdr_size
);
734 /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
735 dh
->max_mapnr
= cpu_to_dump32(s
, MIN(s
->max_mapnr
, UINT_MAX
));
736 dh
->nr_cpus
= cpu_to_dump32(s
, s
->nr_cpus
);
737 bitmap_blocks
= DIV_ROUND_UP(s
->len_dump_bitmap
, block_size
) * 2;
738 dh
->bitmap_blocks
= cpu_to_dump32(s
, bitmap_blocks
);
739 strncpy(dh
->utsname
.machine
, ELF_MACHINE_UNAME
, sizeof(dh
->utsname
.machine
));
741 if (s
->flag_compress
& DUMP_DH_COMPRESSED_ZLIB
) {
742 status
|= DUMP_DH_COMPRESSED_ZLIB
;
745 if (s
->flag_compress
& DUMP_DH_COMPRESSED_LZO
) {
746 status
|= DUMP_DH_COMPRESSED_LZO
;
750 if (s
->flag_compress
& DUMP_DH_COMPRESSED_SNAPPY
) {
751 status
|= DUMP_DH_COMPRESSED_SNAPPY
;
754 dh
->status
= cpu_to_dump32(s
, status
);
756 if (write_buffer(s
->fd
, 0, dh
, size
) < 0) {
757 error_setg(errp
, "dump: failed to write disk dump header");
761 /* write sub header */
762 size
= sizeof(KdumpSubHeader32
);
763 kh
= g_malloc0(size
);
765 /* 64bit max_mapnr_64 */
766 kh
->max_mapnr_64
= cpu_to_dump64(s
, s
->max_mapnr
);
767 kh
->phys_base
= cpu_to_dump32(s
, s
->dump_info
.phys_base
);
768 kh
->dump_level
= cpu_to_dump32(s
, DUMP_LEVEL
);
770 offset_note
= DISKDUMP_HEADER_BLOCKS
* block_size
+ size
;
771 kh
->offset_note
= cpu_to_dump64(s
, offset_note
);
772 kh
->note_size
= cpu_to_dump32(s
, s
->note_size
);
774 if (write_buffer(s
->fd
, DISKDUMP_HEADER_BLOCKS
*
775 block_size
, kh
, size
) < 0) {
776 error_setg(errp
, "dump: failed to write kdump sub header");
781 s
->note_buf
= g_malloc0(s
->note_size
);
782 s
->note_buf_offset
= 0;
784 /* use s->note_buf to store notes temporarily */
785 write_elf32_notes(buf_write_note
, s
, &local_err
);
787 error_propagate(errp
, local_err
);
790 if (write_buffer(s
->fd
, offset_note
, s
->note_buf
,
792 error_setg(errp
, "dump: failed to write notes");
796 /* get offset of dump_bitmap */
797 s
->offset_dump_bitmap
= (DISKDUMP_HEADER_BLOCKS
+ sub_hdr_size
) *
800 /* get offset of page */
801 s
->offset_page
= (DISKDUMP_HEADER_BLOCKS
+ sub_hdr_size
+ bitmap_blocks
) *
810 /* write common header, sub header and elf note to vmcore */
811 static void create_header64(DumpState
*s
, Error
**errp
)
813 DiskDumpHeader64
*dh
= NULL
;
814 KdumpSubHeader64
*kh
= NULL
;
817 uint32_t sub_hdr_size
;
818 uint32_t bitmap_blocks
;
820 uint64_t offset_note
;
821 Error
*local_err
= NULL
;
823 /* write common header, the version of kdump-compressed format is 6th */
824 size
= sizeof(DiskDumpHeader64
);
825 dh
= g_malloc0(size
);
827 strncpy(dh
->signature
, KDUMP_SIGNATURE
, strlen(KDUMP_SIGNATURE
));
828 dh
->header_version
= cpu_to_dump32(s
, 6);
829 block_size
= s
->dump_info
.page_size
;
830 dh
->block_size
= cpu_to_dump32(s
, block_size
);
831 sub_hdr_size
= sizeof(struct KdumpSubHeader64
) + s
->note_size
;
832 sub_hdr_size
= DIV_ROUND_UP(sub_hdr_size
, block_size
);
833 dh
->sub_hdr_size
= cpu_to_dump32(s
, sub_hdr_size
);
834 /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
835 dh
->max_mapnr
= cpu_to_dump32(s
, MIN(s
->max_mapnr
, UINT_MAX
));
836 dh
->nr_cpus
= cpu_to_dump32(s
, s
->nr_cpus
);
837 bitmap_blocks
= DIV_ROUND_UP(s
->len_dump_bitmap
, block_size
) * 2;
838 dh
->bitmap_blocks
= cpu_to_dump32(s
, bitmap_blocks
);
839 strncpy(dh
->utsname
.machine
, ELF_MACHINE_UNAME
, sizeof(dh
->utsname
.machine
));
841 if (s
->flag_compress
& DUMP_DH_COMPRESSED_ZLIB
) {
842 status
|= DUMP_DH_COMPRESSED_ZLIB
;
845 if (s
->flag_compress
& DUMP_DH_COMPRESSED_LZO
) {
846 status
|= DUMP_DH_COMPRESSED_LZO
;
850 if (s
->flag_compress
& DUMP_DH_COMPRESSED_SNAPPY
) {
851 status
|= DUMP_DH_COMPRESSED_SNAPPY
;
854 dh
->status
= cpu_to_dump32(s
, status
);
856 if (write_buffer(s
->fd
, 0, dh
, size
) < 0) {
857 error_setg(errp
, "dump: failed to write disk dump header");
861 /* write sub header */
862 size
= sizeof(KdumpSubHeader64
);
863 kh
= g_malloc0(size
);
865 /* 64bit max_mapnr_64 */
866 kh
->max_mapnr_64
= cpu_to_dump64(s
, s
->max_mapnr
);
867 kh
->phys_base
= cpu_to_dump64(s
, s
->dump_info
.phys_base
);
868 kh
->dump_level
= cpu_to_dump32(s
, DUMP_LEVEL
);
870 offset_note
= DISKDUMP_HEADER_BLOCKS
* block_size
+ size
;
871 kh
->offset_note
= cpu_to_dump64(s
, offset_note
);
872 kh
->note_size
= cpu_to_dump64(s
, s
->note_size
);
874 if (write_buffer(s
->fd
, DISKDUMP_HEADER_BLOCKS
*
875 block_size
, kh
, size
) < 0) {
876 error_setg(errp
, "dump: failed to write kdump sub header");
881 s
->note_buf
= g_malloc0(s
->note_size
);
882 s
->note_buf_offset
= 0;
884 /* use s->note_buf to store notes temporarily */
885 write_elf64_notes(buf_write_note
, s
, &local_err
);
887 error_propagate(errp
, local_err
);
891 if (write_buffer(s
->fd
, offset_note
, s
->note_buf
,
893 error_setg(errp
, "dump: failed to write notes");
897 /* get offset of dump_bitmap */
898 s
->offset_dump_bitmap
= (DISKDUMP_HEADER_BLOCKS
+ sub_hdr_size
) *
901 /* get offset of page */
902 s
->offset_page
= (DISKDUMP_HEADER_BLOCKS
+ sub_hdr_size
+ bitmap_blocks
) *
911 static void write_dump_header(DumpState
*s
, Error
**errp
)
913 Error
*local_err
= NULL
;
915 if (s
->dump_info
.d_class
== ELFCLASS32
) {
916 create_header32(s
, &local_err
);
918 create_header64(s
, &local_err
);
921 error_propagate(errp
, local_err
);
925 static size_t dump_bitmap_get_bufsize(DumpState
*s
)
927 return s
->dump_info
.page_size
;
931 * set dump_bitmap sequencely. the bit before last_pfn is not allowed to be
932 * rewritten, so if need to set the first bit, set last_pfn and pfn to 0.
933 * set_dump_bitmap will always leave the recently set bit un-sync. And setting
934 * (last bit + sizeof(buf) * 8) to 0 will do flushing the content in buf into
935 * vmcore, ie. synchronizing un-sync bit into vmcore.
937 static int set_dump_bitmap(uint64_t last_pfn
, uint64_t pfn
, bool value
,
938 uint8_t *buf
, DumpState
*s
)
940 off_t old_offset
, new_offset
;
941 off_t offset_bitmap1
, offset_bitmap2
;
943 size_t bitmap_bufsize
= dump_bitmap_get_bufsize(s
);
944 size_t bits_per_buf
= bitmap_bufsize
* CHAR_BIT
;
946 /* should not set the previous place */
947 assert(last_pfn
<= pfn
);
950 * if the bit needed to be set is not cached in buf, flush the data in buf
952 * making new_offset be bigger than old_offset can also sync remained data
955 old_offset
= bitmap_bufsize
* (last_pfn
/ bits_per_buf
);
956 new_offset
= bitmap_bufsize
* (pfn
/ bits_per_buf
);
958 while (old_offset
< new_offset
) {
959 /* calculate the offset and write dump_bitmap */
960 offset_bitmap1
= s
->offset_dump_bitmap
+ old_offset
;
961 if (write_buffer(s
->fd
, offset_bitmap1
, buf
,
962 bitmap_bufsize
) < 0) {
966 /* dump level 1 is chosen, so 1st and 2nd bitmap are same */
967 offset_bitmap2
= s
->offset_dump_bitmap
+ s
->len_dump_bitmap
+
969 if (write_buffer(s
->fd
, offset_bitmap2
, buf
,
970 bitmap_bufsize
) < 0) {
974 memset(buf
, 0, bitmap_bufsize
);
975 old_offset
+= bitmap_bufsize
;
978 /* get the exact place of the bit in the buf, and set it */
979 byte
= (pfn
% bits_per_buf
) / CHAR_BIT
;
980 bit
= (pfn
% bits_per_buf
) % CHAR_BIT
;
982 buf
[byte
] |= 1u << bit
;
984 buf
[byte
] &= ~(1u << bit
);
990 static uint64_t dump_paddr_to_pfn(DumpState
*s
, uint64_t addr
)
992 int target_page_shift
= ctz32(s
->dump_info
.page_size
);
994 return (addr
>> target_page_shift
) - ARCH_PFN_OFFSET
;
997 static uint64_t dump_pfn_to_paddr(DumpState
*s
, uint64_t pfn
)
999 int target_page_shift
= ctz32(s
->dump_info
.page_size
);
1001 return (pfn
+ ARCH_PFN_OFFSET
) << target_page_shift
;
1005 * exam every page and return the page frame number and the address of the page.
1006 * bufptr can be NULL. note: the blocks here is supposed to reflect guest-phys
1007 * blocks, so block->target_start and block->target_end should be interal
1008 * multiples of the target page size.
1010 static bool get_next_page(GuestPhysBlock
**blockptr
, uint64_t *pfnptr
,
1011 uint8_t **bufptr
, DumpState
*s
)
1013 GuestPhysBlock
*block
= *blockptr
;
1014 hwaddr addr
, target_page_mask
= ~((hwaddr
)s
->dump_info
.page_size
- 1);
1017 /* block == NULL means the start of the iteration */
1019 block
= QTAILQ_FIRST(&s
->guest_phys_blocks
.head
);
1021 assert((block
->target_start
& ~target_page_mask
) == 0);
1022 assert((block
->target_end
& ~target_page_mask
) == 0);
1023 *pfnptr
= dump_paddr_to_pfn(s
, block
->target_start
);
1025 *bufptr
= block
->host_addr
;
1030 *pfnptr
= *pfnptr
+ 1;
1031 addr
= dump_pfn_to_paddr(s
, *pfnptr
);
1033 if ((addr
>= block
->target_start
) &&
1034 (addr
+ s
->dump_info
.page_size
<= block
->target_end
)) {
1035 buf
= block
->host_addr
+ (addr
- block
->target_start
);
1037 /* the next page is in the next block */
1038 block
= QTAILQ_NEXT(block
, next
);
1043 assert((block
->target_start
& ~target_page_mask
) == 0);
1044 assert((block
->target_end
& ~target_page_mask
) == 0);
1045 *pfnptr
= dump_paddr_to_pfn(s
, block
->target_start
);
1046 buf
= block
->host_addr
;
1056 static void write_dump_bitmap(DumpState
*s
, Error
**errp
)
1059 uint64_t last_pfn
, pfn
;
1060 void *dump_bitmap_buf
;
1061 size_t num_dumpable
;
1062 GuestPhysBlock
*block_iter
= NULL
;
1063 size_t bitmap_bufsize
= dump_bitmap_get_bufsize(s
);
1064 size_t bits_per_buf
= bitmap_bufsize
* CHAR_BIT
;
1066 /* dump_bitmap_buf is used to store dump_bitmap temporarily */
1067 dump_bitmap_buf
= g_malloc0(bitmap_bufsize
);
1073 * exam memory page by page, and set the bit in dump_bitmap corresponded
1074 * to the existing page.
1076 while (get_next_page(&block_iter
, &pfn
, NULL
, s
)) {
1077 ret
= set_dump_bitmap(last_pfn
, pfn
, true, dump_bitmap_buf
, s
);
1079 error_setg(errp
, "dump: failed to set dump_bitmap");
1088 * set_dump_bitmap will always leave the recently set bit un-sync. Here we
1089 * set the remaining bits from last_pfn to the end of the bitmap buffer to
1090 * 0. With those set, the un-sync bit will be synchronized into the vmcore.
1092 if (num_dumpable
> 0) {
1093 ret
= set_dump_bitmap(last_pfn
, last_pfn
+ bits_per_buf
, false,
1094 dump_bitmap_buf
, s
);
1096 error_setg(errp
, "dump: failed to sync dump_bitmap");
1101 /* number of dumpable pages that will be dumped later */
1102 s
->num_dumpable
= num_dumpable
;
1105 g_free(dump_bitmap_buf
);
1108 static void prepare_data_cache(DataCache
*data_cache
, DumpState
*s
,
1111 data_cache
->fd
= s
->fd
;
1112 data_cache
->data_size
= 0;
1113 data_cache
->buf_size
= 4 * dump_bitmap_get_bufsize(s
);
1114 data_cache
->buf
= g_malloc0(data_cache
->buf_size
);
1115 data_cache
->offset
= offset
;
1118 static int write_cache(DataCache
*dc
, const void *buf
, size_t size
,
1122 * dc->buf_size should not be less than size, otherwise dc will never be
1125 assert(size
<= dc
->buf_size
);
1128 * if flag_sync is set, synchronize data in dc->buf into vmcore.
1129 * otherwise check if the space is enough for caching data in buf, if not,
1130 * write the data in dc->buf to dc->fd and reset dc->buf
1132 if ((!flag_sync
&& dc
->data_size
+ size
> dc
->buf_size
) ||
1133 (flag_sync
&& dc
->data_size
> 0)) {
1134 if (write_buffer(dc
->fd
, dc
->offset
, dc
->buf
, dc
->data_size
) < 0) {
1138 dc
->offset
+= dc
->data_size
;
1143 memcpy(dc
->buf
+ dc
->data_size
, buf
, size
);
1144 dc
->data_size
+= size
;
1150 static void free_data_cache(DataCache
*data_cache
)
1152 g_free(data_cache
->buf
);
1155 static size_t get_len_buf_out(size_t page_size
, uint32_t flag_compress
)
1157 switch (flag_compress
) {
1158 case DUMP_DH_COMPRESSED_ZLIB
:
1159 return compressBound(page_size
);
1161 case DUMP_DH_COMPRESSED_LZO
:
1163 * LZO will expand incompressible data by a little amount. Please check
1164 * the following URL to see the expansion calculation:
1165 * http://www.oberhumer.com/opensource/lzo/lzofaq.php
1167 return page_size
+ page_size
/ 16 + 64 + 3;
1169 #ifdef CONFIG_SNAPPY
1170 case DUMP_DH_COMPRESSED_SNAPPY
:
1171 return snappy_max_compressed_length(page_size
);
1178 * check if the page is all 0
1180 static inline bool is_zero_page(const uint8_t *buf
, size_t page_size
)
1182 return buffer_is_zero(buf
, page_size
);
1185 static void write_dump_pages(DumpState
*s
, Error
**errp
)
1188 DataCache page_desc
, page_data
;
1189 size_t len_buf_out
, size_out
;
1191 lzo_bytep wrkmem
= NULL
;
1193 uint8_t *buf_out
= NULL
;
1194 off_t offset_desc
, offset_data
;
1195 PageDescriptor pd
, pd_zero
;
1197 GuestPhysBlock
*block_iter
= NULL
;
1200 /* get offset of page_desc and page_data in dump file */
1201 offset_desc
= s
->offset_page
;
1202 offset_data
= offset_desc
+ sizeof(PageDescriptor
) * s
->num_dumpable
;
1204 prepare_data_cache(&page_desc
, s
, offset_desc
);
1205 prepare_data_cache(&page_data
, s
, offset_data
);
1207 /* prepare buffer to store compressed data */
1208 len_buf_out
= get_len_buf_out(s
->dump_info
.page_size
, s
->flag_compress
);
1209 assert(len_buf_out
!= 0);
1212 wrkmem
= g_malloc(LZO1X_1_MEM_COMPRESS
);
1215 buf_out
= g_malloc(len_buf_out
);
1218 * init zero page's page_desc and page_data, because every zero page
1219 * uses the same page_data
1221 pd_zero
.size
= cpu_to_dump32(s
, s
->dump_info
.page_size
);
1222 pd_zero
.flags
= cpu_to_dump32(s
, 0);
1223 pd_zero
.offset
= cpu_to_dump64(s
, offset_data
);
1224 pd_zero
.page_flags
= cpu_to_dump64(s
, 0);
1225 buf
= g_malloc0(s
->dump_info
.page_size
);
1226 ret
= write_cache(&page_data
, buf
, s
->dump_info
.page_size
, false);
1229 error_setg(errp
, "dump: failed to write page data (zero page)");
1233 offset_data
+= s
->dump_info
.page_size
;
1236 * dump memory to vmcore page by page. zero page will all be resided in the
1237 * first page of page section
1239 while (get_next_page(&block_iter
, &pfn_iter
, &buf
, s
)) {
1240 /* check zero page */
1241 if (is_zero_page(buf
, s
->dump_info
.page_size
)) {
1242 ret
= write_cache(&page_desc
, &pd_zero
, sizeof(PageDescriptor
),
1245 error_setg(errp
, "dump: failed to write page desc");
1250 * not zero page, then:
1251 * 1. compress the page
1252 * 2. write the compressed page into the cache of page_data
1253 * 3. get page desc of the compressed page and write it into the
1254 * cache of page_desc
1256 * only one compression format will be used here, for
1257 * s->flag_compress is set. But when compression fails to work,
1258 * we fall back to save in plaintext.
1260 size_out
= len_buf_out
;
1261 if ((s
->flag_compress
& DUMP_DH_COMPRESSED_ZLIB
) &&
1262 (compress2(buf_out
, (uLongf
*)&size_out
, buf
,
1263 s
->dump_info
.page_size
, Z_BEST_SPEED
) == Z_OK
) &&
1264 (size_out
< s
->dump_info
.page_size
)) {
1265 pd
.flags
= cpu_to_dump32(s
, DUMP_DH_COMPRESSED_ZLIB
);
1266 pd
.size
= cpu_to_dump32(s
, size_out
);
1268 ret
= write_cache(&page_data
, buf_out
, size_out
, false);
1270 error_setg(errp
, "dump: failed to write page data");
1274 } else if ((s
->flag_compress
& DUMP_DH_COMPRESSED_LZO
) &&
1275 (lzo1x_1_compress(buf
, s
->dump_info
.page_size
, buf_out
,
1276 (lzo_uint
*)&size_out
, wrkmem
) == LZO_E_OK
) &&
1277 (size_out
< s
->dump_info
.page_size
)) {
1278 pd
.flags
= cpu_to_dump32(s
, DUMP_DH_COMPRESSED_LZO
);
1279 pd
.size
= cpu_to_dump32(s
, size_out
);
1281 ret
= write_cache(&page_data
, buf_out
, size_out
, false);
1283 error_setg(errp
, "dump: failed to write page data");
1287 #ifdef CONFIG_SNAPPY
1288 } else if ((s
->flag_compress
& DUMP_DH_COMPRESSED_SNAPPY
) &&
1289 (snappy_compress((char *)buf
, s
->dump_info
.page_size
,
1290 (char *)buf_out
, &size_out
) == SNAPPY_OK
) &&
1291 (size_out
< s
->dump_info
.page_size
)) {
1292 pd
.flags
= cpu_to_dump32(s
, DUMP_DH_COMPRESSED_SNAPPY
);
1293 pd
.size
= cpu_to_dump32(s
, size_out
);
1295 ret
= write_cache(&page_data
, buf_out
, size_out
, false);
1297 error_setg(errp
, "dump: failed to write page data");
1303 * fall back to save in plaintext, size_out should be
1304 * assigned the target's page size
1306 pd
.flags
= cpu_to_dump32(s
, 0);
1307 size_out
= s
->dump_info
.page_size
;
1308 pd
.size
= cpu_to_dump32(s
, size_out
);
1310 ret
= write_cache(&page_data
, buf
,
1311 s
->dump_info
.page_size
, false);
1313 error_setg(errp
, "dump: failed to write page data");
1318 /* get and write page desc here */
1319 pd
.page_flags
= cpu_to_dump64(s
, 0);
1320 pd
.offset
= cpu_to_dump64(s
, offset_data
);
1321 offset_data
+= size_out
;
1323 ret
= write_cache(&page_desc
, &pd
, sizeof(PageDescriptor
), false);
1325 error_setg(errp
, "dump: failed to write page desc");
1329 s
->written_size
+= s
->dump_info
.page_size
;
1332 ret
= write_cache(&page_desc
, NULL
, 0, true);
1334 error_setg(errp
, "dump: failed to sync cache for page_desc");
1337 ret
= write_cache(&page_data
, NULL
, 0, true);
1339 error_setg(errp
, "dump: failed to sync cache for page_data");
1344 free_data_cache(&page_desc
);
1345 free_data_cache(&page_data
);
1354 static void create_kdump_vmcore(DumpState
*s
, Error
**errp
)
1357 Error
*local_err
= NULL
;
1360 * the kdump-compressed format is:
1362 * +------------------------------------------+ 0x0
1363 * | main header (struct disk_dump_header) |
1364 * |------------------------------------------+ block 1
1365 * | sub header (struct kdump_sub_header) |
1366 * |------------------------------------------+ block 2
1367 * | 1st-dump_bitmap |
1368 * |------------------------------------------+ block 2 + X blocks
1369 * | 2nd-dump_bitmap | (aligned by block)
1370 * |------------------------------------------+ block 2 + 2 * X blocks
1371 * | page desc for pfn 0 (struct page_desc) | (aligned by block)
1372 * | page desc for pfn 1 (struct page_desc) |
1374 * |------------------------------------------| (not aligned by block)
1375 * | page data (pfn 0) |
1376 * | page data (pfn 1) |
1378 * +------------------------------------------+
1381 ret
= write_start_flat_header(s
->fd
);
1383 error_setg(errp
, "dump: failed to write start flat header");
1387 write_dump_header(s
, &local_err
);
1389 error_propagate(errp
, local_err
);
1393 write_dump_bitmap(s
, &local_err
);
1395 error_propagate(errp
, local_err
);
1399 write_dump_pages(s
, &local_err
);
1401 error_propagate(errp
, local_err
);
1405 ret
= write_end_flat_header(s
->fd
);
1407 error_setg(errp
, "dump: failed to write end flat header");
1412 static ram_addr_t
get_start_block(DumpState
*s
)
1414 GuestPhysBlock
*block
;
1416 if (!s
->has_filter
) {
1417 s
->next_block
= QTAILQ_FIRST(&s
->guest_phys_blocks
.head
);
1421 QTAILQ_FOREACH(block
, &s
->guest_phys_blocks
.head
, next
) {
1422 if (block
->target_start
>= s
->begin
+ s
->length
||
1423 block
->target_end
<= s
->begin
) {
1424 /* This block is out of the range */
1428 s
->next_block
= block
;
1429 if (s
->begin
> block
->target_start
) {
1430 s
->start
= s
->begin
- block
->target_start
;
1440 static void get_max_mapnr(DumpState
*s
)
1442 GuestPhysBlock
*last_block
;
1444 last_block
= QTAILQ_LAST(&s
->guest_phys_blocks
.head
, GuestPhysBlockHead
);
1445 s
->max_mapnr
= dump_paddr_to_pfn(s
, last_block
->target_end
);
1448 static DumpState dump_state_global
= { .status
= DUMP_STATUS_NONE
};
1450 static void dump_state_prepare(DumpState
*s
)
1452 /* zero the struct, setting status to active */
1453 *s
= (DumpState
) { .status
= DUMP_STATUS_ACTIVE
};
1456 bool dump_in_progress(void)
1458 DumpState
*state
= &dump_state_global
;
1459 return (state
->status
== DUMP_STATUS_ACTIVE
);
1462 /* calculate total size of memory to be dumped (taking filter into
1464 static int64_t dump_calculate_size(DumpState
*s
)
1466 GuestPhysBlock
*block
;
1467 int64_t size
= 0, total
= 0, left
= 0, right
= 0;
1469 QTAILQ_FOREACH(block
, &s
->guest_phys_blocks
.head
, next
) {
1470 if (s
->has_filter
) {
1471 /* calculate the overlapped region. */
1472 left
= MAX(s
->begin
, block
->target_start
);
1473 right
= MIN(s
->begin
+ s
->length
, block
->target_end
);
1474 size
= right
- left
;
1475 size
= size
> 0 ? size
: 0;
1477 /* count the whole region in */
1478 size
= (block
->target_end
- block
->target_start
);
1486 static void dump_init(DumpState
*s
, int fd
, bool has_format
,
1487 DumpGuestMemoryFormat format
, bool paging
, bool has_filter
,
1488 int64_t begin
, int64_t length
, Error
**errp
)
1495 s
->has_format
= has_format
;
1497 s
->written_size
= 0;
1499 /* kdump-compressed is conflict with paging and filter */
1500 if (has_format
&& format
!= DUMP_GUEST_MEMORY_FORMAT_ELF
) {
1501 assert(!paging
&& !has_filter
);
1504 if (runstate_is_running()) {
1505 vm_stop(RUN_STATE_SAVE_VM
);
1511 /* If we use KVM, we should synchronize the registers before we get dump
1512 * info or physmap info.
1514 cpu_synchronize_all_states();
1521 s
->has_filter
= has_filter
;
1525 memory_mapping_list_init(&s
->list
);
1527 guest_phys_blocks_init(&s
->guest_phys_blocks
);
1528 guest_phys_blocks_append(&s
->guest_phys_blocks
);
1529 s
->total_size
= dump_calculate_size(s
);
1530 #ifdef DEBUG_DUMP_GUEST_MEMORY
1531 fprintf(stderr
, "DUMP: total memory to dump: %lu\n", s
->total_size
);
1534 s
->start
= get_start_block(s
);
1535 if (s
->start
== -1) {
1536 error_setg(errp
, QERR_INVALID_PARAMETER
, "begin");
1540 /* get dump info: endian, class and architecture.
1541 * If the target architecture is not supported, cpu_get_dump_info() will
1544 ret
= cpu_get_dump_info(&s
->dump_info
, &s
->guest_phys_blocks
);
1546 error_setg(errp
, QERR_UNSUPPORTED
);
1550 if (!s
->dump_info
.page_size
) {
1551 s
->dump_info
.page_size
= TARGET_PAGE_SIZE
;
1554 s
->note_size
= cpu_get_note_size(s
->dump_info
.d_class
,
1555 s
->dump_info
.d_machine
, nr_cpus
);
1556 if (s
->note_size
< 0) {
1557 error_setg(errp
, QERR_UNSUPPORTED
);
1561 /* get memory mapping */
1563 qemu_get_guest_memory_mapping(&s
->list
, &s
->guest_phys_blocks
, &err
);
1565 error_propagate(errp
, err
);
1569 qemu_get_guest_simple_memory_mapping(&s
->list
, &s
->guest_phys_blocks
);
1572 s
->nr_cpus
= nr_cpus
;
1577 tmp
= DIV_ROUND_UP(DIV_ROUND_UP(s
->max_mapnr
, CHAR_BIT
),
1578 s
->dump_info
.page_size
);
1579 s
->len_dump_bitmap
= tmp
* s
->dump_info
.page_size
;
1581 /* init for kdump-compressed format */
1582 if (has_format
&& format
!= DUMP_GUEST_MEMORY_FORMAT_ELF
) {
1584 case DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB
:
1585 s
->flag_compress
= DUMP_DH_COMPRESSED_ZLIB
;
1588 case DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO
:
1590 if (lzo_init() != LZO_E_OK
) {
1591 error_setg(errp
, "failed to initialize the LZO library");
1595 s
->flag_compress
= DUMP_DH_COMPRESSED_LZO
;
1598 case DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY
:
1599 s
->flag_compress
= DUMP_DH_COMPRESSED_SNAPPY
;
1603 s
->flag_compress
= 0;
1609 if (s
->has_filter
) {
1610 memory_mapping_filter(&s
->list
, s
->begin
, s
->length
);
1614 * calculate phdr_num
1616 * the type of ehdr->e_phnum is uint16_t, so we should avoid overflow
1618 s
->phdr_num
= 1; /* PT_NOTE */
1619 if (s
->list
.num
< UINT16_MAX
- 2) {
1620 s
->phdr_num
+= s
->list
.num
;
1621 s
->have_section
= false;
1623 s
->have_section
= true;
1624 s
->phdr_num
= PN_XNUM
;
1625 s
->sh_info
= 1; /* PT_NOTE */
1627 /* the type of shdr->sh_info is uint32_t, so we should avoid overflow */
1628 if (s
->list
.num
<= UINT32_MAX
- 1) {
1629 s
->sh_info
+= s
->list
.num
;
1631 s
->sh_info
= UINT32_MAX
;
1635 if (s
->dump_info
.d_class
== ELFCLASS64
) {
1636 if (s
->have_section
) {
1637 s
->memory_offset
= sizeof(Elf64_Ehdr
) +
1638 sizeof(Elf64_Phdr
) * s
->sh_info
+
1639 sizeof(Elf64_Shdr
) + s
->note_size
;
1641 s
->memory_offset
= sizeof(Elf64_Ehdr
) +
1642 sizeof(Elf64_Phdr
) * s
->phdr_num
+ s
->note_size
;
1645 if (s
->have_section
) {
1646 s
->memory_offset
= sizeof(Elf32_Ehdr
) +
1647 sizeof(Elf32_Phdr
) * s
->sh_info
+
1648 sizeof(Elf32_Shdr
) + s
->note_size
;
1650 s
->memory_offset
= sizeof(Elf32_Ehdr
) +
1651 sizeof(Elf32_Phdr
) * s
->phdr_num
+ s
->note_size
;
1661 /* this operation might be time consuming. */
1662 static void dump_process(DumpState
*s
, Error
**errp
)
1664 Error
*local_err
= NULL
;
1666 if (s
->has_format
&& s
->format
!= DUMP_GUEST_MEMORY_FORMAT_ELF
) {
1667 create_kdump_vmcore(s
, &local_err
);
1669 create_vmcore(s
, &local_err
);
1672 s
->status
= (local_err
? DUMP_STATUS_FAILED
: DUMP_STATUS_COMPLETED
);
1673 error_propagate(errp
, local_err
);
1678 static void *dump_thread(void *data
)
1681 DumpState
*s
= (DumpState
*)data
;
1683 dump_process(s
, &err
);
1686 /* TODO: notify user the error */
1692 void qmp_dump_guest_memory(bool paging
, const char *file
,
1693 bool has_detach
, bool detach
,
1694 bool has_begin
, int64_t begin
, bool has_length
,
1695 int64_t length
, bool has_format
,
1696 DumpGuestMemoryFormat format
, Error
**errp
)
1701 Error
*local_err
= NULL
;
1702 bool detach_p
= false;
1704 if (runstate_check(RUN_STATE_INMIGRATE
)) {
1705 error_setg(errp
, "Dump not allowed during incoming migration.");
1709 /* if there is a dump in background, we should wait until the dump
1711 if (dump_in_progress()) {
1712 error_setg(errp
, "There is a dump in process, please wait.");
1717 * kdump-compressed format need the whole memory dumped, so paging or
1718 * filter is not supported here.
1720 if ((has_format
&& format
!= DUMP_GUEST_MEMORY_FORMAT_ELF
) &&
1721 (paging
|| has_begin
|| has_length
)) {
1722 error_setg(errp
, "kdump-compressed format doesn't support paging or "
1726 if (has_begin
&& !has_length
) {
1727 error_setg(errp
, QERR_MISSING_PARAMETER
, "length");
1730 if (!has_begin
&& has_length
) {
1731 error_setg(errp
, QERR_MISSING_PARAMETER
, "begin");
1738 /* check whether lzo/snappy is supported */
1740 if (has_format
&& format
== DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO
) {
1741 error_setg(errp
, "kdump-lzo is not available now");
1746 #ifndef CONFIG_SNAPPY
1747 if (has_format
&& format
== DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY
) {
1748 error_setg(errp
, "kdump-snappy is not available now");
1754 if (strstart(file
, "fd:", &p
)) {
1755 fd
= monitor_get_fd(cur_mon
, p
, errp
);
1762 if (strstart(file
, "file:", &p
)) {
1763 fd
= qemu_open(p
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, S_IRUSR
);
1765 error_setg_file_open(errp
, errno
, p
);
1771 error_setg(errp
, QERR_INVALID_PARAMETER
, "protocol");
1775 s
= &dump_state_global
;
1776 dump_state_prepare(s
);
1778 dump_init(s
, fd
, has_format
, format
, paging
, has_begin
,
1779 begin
, length
, &local_err
);
1781 error_propagate(errp
, local_err
);
1782 s
->status
= DUMP_STATUS_FAILED
;
1788 qemu_thread_create(&s
->dump_thread
, "dump_thread", dump_thread
,
1789 s
, QEMU_THREAD_DETACHED
);
1792 dump_process(s
, errp
);
1796 DumpGuestMemoryCapability
*qmp_query_dump_guest_memory_capability(Error
**errp
)
1798 DumpGuestMemoryFormatList
*item
;
1799 DumpGuestMemoryCapability
*cap
=
1800 g_malloc0(sizeof(DumpGuestMemoryCapability
));
1802 /* elf is always available */
1803 item
= g_malloc0(sizeof(DumpGuestMemoryFormatList
));
1804 cap
->formats
= item
;
1805 item
->value
= DUMP_GUEST_MEMORY_FORMAT_ELF
;
1807 /* kdump-zlib is always available */
1808 item
->next
= g_malloc0(sizeof(DumpGuestMemoryFormatList
));
1810 item
->value
= DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB
;
1812 /* add new item if kdump-lzo is available */
1814 item
->next
= g_malloc0(sizeof(DumpGuestMemoryFormatList
));
1816 item
->value
= DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO
;
1819 /* add new item if kdump-snappy is available */
1820 #ifdef CONFIG_SNAPPY
1821 item
->next
= g_malloc0(sizeof(DumpGuestMemoryFormatList
));
1823 item
->value
= DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY
;