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