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. See
10 * the COPYING file in the top-level directory.
14 #include "qemu-common.h"
17 #include <sys/procfs.h>
27 #include "memory_mapping.h"
29 #include "qmp-commands.h"
32 static uint16_t cpu_convert_to_target16(uint16_t val
, int endian
)
34 if (endian
== ELFDATA2LSB
) {
35 val
= cpu_to_le16(val
);
37 val
= cpu_to_be16(val
);
43 static uint32_t cpu_convert_to_target32(uint32_t val
, int endian
)
45 if (endian
== ELFDATA2LSB
) {
46 val
= cpu_to_le32(val
);
48 val
= cpu_to_be32(val
);
54 static uint64_t cpu_convert_to_target64(uint64_t val
, int endian
)
56 if (endian
== ELFDATA2LSB
) {
57 val
= cpu_to_le64(val
);
59 val
= cpu_to_be64(val
);
65 typedef struct DumpState
{
66 ArchDumpInfo dump_info
;
67 MemoryMappingList list
;
73 target_phys_addr_t memory_offset
;
84 static int dump_cleanup(DumpState
*s
)
88 memory_mapping_list_free(&s
->list
);
99 static void dump_error(DumpState
*s
, const char *reason
)
104 static int fd_write_vmcore(void *buf
, size_t size
, void *opaque
)
106 DumpState
*s
= opaque
;
110 /* The fd may be passed from user, and it can be non-blocked */
112 writen_size
= qemu_write_full(fd
, buf
, size
);
113 if (writen_size
!= size
&& errno
!= EAGAIN
) {
124 static int write_elf64_header(DumpState
*s
)
126 Elf64_Ehdr elf_header
;
128 int endian
= s
->dump_info
.d_endian
;
130 memset(&elf_header
, 0, sizeof(Elf64_Ehdr
));
131 memcpy(&elf_header
, ELFMAG
, SELFMAG
);
132 elf_header
.e_ident
[EI_CLASS
] = ELFCLASS64
;
133 elf_header
.e_ident
[EI_DATA
] = s
->dump_info
.d_endian
;
134 elf_header
.e_ident
[EI_VERSION
] = EV_CURRENT
;
135 elf_header
.e_type
= cpu_convert_to_target16(ET_CORE
, endian
);
136 elf_header
.e_machine
= cpu_convert_to_target16(s
->dump_info
.d_machine
,
138 elf_header
.e_version
= cpu_convert_to_target32(EV_CURRENT
, endian
);
139 elf_header
.e_ehsize
= cpu_convert_to_target16(sizeof(elf_header
), endian
);
140 elf_header
.e_phoff
= cpu_convert_to_target64(sizeof(Elf64_Ehdr
), endian
);
141 elf_header
.e_phentsize
= cpu_convert_to_target16(sizeof(Elf64_Phdr
),
143 elf_header
.e_phnum
= cpu_convert_to_target16(s
->phdr_num
, endian
);
144 if (s
->have_section
) {
145 uint64_t shoff
= sizeof(Elf64_Ehdr
) + sizeof(Elf64_Phdr
) * s
->sh_info
;
147 elf_header
.e_shoff
= cpu_convert_to_target64(shoff
, endian
);
148 elf_header
.e_shentsize
= cpu_convert_to_target16(sizeof(Elf64_Shdr
),
150 elf_header
.e_shnum
= cpu_convert_to_target16(1, endian
);
153 ret
= fd_write_vmcore(&elf_header
, sizeof(elf_header
), s
);
155 dump_error(s
, "dump: failed to write elf header.\n");
162 static int write_elf32_header(DumpState
*s
)
164 Elf32_Ehdr elf_header
;
166 int endian
= s
->dump_info
.d_endian
;
168 memset(&elf_header
, 0, sizeof(Elf32_Ehdr
));
169 memcpy(&elf_header
, ELFMAG
, SELFMAG
);
170 elf_header
.e_ident
[EI_CLASS
] = ELFCLASS32
;
171 elf_header
.e_ident
[EI_DATA
] = endian
;
172 elf_header
.e_ident
[EI_VERSION
] = EV_CURRENT
;
173 elf_header
.e_type
= cpu_convert_to_target16(ET_CORE
, endian
);
174 elf_header
.e_machine
= cpu_convert_to_target16(s
->dump_info
.d_machine
,
176 elf_header
.e_version
= cpu_convert_to_target32(EV_CURRENT
, endian
);
177 elf_header
.e_ehsize
= cpu_convert_to_target16(sizeof(elf_header
), endian
);
178 elf_header
.e_phoff
= cpu_convert_to_target32(sizeof(Elf32_Ehdr
), endian
);
179 elf_header
.e_phentsize
= cpu_convert_to_target16(sizeof(Elf32_Phdr
),
181 elf_header
.e_phnum
= cpu_convert_to_target16(s
->phdr_num
, endian
);
182 if (s
->have_section
) {
183 uint32_t shoff
= sizeof(Elf32_Ehdr
) + sizeof(Elf32_Phdr
) * s
->sh_info
;
185 elf_header
.e_shoff
= cpu_convert_to_target32(shoff
, endian
);
186 elf_header
.e_shentsize
= cpu_convert_to_target16(sizeof(Elf32_Shdr
),
188 elf_header
.e_shnum
= cpu_convert_to_target16(1, endian
);
191 ret
= fd_write_vmcore(&elf_header
, sizeof(elf_header
), s
);
193 dump_error(s
, "dump: failed to write elf header.\n");
200 static int write_elf64_load(DumpState
*s
, MemoryMapping
*memory_mapping
,
201 int phdr_index
, target_phys_addr_t offset
)
205 int endian
= s
->dump_info
.d_endian
;
207 memset(&phdr
, 0, sizeof(Elf64_Phdr
));
208 phdr
.p_type
= cpu_convert_to_target32(PT_LOAD
, endian
);
209 phdr
.p_offset
= cpu_convert_to_target64(offset
, endian
);
210 phdr
.p_paddr
= cpu_convert_to_target64(memory_mapping
->phys_addr
, endian
);
212 /* When the memory is not stored into vmcore, offset will be -1 */
215 phdr
.p_filesz
= cpu_convert_to_target64(memory_mapping
->length
, endian
);
217 phdr
.p_memsz
= cpu_convert_to_target64(memory_mapping
->length
, endian
);
218 phdr
.p_vaddr
= cpu_convert_to_target64(memory_mapping
->virt_addr
, endian
);
220 ret
= fd_write_vmcore(&phdr
, sizeof(Elf64_Phdr
), s
);
222 dump_error(s
, "dump: failed to write program header table.\n");
229 static int write_elf32_load(DumpState
*s
, MemoryMapping
*memory_mapping
,
230 int phdr_index
, target_phys_addr_t offset
)
234 int endian
= s
->dump_info
.d_endian
;
236 memset(&phdr
, 0, sizeof(Elf32_Phdr
));
237 phdr
.p_type
= cpu_convert_to_target32(PT_LOAD
, endian
);
238 phdr
.p_offset
= cpu_convert_to_target32(offset
, endian
);
239 phdr
.p_paddr
= cpu_convert_to_target32(memory_mapping
->phys_addr
, endian
);
241 /* When the memory is not stored into vmcore, offset will be -1 */
244 phdr
.p_filesz
= cpu_convert_to_target32(memory_mapping
->length
, endian
);
246 phdr
.p_memsz
= cpu_convert_to_target32(memory_mapping
->length
, endian
);
247 phdr
.p_vaddr
= cpu_convert_to_target32(memory_mapping
->virt_addr
, endian
);
249 ret
= fd_write_vmcore(&phdr
, sizeof(Elf32_Phdr
), s
);
251 dump_error(s
, "dump: failed to write program header table.\n");
258 static int write_elf64_note(DumpState
*s
)
261 int endian
= s
->dump_info
.d_endian
;
262 target_phys_addr_t begin
= s
->memory_offset
- s
->note_size
;
265 memset(&phdr
, 0, sizeof(Elf64_Phdr
));
266 phdr
.p_type
= cpu_convert_to_target32(PT_NOTE
, endian
);
267 phdr
.p_offset
= cpu_convert_to_target64(begin
, endian
);
269 phdr
.p_filesz
= cpu_convert_to_target64(s
->note_size
, endian
);
270 phdr
.p_memsz
= cpu_convert_to_target64(s
->note_size
, endian
);
273 ret
= fd_write_vmcore(&phdr
, sizeof(Elf64_Phdr
), s
);
275 dump_error(s
, "dump: failed to write program header table.\n");
282 static int write_elf64_notes(DumpState
*s
)
288 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
290 ret
= cpu_write_elf64_note(fd_write_vmcore
, env
, id
, s
);
292 dump_error(s
, "dump: failed to write elf notes.\n");
297 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
298 ret
= cpu_write_elf64_qemunote(fd_write_vmcore
, env
, s
);
300 dump_error(s
, "dump: failed to write CPU status.\n");
308 static int write_elf32_note(DumpState
*s
)
310 target_phys_addr_t begin
= s
->memory_offset
- s
->note_size
;
312 int endian
= s
->dump_info
.d_endian
;
315 memset(&phdr
, 0, sizeof(Elf32_Phdr
));
316 phdr
.p_type
= cpu_convert_to_target32(PT_NOTE
, endian
);
317 phdr
.p_offset
= cpu_convert_to_target32(begin
, endian
);
319 phdr
.p_filesz
= cpu_convert_to_target32(s
->note_size
, endian
);
320 phdr
.p_memsz
= cpu_convert_to_target32(s
->note_size
, endian
);
323 ret
= fd_write_vmcore(&phdr
, sizeof(Elf32_Phdr
), s
);
325 dump_error(s
, "dump: failed to write program header table.\n");
332 static int write_elf32_notes(DumpState
*s
)
338 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
340 ret
= cpu_write_elf32_note(fd_write_vmcore
, env
, id
, s
);
342 dump_error(s
, "dump: failed to write elf notes.\n");
347 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
348 ret
= cpu_write_elf32_qemunote(fd_write_vmcore
, env
, s
);
350 dump_error(s
, "dump: failed to write CPU status.\n");
358 static int write_elf_section(DumpState
*s
, int type
)
362 int endian
= s
->dump_info
.d_endian
;
368 shdr_size
= sizeof(Elf32_Shdr
);
369 memset(&shdr32
, 0, shdr_size
);
370 shdr32
.sh_info
= cpu_convert_to_target32(s
->sh_info
, endian
);
373 shdr_size
= sizeof(Elf64_Shdr
);
374 memset(&shdr64
, 0, shdr_size
);
375 shdr64
.sh_info
= cpu_convert_to_target32(s
->sh_info
, endian
);
379 ret
= fd_write_vmcore(&shdr
, shdr_size
, s
);
381 dump_error(s
, "dump: failed to write section header table.\n");
388 static int write_data(DumpState
*s
, void *buf
, int length
)
392 ret
= fd_write_vmcore(buf
, length
, s
);
394 dump_error(s
, "dump: failed to save memory.\n");
401 /* write the memroy to vmcore. 1 page per I/O. */
402 static int write_memory(DumpState
*s
, RAMBlock
*block
, ram_addr_t start
,
408 for (i
= 0; i
< size
/ TARGET_PAGE_SIZE
; i
++) {
409 ret
= write_data(s
, block
->host
+ start
+ i
* TARGET_PAGE_SIZE
,
416 if ((size
% TARGET_PAGE_SIZE
) != 0) {
417 ret
= write_data(s
, block
->host
+ start
+ i
* TARGET_PAGE_SIZE
,
418 size
% TARGET_PAGE_SIZE
);
427 /* get the memory's offset in the vmcore */
428 static target_phys_addr_t
get_offset(target_phys_addr_t phys_addr
,
432 target_phys_addr_t offset
= s
->memory_offset
;
433 int64_t size_in_block
, start
;
436 if (phys_addr
< s
->begin
|| phys_addr
>= s
->begin
+ s
->length
) {
441 QLIST_FOREACH(block
, &ram_list
.blocks
, next
) {
443 if (block
->offset
>= s
->begin
+ s
->length
||
444 block
->offset
+ block
->length
<= s
->begin
) {
445 /* This block is out of the range */
449 if (s
->begin
<= block
->offset
) {
450 start
= block
->offset
;
455 size_in_block
= block
->length
- (start
- block
->offset
);
456 if (s
->begin
+ s
->length
< block
->offset
+ block
->length
) {
457 size_in_block
-= block
->offset
+ block
->length
-
458 (s
->begin
+ s
->length
);
461 start
= block
->offset
;
462 size_in_block
= block
->length
;
465 if (phys_addr
>= start
&& phys_addr
< start
+ size_in_block
) {
466 return phys_addr
- start
+ offset
;
469 offset
+= size_in_block
;
475 static int write_elf_loads(DumpState
*s
)
477 target_phys_addr_t offset
;
478 MemoryMapping
*memory_mapping
;
479 uint32_t phdr_index
= 1;
483 if (s
->have_section
) {
484 max_index
= s
->sh_info
;
486 max_index
= s
->phdr_num
;
489 QTAILQ_FOREACH(memory_mapping
, &s
->list
.head
, next
) {
490 offset
= get_offset(memory_mapping
->phys_addr
, s
);
491 if (s
->dump_info
.d_class
== ELFCLASS64
) {
492 ret
= write_elf64_load(s
, memory_mapping
, phdr_index
++, offset
);
494 ret
= write_elf32_load(s
, memory_mapping
, phdr_index
++, offset
);
501 if (phdr_index
>= max_index
) {
509 /* write elf header, PT_NOTE and elf note to vmcore. */
510 static int dump_begin(DumpState
*s
)
515 * the vmcore's format is:
534 * we only know where the memory is saved after we write elf note into
538 /* write elf header to vmcore */
539 if (s
->dump_info
.d_class
== ELFCLASS64
) {
540 ret
= write_elf64_header(s
);
542 ret
= write_elf32_header(s
);
548 if (s
->dump_info
.d_class
== ELFCLASS64
) {
549 /* write PT_NOTE to vmcore */
550 if (write_elf64_note(s
) < 0) {
554 /* write all PT_LOAD to vmcore */
555 if (write_elf_loads(s
) < 0) {
559 /* write section to vmcore */
560 if (s
->have_section
) {
561 if (write_elf_section(s
, 1) < 0) {
566 /* write notes to vmcore */
567 if (write_elf64_notes(s
) < 0) {
572 /* write PT_NOTE to vmcore */
573 if (write_elf32_note(s
) < 0) {
577 /* write all PT_LOAD to vmcore */
578 if (write_elf_loads(s
) < 0) {
582 /* write section to vmcore */
583 if (s
->have_section
) {
584 if (write_elf_section(s
, 0) < 0) {
589 /* write notes to vmcore */
590 if (write_elf32_notes(s
) < 0) {
598 /* write PT_LOAD to vmcore */
599 static int dump_completed(DumpState
*s
)
605 static int get_next_block(DumpState
*s
, RAMBlock
*block
)
608 block
= QLIST_NEXT(block
, next
);
617 if (block
->offset
>= s
->begin
+ s
->length
||
618 block
->offset
+ block
->length
<= s
->begin
) {
619 /* This block is out of the range */
623 if (s
->begin
> block
->offset
) {
624 s
->start
= s
->begin
- block
->offset
;
632 /* write all memory to vmcore */
633 static int dump_iterate(DumpState
*s
)
642 size
= block
->length
;
645 if (s
->begin
+ s
->length
< block
->offset
+ block
->length
) {
646 size
-= block
->offset
+ block
->length
- (s
->begin
+ s
->length
);
649 ret
= write_memory(s
, block
, s
->start
, size
);
654 ret
= get_next_block(s
, block
);
662 static int create_vmcore(DumpState
*s
)
671 ret
= dump_iterate(s
);
679 static ram_addr_t
get_start_block(DumpState
*s
)
683 if (!s
->has_filter
) {
684 s
->block
= QLIST_FIRST(&ram_list
.blocks
);
688 QLIST_FOREACH(block
, &ram_list
.blocks
, next
) {
689 if (block
->offset
>= s
->begin
+ s
->length
||
690 block
->offset
+ block
->length
<= s
->begin
) {
691 /* This block is out of the range */
696 if (s
->begin
> block
->offset
) {
697 s
->start
= s
->begin
- block
->offset
;
707 static int dump_init(DumpState
*s
, int fd
, bool paging
, bool has_filter
,
708 int64_t begin
, int64_t length
, Error
**errp
)
714 if (runstate_is_running()) {
715 vm_stop(RUN_STATE_SAVE_VM
);
723 s
->has_filter
= has_filter
;
726 s
->start
= get_start_block(s
);
727 if (s
->start
== -1) {
728 error_set(errp
, QERR_INVALID_PARAMETER
, "begin");
733 * get dump info: endian, class and architecture.
734 * If the target architecture is not supported, cpu_get_dump_info() will
737 * if we use kvm, we should synchronize the register before we get dump
741 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
742 cpu_synchronize_state(env
);
746 ret
= cpu_get_dump_info(&s
->dump_info
);
748 error_set(errp
, QERR_UNSUPPORTED
);
752 s
->note_size
= cpu_get_note_size(s
->dump_info
.d_class
,
753 s
->dump_info
.d_machine
, nr_cpus
);
755 error_set(errp
, QERR_UNSUPPORTED
);
759 /* get memory mapping */
760 memory_mapping_list_init(&s
->list
);
762 qemu_get_guest_memory_mapping(&s
->list
);
764 qemu_get_guest_simple_memory_mapping(&s
->list
);
768 memory_mapping_filter(&s
->list
, s
->begin
, s
->length
);
774 * the type of ehdr->e_phnum is uint16_t, so we should avoid overflow
776 s
->phdr_num
= 1; /* PT_NOTE */
777 if (s
->list
.num
< UINT16_MAX
- 2) {
778 s
->phdr_num
+= s
->list
.num
;
779 s
->have_section
= false;
781 s
->have_section
= true;
782 s
->phdr_num
= PN_XNUM
;
783 s
->sh_info
= 1; /* PT_NOTE */
785 /* the type of shdr->sh_info is uint32_t, so we should avoid overflow */
786 if (s
->list
.num
<= UINT32_MAX
- 1) {
787 s
->sh_info
+= s
->list
.num
;
789 s
->sh_info
= UINT32_MAX
;
793 if (s
->dump_info
.d_class
== ELFCLASS64
) {
794 if (s
->have_section
) {
795 s
->memory_offset
= sizeof(Elf64_Ehdr
) +
796 sizeof(Elf64_Phdr
) * s
->sh_info
+
797 sizeof(Elf64_Shdr
) + s
->note_size
;
799 s
->memory_offset
= sizeof(Elf64_Ehdr
) +
800 sizeof(Elf64_Phdr
) * s
->phdr_num
+ s
->note_size
;
803 if (s
->have_section
) {
804 s
->memory_offset
= sizeof(Elf32_Ehdr
) +
805 sizeof(Elf32_Phdr
) * s
->sh_info
+
806 sizeof(Elf32_Shdr
) + s
->note_size
;
808 s
->memory_offset
= sizeof(Elf32_Ehdr
) +
809 sizeof(Elf32_Phdr
) * s
->phdr_num
+ s
->note_size
;
823 void qmp_dump_guest_memory(bool paging
, const char *file
, bool has_begin
,
824 int64_t begin
, bool has_length
, int64_t length
,
832 if (has_begin
&& !has_length
) {
833 error_set(errp
, QERR_MISSING_PARAMETER
, "length");
836 if (!has_begin
&& has_length
) {
837 error_set(errp
, QERR_MISSING_PARAMETER
, "begin");
842 if (strstart(file
, "fd:", &p
)) {
843 fd
= monitor_get_fd(cur_mon
, p
);
845 error_set(errp
, QERR_FD_NOT_FOUND
, p
);
851 if (strstart(file
, "file:", &p
)) {
852 fd
= qemu_open(p
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, S_IRUSR
);
854 error_set(errp
, QERR_OPEN_FILE_FAILED
, p
);
860 error_set(errp
, QERR_INVALID_PARAMETER
, "protocol");
864 s
= g_malloc(sizeof(DumpState
));
866 ret
= dump_init(s
, fd
, paging
, has_begin
, begin
, length
, errp
);
872 if (create_vmcore(s
) < 0 && !error_is_set(s
->errp
)) {
873 error_set(errp
, QERR_IO_ERROR
);