Re: [PATCH v4 08/19] pc-bios/s390-ccw: Remove panics from ECKD IPL path

[Thomas Huth <thuth@redhat.com>]

On 17/10/2024 03.47, jrossi@linux.ibm.com wrote:
> From: Jared Rossi <jrossi@linux.ibm.com>
> 
> Remove panic-on-error from ECKD block device IPL specific functions so that
> error recovery may be possible in the future.
> 
> Functions that would previously panic now provide a return code.
> 
> Signed-off-by: Jared Rossi <jrossi@linux.ibm.com>
> ---
>   pc-bios/s390-ccw/bootmap.h |   1 +
>   pc-bios/s390-ccw/bootmap.c | 193 +++++++++++++++++++++++++------------
>   2 files changed, 135 insertions(+), 59 deletions(-)
> 
> diff --git a/pc-bios/s390-ccw/bootmap.h b/pc-bios/s390-ccw/bootmap.h
> index 09f4e6fb40..271dbabbc3 100644
> --- a/pc-bios/s390-ccw/bootmap.h
> +++ b/pc-bios/s390-ccw/bootmap.h
> @@ -16,6 +16,7 @@
>   
>   typedef uint64_t block_number_t;
>   #define NULL_BLOCK_NR 0xffffffffffffffffULL
> +#define ERROR_BLOCK_NR 0xfffffffffffffffeULL
>   
>   #define FREE_SPACE_FILLER '\xAA'
>   
> diff --git a/pc-bios/s390-ccw/bootmap.c b/pc-bios/s390-ccw/bootmap.c
> index 5477cfe228..dd04bb3384 100644
> --- a/pc-bios/s390-ccw/bootmap.c
> +++ b/pc-bios/s390-ccw/bootmap.c
> @@ -145,14 +145,17 @@ static block_number_t load_eckd_segments(block_number_t blk, bool ldipl,
>       bool more_data;
>   
>       memset(_bprs, FREE_SPACE_FILLER, sizeof(_bprs));
> -    read_block(blk, bprs, "BPRS read failed");
> +    if (virtio_read(blk, bprs)) {
> +        puts("BPRS read failed");
> +        return ERROR_BLOCK_NR;
> +    }
>   
>       do {
>           more_data = false;
>           for (j = 0;; j++) {
>               block_nr = gen_eckd_block_num(&bprs[j].xeckd, ldipl);
>               if (is_null_block_number(block_nr)) { /* end of chunk */
> -                break;
> +                return NULL_BLOCK_NR;
>               }
>   
>               /* we need the updated blockno for the next indirect entry
> @@ -163,15 +166,20 @@ static block_number_t load_eckd_segments(block_number_t blk, bool ldipl,
>               }
>   
>               /* List directed pointer does not store block size */
> -            IPL_assert(ldipl || block_size_ok(bprs[j].xeckd.bptr.size),
> -                       "bad chunk block size");
> +            if (!ldipl && !block_size_ok(bprs[j].xeckd.bptr.size)) {
> +                puts("Bad chunk block size");
> +                return NULL_BLOCK_NR;

Shouldn't that be a "return ERROR_BLOCK_NR" instead?

> +            }
>   
>               if (!eckd_valid_address(&bprs[j].xeckd, ldipl)) {
>                   /*
>                    * If an invalid address is found during LD-IPL then break and
> -                 * retry as CCW
> +                 * retry as CCW-IPL, otherwise abort on error
>                    */
> -                IPL_assert(ldipl, "bad chunk ECKD addr");
> +                if (!ldipl) {
> +                    puts("Bad chunk ECKD address");
> +                    return ERROR_BLOCK_NR;
> +                }
>                   break;
>               }
>   
> @@ -189,7 +197,10 @@ static block_number_t load_eckd_segments(block_number_t blk, bool ldipl,
>                    * I.e. the next ptr must point to the unused memory area
>                    */
>                   memset(_bprs, FREE_SPACE_FILLER, sizeof(_bprs));
> -                read_block(block_nr, bprs, "BPRS continuation read failed");
> +                if (virtio_read(block_nr, bprs)) {
> +                    puts("BPRS continuation read failed");
> +                    return ERROR_BLOCK_NR;
> +                }
>                   more_data = true;
>                   break;
>               }
> @@ -198,7 +209,10 @@ static block_number_t load_eckd_segments(block_number_t blk, bool ldipl,
>                * to memory (address).
>                */
>               rc = virtio_read_many(block_nr, (void *)(*address), count + 1);
> -            IPL_assert(rc == 0, "code chunk read failed");
> +            if (rc != 0) {
> +                puts("Code chunk read failed");
> +                return ERROR_BLOCK_NR;
> +            }
>   
>               *address += (count + 1) * virtio_get_block_size();
>           }
> @@ -232,7 +246,10 @@ static int eckd_get_boot_menu_index(block_number_t s1b_block_nr)
>   
>       /* Get Stage1b data */
>       memset(sec, FREE_SPACE_FILLER, sizeof(sec));
> -    read_block(s1b_block_nr, s1b, "Cannot read stage1b boot loader");
> +    if (virtio_read(s1b_block_nr, s1b)) {
> +        puts("Cannot read stage1b boot loader");
> +        return -EIO;
> +    }
>   
>       memset(_s2, FREE_SPACE_FILLER, sizeof(_s2));
>   
> @@ -244,7 +261,10 @@ static int eckd_get_boot_menu_index(block_number_t s1b_block_nr)
>               break;
>           }
>   
> -        read_block(cur_block_nr, s2_cur_blk, "Cannot read stage2 boot loader");
> +        if (virtio_read(cur_block_nr, s2_cur_blk)) {
> +            puts("Cannot read stage2 boot loader");
> +            return -EIO;
> +        }
>   
>           if (find_zipl_boot_menu_banner(&banner_offset)) {
>               /*
> @@ -252,8 +272,10 @@ static int eckd_get_boot_menu_index(block_number_t s1b_block_nr)
>                * possibility of menu data spanning multiple blocks.
>                */
>               if (prev_block_nr) {
> -                read_block(prev_block_nr, s2_prev_blk,
> -                           "Cannot read stage2 boot loader");
> +                if (virtio_read(prev_block_nr, s2_prev_blk)) {
> +                    puts("Cannot read stage2 boot loader");
> +                    return -EIO;
> +                }
>               }
>   
>               if (i + 1 < STAGE2_BLK_CNT_MAX) {
> @@ -261,8 +283,10 @@ static int eckd_get_boot_menu_index(block_number_t s1b_block_nr)
>               }
>   
>               if (next_block_nr && !is_null_block_number(next_block_nr)) {
> -                read_block(next_block_nr, s2_next_blk,
> -                           "Cannot read stage2 boot loader");
> +                if (virtio_read(next_block_nr, s2_next_blk)) {
> +                    puts("Cannot read stage2 boot loader");
> +                    return -EIO;
> +                }
>               }
>   
>               return menu_get_zipl_boot_index(s2_cur_blk + banner_offset);
> @@ -275,7 +299,7 @@ static int eckd_get_boot_menu_index(block_number_t s1b_block_nr)
>       return 0;
>   }
>   
> -static void run_eckd_boot_script(block_number_t bmt_block_nr,
> +static int run_eckd_boot_script(block_number_t bmt_block_nr,
>                                    block_number_t s1b_block_nr)
>   {
>       int i;
> @@ -292,17 +316,28 @@ static void run_eckd_boot_script(block_number_t bmt_block_nr,
>       }
>   
>       debug_print_int("loadparm", loadparm);
> -    IPL_assert(loadparm < MAX_BOOT_ENTRIES, "loadparm value greater than"
> -               " maximum number of boot entries allowed");
> +    if (loadparm >= MAX_BOOT_ENTRIES) {
> +        puts("loadparm value greater than max number of boot entries allowed");
> +        return -EINVAL;
> +    }
>   
>       memset(sec, FREE_SPACE_FILLER, sizeof(sec));
> -    read_block(bmt_block_nr, sec, "Cannot read Boot Map Table");
> +    if (virtio_read(bmt_block_nr, sec)) {
> +        puts("Cannot read Boot Map Table");
> +        return -EIO;
> +    }
>   
>       block_nr = gen_eckd_block_num(&bmt->entry[loadparm].xeckd, ldipl);
> -    IPL_assert(block_nr != -1, "Cannot find Boot Map Table Entry");
> +    if (block_nr == NULL_BLOCK_NR) {
> +        puts("Cannot find Boot Map Table Entry");
> +        return -EIO;
> +    }
>   
>       memset(sec, FREE_SPACE_FILLER, sizeof(sec));
> -    read_block(block_nr, sec, "Cannot read Boot Map Script");
> +    if (virtio_read(block_nr, sec)) {
> +        puts("Cannot read Boot Map Script");
> +        return -EIO;
> +    }
>   
>       for (i = 0; bms->entry[i].type == BOOT_SCRIPT_LOAD ||
>                   bms->entry[i].type == BOOT_SCRIPT_SIGNATURE; i++) {
> @@ -317,21 +352,28 @@ static void run_eckd_boot_script(block_number_t bmt_block_nr,
>   
>           do {
>               block_nr = load_eckd_segments(block_nr, ldipl, &address);
> -        } while (block_nr != -1);
> +        } while (block_nr != ERROR_BLOCK_NR && block_nr != NULL_BLOCK_NR);
> +
> +        if (block_nr == ERROR_BLOCK_NR) {
> +            return ldipl ? 0 : -EIO;
> +        }

Mostly a matter of style, but if you move the if-statement into the while 
loop, you don't have to check for ERROR_BLOCK_NR in the while condition again.

>       }
>   
>       if (ldipl && bms->entry[i].type != BOOT_SCRIPT_EXEC) {
>           /* Abort LD-IPL and retry as CCW-IPL */
> -        return;
> +        return 0;
>       }
>   
> -    IPL_assert(bms->entry[i].type == BOOT_SCRIPT_EXEC,
> -               "Unknown script entry type");
> +    if (bms->entry[i].type != BOOT_SCRIPT_EXEC) {
> +        puts("Unknown script entry type");
> +        return -EINVAL;
> +    }
>       write_reset_psw(bms->entry[i].address.load_address); /* no return */
>       jump_to_IPL_code(0); /* no return */
> +    return 1;
>   }
...
> @@ -787,12 +859,15 @@ static void load_iso_bc_entry(IsoBcSection *load)
>       uint32_t blks_to_load = bswap16(s.sector_count) >> ET_SECTOR_SHIFT;
>       long real_size = iso_get_file_size(bswap32(s.load_rba));
>   
> -    if (real_size) {
> +    if (real_size > 0) {
>           /* Round up blocks to load */
>           blks_to_load = (real_size + ISO_SECTOR_SIZE - 1) / ISO_SECTOR_SIZE;
>           puts("ISO boot image size verified");
>       } else {
>           puts("ISO boot image size could not be verified");
> +        if (real_size < 0) {
> +            return;
> +        }
>       }

Ah, here's the fix for the problem that I complained about in the previous 
patch :-) ... looks like you've squashed it into the wrong patch.

  Thomas