target/s390x/arch_dump.c

   1 /*
   2  * writing ELF notes for s390x arch
   3  *
   4  *
   5  * Copyright IBM Corp. 2012, 2013
   6  *
   7  *     Ekaterina Tumanova <tumanova@linux.vnet.ibm.com>
   8  *
   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.
  11  *
  12  */
  13
  14 #include "qemu/osdep.h"
  15 #include "cpu.h"
  16 #include "internal.h"
  17 #include "elf.h"
  18 #include "exec/cpu-all.h"
  19 #include "sysemu/dump.h"
  20
  21
  22 struct S390xUserRegsStruct {
  23     uint64_t psw[2];
  24     uint64_t gprs[16];
  25     uint32_t acrs[16];
  26 } QEMU_PACKED;
  27
  28 typedef struct S390xUserRegsStruct S390xUserRegs;
  29
  30 struct S390xElfPrstatusStruct {
  31     uint8_t pad1[32];
  32     uint32_t pid;
  33     uint8_t pad2[76];
  34     S390xUserRegs regs;
  35     uint8_t pad3[16];
  36 } QEMU_PACKED;
  37
  38 typedef struct S390xElfPrstatusStruct S390xElfPrstatus;
  39
  40 struct S390xElfFpregsetStruct {
  41     uint32_t fpc;
  42     uint32_t pad;
  43     uint64_t fprs[16];
  44 } QEMU_PACKED;
  45
  46 typedef struct S390xElfFpregsetStruct S390xElfFpregset;
  47
  48 struct S390xElfVregsLoStruct {
  49     uint64_t vregs[16];
  50 } QEMU_PACKED;
  51
  52 typedef struct S390xElfVregsLoStruct S390xElfVregsLo;
  53
  54 struct S390xElfVregsHiStruct {
  55     uint64_t vregs[16][2];
  56 } QEMU_PACKED;
  57
  58 typedef struct S390xElfVregsHiStruct S390xElfVregsHi;
  59
  60 struct S390xElfGSCBStruct {
  61     uint64_t gsregs[4];
  62 } QEMU_PACKED;
  63
  64 typedef struct S390xElfGSCBStruct S390xElfGSCB;
  65
  66 typedef struct noteStruct {
  67     Elf64_Nhdr hdr;
  68     char name[8];
  69     union {
  70         S390xElfPrstatus prstatus;
  71         S390xElfFpregset fpregset;
  72         S390xElfVregsLo vregslo;
  73         S390xElfVregsHi vregshi;
  74         S390xElfGSCB gscb;
  75         uint32_t prefix;
  76         uint64_t timer;
  77         uint64_t todcmp;
  78         uint32_t todpreg;
  79         uint64_t ctrs[16];
  80     } contents;
  81 } QEMU_PACKED Note;
  82
  83 static void s390x_write_elf64_prstatus(Note *note, S390CPU *cpu, int id)
  84 {
  85     int i;
  86     S390xUserRegs *regs;
  87
  88     note->hdr.n_type = cpu_to_be32(NT_PRSTATUS);
  89
  90     regs = &(note->contents.prstatus.regs);
  91     regs->psw[0] = cpu_to_be64(cpu->env.psw.mask);
  92     regs->psw[1] = cpu_to_be64(cpu->env.psw.addr);
  93     for (i = 0; i <= 15; i++) {
  94         regs->acrs[i] = cpu_to_be32(cpu->env.aregs[i]);
  95         regs->gprs[i] = cpu_to_be64(cpu->env.regs[i]);
  96     }
  97     note->contents.prstatus.pid = id;
  98 }
  99
 100 static void s390x_write_elf64_fpregset(Note *note, S390CPU *cpu, int id)
 101 {
 102     int i;
 103     CPUS390XState *cs = &cpu->env;
 104
 105     note->hdr.n_type = cpu_to_be32(NT_FPREGSET);
 106     note->contents.fpregset.fpc = cpu_to_be32(cpu->env.fpc);
 107     for (i = 0; i <= 15; i++) {
 108         note->contents.fpregset.fprs[i] = cpu_to_be64(get_freg(cs, i)->ll);
 109     }
 110 }
 111
 112 static void s390x_write_elf64_vregslo(Note *note, S390CPU *cpu,  int id)
 113 {
 114     int i;
 115
 116     note->hdr.n_type = cpu_to_be32(NT_S390_VXRS_LOW);
 117     for (i = 0; i <= 15; i++) {
 118         note->contents.vregslo.vregs[i] = cpu_to_be64(cpu->env.vregs[i][1].ll);
 119     }
 120 }
 121
 122 static void s390x_write_elf64_vregshi(Note *note, S390CPU *cpu, int id)
 123 {
 124     int i;
 125     S390xElfVregsHi *temp_vregshi;
 126
 127     temp_vregshi = &note->contents.vregshi;
 128
 129     note->hdr.n_type = cpu_to_be32(NT_S390_VXRS_HIGH);
 130     for (i = 0; i <= 15; i++) {
 131         temp_vregshi->vregs[i][0] = cpu_to_be64(cpu->env.vregs[i + 16][0].ll);
 132         temp_vregshi->vregs[i][1] = cpu_to_be64(cpu->env.vregs[i + 16][1].ll);
 133     }
 134 }
 135
 136 static void s390x_write_elf64_gscb(Note *note, S390CPU *cpu, int id)
 137 {
 138     int i;
 139
 140     note->hdr.n_type = cpu_to_be32(NT_S390_GS_CB);
 141     for (i = 0; i < 4; i++) {
 142         note->contents.gscb.gsregs[i] = cpu_to_be64(cpu->env.gscb[i]);
 143     }
 144 }
 145
 146 static void s390x_write_elf64_timer(Note *note, S390CPU *cpu, int id)
 147 {
 148     note->hdr.n_type = cpu_to_be32(NT_S390_TIMER);
 149     note->contents.timer = cpu_to_be64((uint64_t)(cpu->env.cputm));
 150 }
 151
 152 static void s390x_write_elf64_todcmp(Note *note, S390CPU *cpu, int id)
 153 {
 154     note->hdr.n_type = cpu_to_be32(NT_S390_TODCMP);
 155     note->contents.todcmp = cpu_to_be64((uint64_t)(cpu->env.ckc));
 156 }
 157
 158 static void s390x_write_elf64_todpreg(Note *note, S390CPU *cpu, int id)
 159 {
 160     note->hdr.n_type = cpu_to_be32(NT_S390_TODPREG);
 161     note->contents.todpreg = cpu_to_be32((uint32_t)(cpu->env.todpr));
 162 }
 163
 164 static void s390x_write_elf64_ctrs(Note *note, S390CPU *cpu, int id)
 165 {
 166     int i;
 167
 168     note->hdr.n_type = cpu_to_be32(NT_S390_CTRS);
 169
 170     for (i = 0; i <= 15; i++) {
 171         note->contents.ctrs[i] = cpu_to_be64(cpu->env.cregs[i]);
 172     }
 173 }
 174
 175 static void s390x_write_elf64_prefix(Note *note, S390CPU *cpu, int id)
 176 {
 177     note->hdr.n_type = cpu_to_be32(NT_S390_PREFIX);
 178     note->contents.prefix = cpu_to_be32((uint32_t)(cpu->env.psa));
 179 }
 180
 181
 182 typedef struct NoteFuncDescStruct {
 183     int contents_size;
 184     void (*note_contents_func)(Note *note, S390CPU *cpu, int id);
 185 } NoteFuncDesc;
 186
 187 static const NoteFuncDesc note_core[] = {
 188     {sizeof(((Note *)0)->contents.prstatus), s390x_write_elf64_prstatus},
 189     {sizeof(((Note *)0)->contents.fpregset), s390x_write_elf64_fpregset},
 190     { 0, NULL}
 191 };
 192
 193 static const NoteFuncDesc note_linux[] = {
 194     {sizeof(((Note *)0)->contents.prefix),   s390x_write_elf64_prefix},
 195     {sizeof(((Note *)0)->contents.ctrs),     s390x_write_elf64_ctrs},
 196     {sizeof(((Note *)0)->contents.timer),    s390x_write_elf64_timer},
 197     {sizeof(((Note *)0)->contents.todcmp),   s390x_write_elf64_todcmp},
 198     {sizeof(((Note *)0)->contents.todpreg),  s390x_write_elf64_todpreg},
 199     {sizeof(((Note *)0)->contents.vregslo),  s390x_write_elf64_vregslo},
 200     {sizeof(((Note *)0)->contents.vregshi),  s390x_write_elf64_vregshi},
 201     {sizeof(((Note *)0)->contents.gscb),     s390x_write_elf64_gscb},
 202     { 0, NULL}
 203 };
 204
 205 static int s390x_write_elf64_notes(const char *note_name,
 206                                        WriteCoreDumpFunction f,
 207                                        S390CPU *cpu, int id,
 208                                        void *opaque,
 209                                        const NoteFuncDesc *funcs)
 210 {
 211     Note note;
 212     const NoteFuncDesc *nf;
 213     int note_size;
 214     int ret = -1;
 215
 216     for (nf = funcs; nf->note_contents_func; nf++) {
 217         memset(&note, 0, sizeof(note));
 218         note.hdr.n_namesz = cpu_to_be32(strlen(note_name) + 1);
 219         note.hdr.n_descsz = cpu_to_be32(nf->contents_size);
 220         strncpy(note.name, note_name, sizeof(note.name));
 221         (*nf->note_contents_func)(&note, cpu, id);
 222
 223         note_size = sizeof(note) - sizeof(note.contents) + nf->contents_size;
 224         ret = f(&note, note_size, opaque);
 225
 226         if (ret < 0) {
 227             return -1;
 228         }
 229
 230     }
 231
 232     return 0;
 233 }
 234
 235
 236 int s390_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
 237                               int cpuid, void *opaque)
 238 {
 239     S390CPU *cpu = S390_CPU(cs);
 240     int r;
 241
 242     r = s390x_write_elf64_notes("CORE", f, cpu, cpuid, opaque, note_core);
 243     if (r) {
 244         return r;
 245     }
 246     return s390x_write_elf64_notes("LINUX", f, cpu, cpuid, opaque, note_linux);
 247 }
 248
 249 int cpu_get_dump_info(ArchDumpInfo *info,
 250                       const struct GuestPhysBlockList *guest_phys_blocks)
 251 {
 252     info->d_machine = EM_S390;
 253     info->d_endian = ELFDATA2MSB;
 254     info->d_class = ELFCLASS64;
 255
 256     return 0;
 257 }
 258
 259 ssize_t cpu_get_note_size(int class, int machine, int nr_cpus)
 260 {
 261     int name_size = 8; /* "LINUX" or "CORE" + pad */
 262     size_t elf_note_size = 0;
 263     int note_head_size;
 264     const NoteFuncDesc *nf;
 265
 266     assert(class == ELFCLASS64);
 267     assert(machine == EM_S390);
 268
 269     note_head_size = sizeof(Elf64_Nhdr);
 270
 271     for (nf = note_core; nf->note_contents_func; nf++) {
 272         elf_note_size = elf_note_size + note_head_size + name_size +
 273                         nf->contents_size;
 274     }
 275     for (nf = note_linux; nf->note_contents_func; nf++) {
 276         elf_note_size = elf_note_size + note_head_size + name_size +
 277                         nf->contents_size;
 278     }
 279
 280     return (elf_note_size) * nr_cpus;
 281 }