Commit dbef7b17 authored by Anthony Liguori's avatar Anthony Liguori
Browse files

Merge remote-tracking branch 'borntraeger/s390-for-1.6' into staging 



* borntraeger/s390-for-1.6:
  s390: Implement dump-guest-memory support for target s390x
  s390x/kvm: Remove redundant return code
  s390x/kvm: Reworked/fixed handling of cc3 in kvm_handle_css_inst()
  s390x/ioinst: Fixed priority of operand exceptions
  s390x/ioinst: Fixed alignment check in SCHM instruction
  s390x/ioinst: Throw addressing exception when memory_map failed
  s390x/ioinst: Add missing alignment checks for IO instructions
  s390/sclpconsole: handle char layer busy conditions

Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>
parents c9dd6a9f 9b4f38e1

hw/char/sclpconsole.c

+1 −17
Original line number Diff line number Diff line
@@ -184,8 +184,6 @@ static int read_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr, 
static ssize_t write_console_data(SCLPEvent *event, const uint8_t *buf,

                                  size_t len)

{

    ssize_t ret = 0;

    const uint8_t *iov_offset;

    SCLPConsole *scon = DO_UPCAST(SCLPConsole, event, event);



    if (!scon->chr) {
@@ -193,21 +191,7 @@ static ssize_t write_console_data(SCLPEvent *event, const uint8_t *buf, 
        return len;

    }



    iov_offset = buf;

    while (len > 0) {

        ret = qemu_chr_fe_write(scon->chr, buf, len);

        if (ret == 0) {

            /* a pty doesn't seem to be connected - no error */

            len = 0;

        } else if (ret == -EAGAIN || (ret > 0 && ret < len)) {

            len -= ret;

            iov_offset += ret;

        } else {

            len = 0;

        }

    }



    return ret;

    return qemu_chr_fe_write_all(scon->chr, buf, len);

}



static int write_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr)

include/elf.h

+6 −0
Original line number Diff line number Diff line
@@ -1348,11 +1348,17 @@ typedef struct elf64_shdr { 


/* Notes used in ET_CORE */

#define NT_PRSTATUS	1

#define NT_FPREGSET     2

#define NT_PRFPREG	2

#define NT_PRPSINFO	3

#define NT_TASKSTRUCT	4

#define NT_AUXV		6

#define NT_PRXFPREG     0x46e62b7f      /* copied from gdb5.1/include/elf/common.h */

#define NT_S390_PREFIX  0x305           /* s390 prefix register */

#define NT_S390_CTRS    0x304           /* s390 control registers */

#define NT_S390_TODPREG 0x303           /* s390 TOD programmable register */

#define NT_S390_TODCMP  0x302           /* s390 TOD clock comparator register */

#define NT_S390_TIMER   0x301           /* s390 timer register */





/* Note header in a PT_NOTE section */

target-s390x/Makefile.objs

+1 −1
Original line number Diff line number Diff line 
obj-y += translate.o helper.o cpu.o interrupt.o

obj-y += int_helper.o fpu_helper.o cc_helper.o mem_helper.o misc_helper.o

obj-y += gdbstub.o

obj-$(CONFIG_SOFTMMU) += ioinst.o

obj-$(CONFIG_SOFTMMU) += ioinst.o arch_dump.o

obj-$(CONFIG_KVM) += kvm.o

target-s390x/arch_dump.c

0 → 100644
+212 −0
Original line number Diff line number Diff line 
/*

 * 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++) {

        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)(&note, cpu);



        note_size = sizeof(note) - sizeof(note.contents) + nf->contents_size;

        ret = f(&note, 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)

{

    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;

}

target-s390x/cpu-qom.h

+5 −0
Original line number Diff line number Diff line
@@ -74,6 +74,11 @@ static inline S390CPU *s390_env_get_cpu(CPUS390XState *env) 
void s390_cpu_do_interrupt(CPUState *cpu);

void s390_cpu_dump_state(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,

                         int flags);

int s390_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,

                              int cpuid, void *opaque);



int s390_cpu_write_elf64_qemunote(WriteCoreDumpFunction f,

                                  CPUState *cpu, void *opaque);

hwaddr s390_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);

int s390_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);

int s390_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);