Skip to contentSkip to conversation

pc-bios: s390x: Cleanup part 2

PATCH Superseded Janosch Frank 3 participants 10 messages Aug 27, 2020 – Aug 31, 2020

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover pc-bios: s390x: Cleanup part 2

So, here are a few more cleanup patches mostly cleaning up ipl code and some of the assembly.

The patches are available here:
https://github.com/frankjaa/qemu/pull/new/cleanup_bios2

v2:
* Fixed psw saving in use reset psw patch (thanks Jason)
* Dropped a lot of patches which weren't strictly necessary
* Added disabled wait patch
* Added RFC PSW save patch

Janosch Frank (4):
pc-bios: s390x: Fix bootmap.c zipl component entry data handling
pc-bios: s390x: Use reset PSW if avaliable
pc-bios: s390x: Save io and external new PSWs before overwriting them
pc-bios: s390x: Go into disabled wait when encountering a PGM
exception

 pc-bios/s390-ccw/bootmap.c  |  6 ++--
 pc-bios/s390-ccw/bootmap.h  |  7 +++-
 pc-bios/s390-ccw/jump2ipl.c | 51 ++++++++++++++++++-----------
 pc-bios/s390-ccw/s390-ccw.h |  1 +
 pc-bios/s390-ccw/start.S    | 65 +++++++++++++++++++++++++++----------
 5 files changed, 91 insertions(+), 39 deletions(-)
Signature · 1 line
2.25.1
#1 lore raw

PATCH v2 1/4 pc-bios: s390x: Fix bootmap.c zipl component entry data handling

The two main types of zipl component entries are execute and load/data. The last member of the component entry struct therefore denotes either a PSW or an address. Let's make this a bit more clear by introducing a union and cleaning up the code that uses that struct member.

The execute type component entries written by zipl contain short PSWs, not addresses. Let's mask them and only pass the address part to jump_to_IPL_code(uint64_t address) because it expects an address as visible by the name of the argument.

---
 pc-bios/s390-ccw/bootmap.c | 5 +++--
 pc-bios/s390-ccw/bootmap.h | 7 ++++++-
 2 files changed, 9 insertions(+), 3 deletions(-)
pc-bios/s390-ccw/bootmap.c +3 -2
index 97205674e5..8747c4ea26 100644
@@ -10,6 +10,7 @@
 
 #include "libc.h"
 #include "s390-ccw.h"
+#include "s390-arch.h"
 #include "bootmap.h"
 #include "virtio.h"
 #include "bswap.h"
@@ -436,7 +437,7 @@ static void zipl_load_segment(ComponentEntry *entry)
     char *blk_no = &err_msg[30]; /* where to print blockno in (those ZZs) */
 
     blockno = entry->data.blockno;
-    address = entry->load_address;
+    address = entry->compdat.load_addr;
 
     debug_print_int("loading segment at block", blockno);
     debug_print_int("addr", address);
@@ -514,7 +515,7 @@ static void zipl_run(ScsiBlockPtr *pte)
     IPL_assert(entry->component_type == ZIPL_COMP_ENTRY_EXEC, "No EXEC entry");
 
     /* should not return */
-    jump_to_IPL_code(entry->load_address);
+    jump_to_IPL_code(entry->compdat.load_psw & PSW_MASK_SHORT_ADDR);
 }
 
 static void ipl_scsi(void)
pc-bios/s390-ccw/bootmap.h +6 -1
index 12a0166aae..3946aa3f8d 100644
@@ -64,11 +64,16 @@ typedef struct BootMapTable {
     BootMapPointer entry[];
 } __attribute__ ((packed)) BootMapTable;
 
+typedef union ComponentEntryData {
+    uint64_t load_psw;
+    uint64_t load_addr;
+} ComponentEntryData;
+
 typedef struct ComponentEntry {
     ScsiBlockPtr data;
     uint8_t pad[7];
     uint8_t component_type;
-    uint64_t load_address;
+    ComponentEntryData compdat;
 } __attribute((packed)) ComponentEntry;
 
 typedef struct ComponentHeader {
Signature · 1 line
2.25.1
#2 lore raw

PATCH v2 2/4 pc-bios: s390x: Use reset PSW if avaliable

In reply to Janosch Frank

If a blob provides a reset PSW then we should use it instead of branching to the PSW address and using our own mask.

---
 pc-bios/s390-ccw/bootmap.c  |  1 +
 pc-bios/s390-ccw/jump2ipl.c | 48 ++++++++++++++++++++++---------------
 pc-bios/s390-ccw/s390-ccw.h |  1 +
 3 files changed, 31 insertions(+), 19 deletions(-)
pc-bios/s390-ccw/bootmap.c +1 -0
index 8747c4ea26..0df9b3781d 100644
@@ -515,6 +515,7 @@ static void zipl_run(ScsiBlockPtr *pte)
     IPL_assert(entry->component_type == ZIPL_COMP_ENTRY_EXEC, "No EXEC entry");
 
     /* should not return */
+    write_reset_psw(entry->compdat.load_psw);
     jump_to_IPL_code(entry->compdat.load_psw & PSW_MASK_SHORT_ADDR);
 }
 
pc-bios/s390-ccw/jump2ipl.c +29 -19

71 lines not on this page · raw message

pc-bios/s390-ccw/s390-ccw.h +1 -0
index 36b884cced..7090720422 100644
@@ -78,6 +78,7 @@ int virtio_read(ulong sector, void *load_addr);
 void zipl_load(void);
 
 /* jump2ipl.c */
+void write_reset_psw(uint64_t psw);
 void jump_to_IPL_code(uint64_t address);
 void jump_to_low_kernel(void);
 
Signature · 1 line
2.25.1
#3 lore raw

Re: [PATCH v2 2/4] pc-bios: s390x: Use reset PSW if avaliable

Quoted 15 lines · Janosch Frank

If a blob provides a reset PSW then we should use it instead of branching to the PSW address and using our own mask.

---
 pc-bios/s390-ccw/bootmap.c  |  1 +
 pc-bios/s390-ccw/jump2ipl.c | 48 ++++++++++++++++++++++---------------
 pc-bios/s390-ccw/s390-ccw.h |  1 +
 3 files changed, 31 insertions(+), 19 deletions(-)
pc-bios/s390-ccw/bootmap.c +0 -0
index 8747c4ea26..0df9b3781d 100644

pc-bios/s390-ccw/bootmap.c static void zipl_run(ScsiBlockPtr *pte) · line 519

Quoted 5 lines
pc-bios/s390-ccw/bootmap.c +1 -0
@@ -515,6 +515,7 @@ static void zipl_run(ScsiBlockPtr *pte)
     IPL_assert(entry->component_type == ZIPL_COMP_ENTRY_EXEC, "No EXEC entry");
 
     /* should not return */
+    write_reset_psw(entry->compdat.load_psw);
     jump_to_IPL_code(entry->compdat.load_psw & PSW_MASK_SHORT_ADDR);

Shouldn't that be jump_to_IPL_code(0) now? Wouldn't it be cleaner to have a jump_to_IPL_PSW() function instead?

Quoted 7 lines
pc-bios/s390-ccw/bootmap.c +0 -0
 }
 
pc-bios/s390-ccw/jump2ipl.c +0 -0
index 767012bf0c..143d027bf7 100644

pc-bios/s390-ccw/jump2ipl.c line 16

Quoted 10 lines
pc-bios/s390-ccw/jump2ipl.c +1 -6
@@ -13,20 +13,28 @@
 #define KERN_IMAGE_START 0x010000UL
 #define RESET_PSW_MASK (PSW_MASK_SHORTPSW | PSW_MASK_64)
 
-typedef struct ResetInfo {
-    uint64_t ipl_psw;
-    uint32_t ipl_continue;
-} ResetInfo;
-
-static ResetInfo save;
+uint64_t *reset_psw = 0, save_psw, ipl_continue;

I think the patch would be better readable if you'd split it in two - first the ResetInfo rework, then the use-reset-PSW-if-available stuff ?

pc-bios/s390-ccw/jump2ipl.c line 21

Quoted 5 lines
pc-bios/s390-ccw/jump2ipl.c +2 -1
 static void jump_to_IPL_2(void)
 {
-    ResetInfo *current = 0;
+    /* Restore reset PSW and io and external new PSWs */
+    *reset_psw = save_psw;

The comment talks about io and external new PSWs ... but where is it in the code?

pc-bios/s390-ccw/jump2ipl.c line 25

Quoted 6 lines
pc-bios/s390-ccw/jump2ipl.c +3 -3
-    void (*ipl)(void) = (void *) (uint64_t) current->ipl_continue;
-    *current = save;
-    ipl(); /* should not return */
+    /* No reset PSW, let's jump instead. */
+    if (ipl_continue) {
+        void (*ipl)(void) = (void *) (uint64_t) ipl_continue;

Is it possible to mark a function pointer with __attribute__((noreturn)) ?

pc-bios/s390-ccw/jump2ipl.c line 31

Quoted 6 lines
pc-bios/s390-ccw/jump2ipl.c +6 -0
+        ipl();
+    }
+
+    /* Reset PSW available, let's load it */
+    asm volatile ("lpsw 0(%0)\n"
+        :  : "a" (0):);

I've never tried. but maybe you could add __attribute__((noreturn)) to an inline asm statement, too?

Quoted 50 lines
pc-bios/s390-ccw/jump2ipl.c +17 -9
+    /* should not return */
+}
+
+void write_reset_psw(uint64_t psw)
+{
+    *reset_psw = psw;
 }
 
 void jump_to_IPL_code(uint64_t address)
@@ -46,15 +54,12 @@ void jump_to_IPL_code(uint64_t address)
      * content of non-BIOS memory after we loaded the guest, so we
      * save the original content and restore it in jump_to_IPL_2.
      */
-    ResetInfo *current = 0;
+    save_psw = *reset_psw;
+    *reset_psw = (uint64_t) &jump_to_IPL_2;
+    *reset_psw |= RESET_PSW_MASK;
+    ipl_continue = address;
 
-    save = *current;
-
-    current->ipl_psw = (uint64_t) &jump_to_IPL_2;
-    current->ipl_psw |= RESET_PSW_MASK;
-    current->ipl_continue = address & PSW_MASK_SHORT_ADDR;
-
-    debug_print_int("set IPL addr to", current->ipl_continue);
+    debug_print_int("set IPL addr to", ipl_continue);
 
     /* Ensure the guest output starts fresh */
     sclp_print("\n");
@@ -84,7 +89,12 @@ void jump_to_low_kernel(void)
 
     /* Trying to get PSW at zero address */
     if (*((uint64_t *)0) & RESET_PSW_MASK) {
-        jump_to_IPL_code((*((uint64_t *)0)) & PSW_MASK_SHORT_ADDR);
+        /*
+         * Surely nobody will try running directly from lowcore, so
+         * let's use 0 as an indication that we want to load the reset
+         * psw at 0x0 and not jump to the entry.
+         */
+        jump_to_IPL_code(0);
     }
 
     /* No other option left, so use the Linux kernel start address */
pc-bios/s390-ccw/s390-ccw.h +0 -0
index 36b884cced..7090720422 100644

pc-bios/s390-ccw/s390-ccw.h int virtio_read(ulong sector, void *load_addr); · line 84

Quoted 7 lines
pc-bios/s390-ccw/s390-ccw.h +1 -0
@@ -78,6 +78,7 @@ int virtio_read(ulong sector, void *load_addr);
 void zipl_load(void);
 
 /* jump2ipl.c */
+void write_reset_psw(uint64_t psw);
 void jump_to_IPL_code(uint64_t address);
 void jump_to_low_kernel(void);
 

Thomas

#4 lore raw

RFC PATCH v2 3/4 pc-bios: s390x: Save io and external new PSWs before overwriting them

In reply to Janosch Frank

Currently we always overwrite the mentioned exception new PSWs before loading the enabled wait PSW. Let's save the PSW before overwriting and restore it right before starting the loaded kernel.

---

Maybe we should rather statically allocate a lowcore so we don't dirty 0x0 at all.

---
 pc-bios/s390-ccw/jump2ipl.c |  3 ++
 pc-bios/s390-ccw/start.S    | 62 +++++++++++++++++++++++++++----------
 2 files changed, 48 insertions(+), 17 deletions(-)
pc-bios/s390-ccw/jump2ipl.c +3 -0
index 143d027bf7..a44f3ab5b3 100644
@@ -13,12 +13,15 @@
 #define KERN_IMAGE_START 0x010000UL
 #define RESET_PSW_MASK (PSW_MASK_SHORTPSW | PSW_MASK_64)
 
+extern uint64_t *psw_save_io, *psw_save_ext;
 uint64_t *reset_psw = 0, save_psw, ipl_continue;
 
 static void jump_to_IPL_2(void)
 {
     /* Restore reset PSW and io and external new PSWs */
     *reset_psw = save_psw;
+    memcpy((void *)0x1f0, psw_save_io, 16);
+    memcpy((void *)0x1b0, psw_save_ext, 16);
 
     /* No reset PSW, let's jump instead. */
     if (ipl_continue) {
pc-bios/s390-ccw/start.S +45 -17

87 lines not on this page · raw message

Signature · 1 line
2.25.1
#5 lore raw

Re: [PATCH RFC v2 3/4] pc-bios: s390x: Save io and external new PSWs before overwriting them

Quoted 20 lines · Janosch Frank

Currently we always overwrite the mentioned exception new PSWs before loading the enabled wait PSW. Let's save the PSW before overwriting and restore it right before starting the loaded kernel.

---

Maybe we should rather statically allocate a lowcore so we don't dirty 0x0 at all.

---
 pc-bios/s390-ccw/jump2ipl.c |  3 ++
 pc-bios/s390-ccw/start.S    | 62 +++++++++++++++++++++++++++----------
 2 files changed, 48 insertions(+), 17 deletions(-)
pc-bios/s390-ccw/jump2ipl.c +0 -0
index 143d027bf7..a44f3ab5b3 100644

pc-bios/s390-ccw/jump2ipl.c line 16

Quoted 4 lines
pc-bios/s390-ccw/jump2ipl.c +1 -0
@@ -13,12 +13,15 @@
 #define KERN_IMAGE_START 0x010000UL
 #define RESET_PSW_MASK (PSW_MASK_SHORTPSW | PSW_MASK_64)
 
+extern uint64_t *psw_save_io, *psw_save_ext;

I think that should be

extern uint64_t psw_save_io[], psw_save_ext[];

instead ... otherwise you'll end up with some funny bugs here, won't you?

pc-bios/s390-ccw/jump2ipl.c line 21

Quoted 5 lines
pc-bios/s390-ccw/jump2ipl.c +0 -0
 uint64_t *reset_psw = 0, save_psw, ipl_continue;
 
 static void jump_to_IPL_2(void)
 {
     /* Restore reset PSW and io and external new PSWs */

Ok, now the comment makes sense :-)

pc-bios/s390-ccw/jump2ipl.c line 24

Quoted 3 lines
pc-bios/s390-ccw/jump2ipl.c +2 -0
     *reset_psw = save_psw;
+    memcpy((void *)0x1f0, psw_save_io, 16);
+    memcpy((void *)0x1b0, psw_save_ext, 16);

Could you use &lowcore->external_new_psw and &lowcore->io_new_psw instead of the magic numbers?

Thomas

#6 lore raw

Re: [PATCH RFC v2 3/4] pc-bios: s390x: Save io and external new PSWs before overwriting them

Quoted 24 lines · Thomas Huth
Quoted 23 lines · Janosch Frank

Currently we always overwrite the mentioned exception new PSWs before loading the enabled wait PSW. Let's save the PSW before overwriting and restore it right before starting the loaded kernel.

---

Maybe we should rather statically allocate a lowcore so we don't dirty 0x0 at all.

---
 pc-bios/s390-ccw/jump2ipl.c |  3 ++
 pc-bios/s390-ccw/start.S    | 62 +++++++++++++++++++++++++++----------
 2 files changed, 48 insertions(+), 17 deletions(-)
pc-bios/s390-ccw/jump2ipl.c +0 -0
index 143d027bf7..a44f3ab5b3 100644
@@ -13,12 +13,15 @@
 #define KERN_IMAGE_START 0x010000UL
 #define RESET_PSW_MASK (PSW_MASK_SHORTPSW | PSW_MASK_64)
 
Quoted 7 lines

pc-bios/s390-ccw/jump2ipl.c line 16

Quoted 1 line
pc-bios/s390-ccw/jump2ipl.c +1 -0
+extern uint64_t *psw_save_io, *psw_save_ext;

I think that should be

extern uint64_t psw_save_io[], psw_save_ext[];

instead ... otherwise you'll end up with some funny bugs here, won't you?

What kind of bugs are you expecting?

Quoted 7 lines

pc-bios/s390-ccw/jump2ipl.c line 21

Quoted 6 lines
pc-bios/s390-ccw/jump2ipl.c +0 -0
 uint64_t *reset_psw = 0, save_psw, ipl_continue;
 
 static void jump_to_IPL_2(void)
 {
     /* Restore reset PSW and io and external new PSWs */
Quoted 7 lines

Ok, now the comment makes sense :-)

pc-bios/s390-ccw/jump2ipl.c line 24

Quoted 3 lines
pc-bios/s390-ccw/jump2ipl.c +2 -0
     *reset_psw = save_psw;
+    memcpy((void *)0x1f0, psw_save_io, 16);
+    memcpy((void *)0x1b0, psw_save_ext, 16);

Could you use &lowcore->external_new_psw and &lowcore->io_new_psw instead of the magic numbers?

I can, but that means that I need to declare lowcore in netmain.c as well as including s390-arch.h

Quoted 5 lines

Thomas

#7 lore raw

Re: [PATCH RFC v2 3/4] pc-bios: s390x: Save io and external new PSWs before overwriting them

Quoted 29 lines · Janosch Frank
Quoted 28 lines · Thomas Huth
Quoted 20 lines · Janosch Frank

Currently we always overwrite the mentioned exception new PSWs before loading the enabled wait PSW. Let's save the PSW before overwriting and restore it right before starting the loaded kernel.

---

Maybe we should rather statically allocate a lowcore so we don't dirty 0x0 at all.

---
 pc-bios/s390-ccw/jump2ipl.c |  3 ++
 pc-bios/s390-ccw/start.S    | 62 +++++++++++++++++++++++++++----------
 2 files changed, 48 insertions(+), 17 deletions(-)
pc-bios/s390-ccw/jump2ipl.c +0 -0
index 143d027bf7..a44f3ab5b3 100644

pc-bios/s390-ccw/jump2ipl.c line 16

Quoted 4 lines
pc-bios/s390-ccw/jump2ipl.c +1 -0
@@ -13,12 +13,15 @@
 #define KERN_IMAGE_START 0x010000UL
 #define RESET_PSW_MASK (PSW_MASK_SHORTPSW | PSW_MASK_64)
 
+extern uint64_t *psw_save_io, *psw_save_ext;

I think that should be

Quoted 5 lines
Quoted 3 lines

extern uint64_t psw_save_io[], psw_save_ext[];

instead ... otherwise you'll end up with some funny bugs here, won't you?

What kind of bugs are you expecting?

Well, "extern uint64_t var[];" and "extern uint64_t *var;" are two different kind of things. One is an array, one is a pointer variable. Looking at your assembler code, you obviously tried to declare an array there, not a pointer variable.

Have a try with this test program:

#include <string.h>

extern unsigned long *var;

void main(void)
{
asm volatile (" nop ; nop ; nop "); /* marker */ memcpy((void *)0x1f0, var, 16);
asm volatile (" nop ; nop ; nop "); /* marker */
}

After compiling that with -O2, and disassembling the corresponding .o file, I get this code between the nops:

c: c4 18 00 00 00 00 lgrl %r1,c <main+0xc>

			e: R_390_PC32DBL	var+0x2

12: e7 00 10 00 00 06 vl %v0,0(%r1)
18: e7 00 01 f0 00 0e vst %v0,496

The "lgrl %r1,var" is likely not what you wanted here.

If you now replace the "*var" with "var[]", you get this instead:

c: c0 10 00 00 00 00 larl %r1,c <main+0xc>

			e: R_390_PC32DBL	var+0x2

12: e7 00 10 00 00 06 vl %v0,0(%r1)
18: e7 00 01 f0 00 0e vst %v0,496

"larl" looks better now, doesn't it?

Quoted 12 lines
Quoted 12 lines

pc-bios/s390-ccw/jump2ipl.c line 21

Quoted 6 lines
pc-bios/s390-ccw/jump2ipl.c +0 -0
 uint64_t *reset_psw = 0, save_psw, ipl_continue;
 
 static void jump_to_IPL_2(void)
 {
     /* Restore reset PSW and io and external new PSWs */

Ok, now the comment makes sense :-)

Quoted 3 lines
pc-bios/s390-ccw/jump2ipl.c +2 -0
     *reset_psw = save_psw;
+    memcpy((void *)0x1f0, psw_save_io, 16);
+    memcpy((void *)0x1b0, psw_save_ext, 16);
Quoted 5 lines
Quoted 2 lines

Could you use &lowcore->external_new_psw and &lowcore->io_new_psw instead of the magic numbers?

I can, but that means that I need to declare lowcore in netmain.c as well as including s390-arch.h

If that does not cause any other big hurdles, I think I'd prefer that instead of using magic numbers.

Thanks,
Thomas

#8 lore raw

PATCH v2 4/4 pc-bios: s390x: Go into disabled wait when encountering a PGM exception

In reply to Janosch Frank

Let's setup a PGM PSW, so we won't load 0s when a program exception happens. Instead we'll load a disabled wait PSW.

---
 pc-bios/s390-ccw/start.S | 3 +++
 1 file changed, 3 insertions(+)
pc-bios/s390-ccw/start.S +3 -0
index 939aac3a7c..775b45baeb 100644
@@ -44,6 +44,9 @@ done:
         larl  %r2, external_new_psw
         stg   %r1, 8(%r2)
         mvc   0x1b0(16),0(%r2)
+        /* set up a pgm exception disabled wait psw */
+        larl  %r2, disabled_wait_psw
+        mvc   0x01d0(16), 0(%r2)
         j      main		/* And call C */
 
 memsetxc:
Signature · 1 line
2.25.1
Reviewed-by on v2 4/4
#9 lore raw

Re: [PATCH v2 4/4] pc-bios: s390x: Go into disabled wait when encountering a PGM exception

Quoted 2 lines · Janosch Frank

Let's setup a PGM PSW, so we won't load 0s when a program exception happens. Instead we'll load a disabled wait PSW.

Makes sense

Quoted 21 lines
---
 pc-bios/s390-ccw/start.S | 3 +++
 1 file changed, 3 insertions(+)
pc-bios/s390-ccw/start.S +3 -0
index 939aac3a7c..775b45baeb 100644
@@ -44,6 +44,9 @@ done:
         larl  %r2, external_new_psw
         stg   %r1, 8(%r2)
         mvc   0x1b0(16),0(%r2)
+        /* set up a pgm exception disabled wait psw */
+        larl  %r2, disabled_wait_psw
+        mvc   0x01d0(16), 0(%r2)
         j      main		/* And call C */
 
 memsetxc: