s390/kdump: add support for vector extension

With this patch for kdump the s390 vector registers are stored into the
prepared save areas in the old kernel and into the REGSET_VX_LOW and
REGSET_VX_HIGH ELF notes for /proc/vmcore in the new kernel.

The NT_S390_VXRS_LOW note contains the lower halves of the first 16 vector
registers 0-15. The higher halves are stored in the floating point register
ELF note.  The NT_S390_VXRS_HIGH contains the full vector registers 16-31.

The kernel provides a save area for storing vector register in case of
machine checks. A pointer to this save are is stored in the CPU lowcore
at offset 0x11b0. This save area is also used to save the registers for
kdump. In case of a dumped crashed kdump those areas are used to extract
the registers of the production system.

The vector registers for remote CPUs are stored using the "store additional
status at address" SIGP. For the dump CPU the vector registers are stored
with the VSTM instruction.

With this patch also zfcpdump stores the vector registers.

Reviewed-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Michael Holzheu <holzheu@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

1 files changed, 49 insertions, 9 deletions

diff --git a/arch/s390/kernel/crash_dump.c b/arch/s390/kernel/crash_dump.c
index a3b9150e6802..9f73c8059022 100644
--- a/arch/s390/kernel/crash_dump.c
+++ b/arch/s390/kernel/crash_dump.c
@@ -46,9 +46,9 @@ struct dump_save_areas dump_save_areas;
 /*
  * Allocate and add a save area for a CPU
  */
-struct save_area *dump_save_area_create(int cpu)
+struct save_area_ext *dump_save_area_create(int cpu)
 {
-        struct save_area **save_areas, *save_area;
+        struct save_area_ext **save_areas, *save_area;
 
         save_area = kmalloc(sizeof(*save_area), GFP_KERNEL);
         if (!save_area)
@@ -386,9 +386,45 @@ static void *nt_s390_prefix(void *ptr, struct save_area *sa)
 }
 
 /*
+ * Initialize vxrs high note (full 128 bit VX registers 16-31)
+ */
+static void *nt_s390_vx_high(void *ptr, __vector128 *vx_regs)
+{
+        return nt_init(ptr, NT_S390_VXRS_HIGH, &vx_regs[16],
+                       16 * sizeof(__vector128), KEXEC_CORE_NOTE_NAME);
+}
+
+/*
+ * Initialize vxrs low note (lower halves of VX registers 0-15)
+ */
+static void *nt_s390_vx_low(void *ptr, __vector128 *vx_regs)
+{
+        Elf64_Nhdr *note;
+        u64 len;
+        int i;
+
+        note = (Elf64_Nhdr *)ptr;
+        note->n_namesz = strlen(KEXEC_CORE_NOTE_NAME) + 1;
+        note->n_descsz = 16 * 8;
+        note->n_type = NT_S390_VXRS_LOW;
+        len = sizeof(Elf64_Nhdr);
+
+        memcpy(ptr + len, KEXEC_CORE_NOTE_NAME, note->n_namesz);
+        len = roundup(len + note->n_namesz, 4);
+
+        ptr += len;
+        /* Copy lower halves of SIMD registers 0-15 */
+        for (i = 0; i < 16; i++) {
+                memcpy(ptr, &vx_regs[i], 8);
+                ptr += 8;
+        }
+        return ptr;
+}
+
+/*
  * Fill ELF notes for one CPU with save area registers
  */
-void *fill_cpu_elf_notes(void *ptr, struct save_area *sa)
+void *fill_cpu_elf_notes(void *ptr, struct save_area *sa, __vector128 *vx_regs)
 {
         ptr = nt_prstatus(ptr, sa);
         ptr = nt_fpregset(ptr, sa);
@@ -397,6 +433,10 @@ void *fill_cpu_elf_notes(void *ptr, struct save_area *sa)
         ptr = nt_s390_tod_preg(ptr, sa);
         ptr = nt_s390_ctrs(ptr, sa);
         ptr = nt_s390_prefix(ptr, sa);
+        if (MACHINE_HAS_VX && vx_regs) {
+                ptr = nt_s390_vx_low(ptr, vx_regs);
+                ptr = nt_s390_vx_high(ptr, vx_regs);
+        }
         return ptr;
 }
 
@@ -484,7 +524,7 @@ static int get_cpu_cnt(void)
         int i, cpus = 0;
 
         for (i = 0; i < dump_save_areas.count; i++) {
-                if (dump_save_areas.areas[i]->pref_reg == 0)
+                if (dump_save_areas.areas[i]->sa.pref_reg == 0)
                         continue;
                 cpus++;
         }
@@ -530,17 +570,17 @@ static void loads_init(Elf64_Phdr *phdr, u64 loads_offset)
  */
 static void *notes_init(Elf64_Phdr *phdr, void *ptr, u64 notes_offset)
 {
-        struct save_area *sa;
+        struct save_area_ext *sa_ext;
         void *ptr_start = ptr;
         int i;
 
         ptr = nt_prpsinfo(ptr);
 
         for (i = 0; i < dump_save_areas.count; i++) {
-                sa = dump_save_areas.areas[i];
-                if (sa->pref_reg == 0)
+                sa_ext = dump_save_areas.areas[i];
+                if (sa_ext->sa.pref_reg == 0)
                         continue;
-                ptr = fill_cpu_elf_notes(ptr, sa);
+                ptr = fill_cpu_elf_notes(ptr, &sa_ext->sa, sa_ext->vx_regs);
         }
         ptr = nt_vmcoreinfo(ptr);
         memset(phdr, 0, sizeof(*phdr));
@@ -581,7 +621,7 @@ int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size)
 
         mem_chunk_cnt = get_mem_chunk_cnt();
 
-        alloc_size = 0x1000 + get_cpu_cnt() * 0x300 +
+        alloc_size = 0x1000 + get_cpu_cnt() * 0x4a0 +
                 mem_chunk_cnt * sizeof(Elf64_Phdr);
         hdr = kzalloc_panic(alloc_size);
         /* Init elf header */