1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
/*
* writing ELF notes for s390x arch
*
*
* Copyright IBM Corp. 2012, 2013
*
* Ekaterina Tumanova <tumanova@linux.vnet.ibm.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*
*/
#include "cpu.h"
#include "elf.h"
#include "exec/cpu-all.h"
#include "sysemu/dump.h"
#include "sysemu/kvm.h"
struct S390xUserRegsStruct {
uint64_t psw[2];
uint64_t gprs[16];
uint32_t acrs[16];
} QEMU_PACKED;
typedef struct S390xUserRegsStruct S390xUserRegs;
struct S390xElfPrstatusStruct {
uint8_t pad1[32];
uint32_t pid;
uint8_t pad2[76];
S390xUserRegs regs;
uint8_t pad3[16];
} QEMU_PACKED;
typedef struct S390xElfPrstatusStruct S390xElfPrstatus;
struct S390xElfFpregsetStruct {
uint32_t fpc;
uint32_t pad;
uint64_t fprs[16];
} QEMU_PACKED;
typedef struct S390xElfFpregsetStruct S390xElfFpregset;
typedef struct noteStruct {
Elf64_Nhdr hdr;
char name[5];
char pad3[3];
union {
S390xElfPrstatus prstatus;
S390xElfFpregset fpregset;
uint32_t prefix;
uint64_t timer;
uint64_t todcmp;
uint32_t todpreg;
uint64_t ctrs[16];
} contents;
} QEMU_PACKED Note;
static void s390x_write_elf64_prstatus(Note *note, S390CPU *cpu)
{
int i;
S390xUserRegs *regs;
note->hdr.n_type = cpu_to_be32(NT_PRSTATUS);
regs = &(note->contents.prstatus.regs);
regs->psw[0] = cpu_to_be64(cpu->env.psw.mask);
regs->psw[1] = cpu_to_be64(cpu->env.psw.addr);
for (i = 0; i <= 15; i++) {
regs->acrs[i] = cpu_to_be32(cpu->env.aregs[i]);
regs->gprs[i] = cpu_to_be64(cpu->env.regs[i]);
}
}
static void s390x_write_elf64_fpregset(Note *note, S390CPU *cpu)
{
int i;
note->hdr.n_type = cpu_to_be32(NT_FPREGSET);
note->contents.fpregset.fpc = cpu_to_be32(cpu->env.fpc);
for (i = 0; i <= 15; i++) {
note->contents.fpregset.fprs[i] = cpu_to_be64(cpu->env.fregs[i].ll);
}
}
static void s390x_write_elf64_timer(Note *note, S390CPU *cpu)
{
note->hdr.n_type = cpu_to_be32(NT_S390_TIMER);
note->contents.timer = cpu_to_be64((uint64_t)(cpu->env.cputm));
}
static void s390x_write_elf64_todcmp(Note *note, S390CPU *cpu)
{
note->hdr.n_type = cpu_to_be32(NT_S390_TODCMP);
note->contents.todcmp = cpu_to_be64((uint64_t)(cpu->env.ckc));
}
static void s390x_write_elf64_todpreg(Note *note, S390CPU *cpu)
{
note->hdr.n_type = cpu_to_be32(NT_S390_TODPREG);
note->contents.todpreg = cpu_to_be32((uint32_t)(cpu->env.todpr));
}
static void s390x_write_elf64_ctrs(Note *note, S390CPU *cpu)
{
int i;
note->hdr.n_type = cpu_to_be32(NT_S390_CTRS);
for (i = 0; i <= 15; i++) {
note->contents.ctrs[i] = cpu_to_be64(cpu->env.cregs[i]);
}
}
static void s390x_write_elf64_prefix(Note *note, S390CPU *cpu)
{
note->hdr.n_type = cpu_to_be32(NT_S390_PREFIX);
note->contents.prefix = cpu_to_be32((uint32_t)(cpu->env.psa));
}
struct NoteFuncDescStruct {
int contents_size;
void (*note_contents_func)(Note *note, S390CPU *cpu);
} note_func[] = {
{sizeof(((Note *)0)->contents.prstatus), s390x_write_elf64_prstatus},
{sizeof(((Note *)0)->contents.prefix), s390x_write_elf64_prefix},
{sizeof(((Note *)0)->contents.fpregset), s390x_write_elf64_fpregset},
{sizeof(((Note *)0)->contents.ctrs), s390x_write_elf64_ctrs},
{sizeof(((Note *)0)->contents.timer), s390x_write_elf64_timer},
{sizeof(((Note *)0)->contents.todcmp), s390x_write_elf64_todcmp},
{sizeof(((Note *)0)->contents.todpreg), s390x_write_elf64_todpreg},
{ 0, NULL}
};
typedef struct NoteFuncDescStruct NoteFuncDesc;
static int s390x_write_all_elf64_notes(const char *note_name,
WriteCoreDumpFunction f,
S390CPU *cpu, int id,
void *opaque)
{
Note note;
NoteFuncDesc *nf;
int note_size;
int ret = -1;
for (nf = note_func; nf->note_contents_func; nf++) {
memset(¬e, 0, sizeof(note));
note.hdr.n_namesz = cpu_to_be32(sizeof(note.name));
note.hdr.n_descsz = cpu_to_be32(nf->contents_size);
strncpy(note.name, note_name, sizeof(note.name));
(*nf->note_contents_func)(¬e, cpu);
note_size = sizeof(note) - sizeof(note.contents) + nf->contents_size;
ret = f(¬e, note_size, opaque);
if (ret < 0) {
return -1;
}
}
return 0;
}
int s390_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
int cpuid, void *opaque)
{
S390CPU *cpu = S390_CPU(cs);
return s390x_write_all_elf64_notes("CORE", f, cpu, cpuid, opaque);
}
int cpu_get_dump_info(ArchDumpInfo *info,
const struct GuestPhysBlockList *guest_phys_blocks)
{
info->d_machine = EM_S390;
info->d_endian = ELFDATA2MSB;
info->d_class = ELFCLASS64;
return 0;
}
ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
{
int name_size = 8; /* "CORE" or "QEMU" rounded */
size_t elf_note_size = 0;
int note_head_size;
NoteFuncDesc *nf;
assert(class == ELFCLASS64);
assert(machine == EM_S390);
note_head_size = sizeof(Elf64_Nhdr);
for (nf = note_func; nf->note_contents_func; nf++) {
elf_note_size = elf_note_size + note_head_size + name_size +
nf->contents_size;
}
return (elf_note_size) * nr_cpus;
}
int s390_cpu_write_elf64_qemunote(WriteCoreDumpFunction f,
CPUState *cpu, void *opaque)
{
return 0;
}
|
