arch/s390/boot/ipl_report.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/init.h>
   3 #include <linux/ctype.h>
   4 #include <asm/ebcdic.h>
   5 #include <asm/sclp.h>
   6 #include <asm/sections.h>
   7 #include <asm/boot_data.h>
   8 #include <uapi/asm/ipl.h>
   9 #include "boot.h"
  10
  11 int __bootdata_preserved(ipl_secure_flag);
  12
  13 unsigned long __bootdata_preserved(ipl_cert_list_addr);
  14 unsigned long __bootdata_preserved(ipl_cert_list_size);
  15
  16 unsigned long __bootdata(early_ipl_comp_list_addr);
  17 unsigned long __bootdata(early_ipl_comp_list_size);
  18
  19 #define for_each_rb_entry(entry, rb) \
  20         for (entry = rb->entries; \
  21              (void *) entry + sizeof(*entry) <= (void *) rb + rb->len; \
  22              entry++)
  23
  24 static inline bool intersects(unsigned long addr0, unsigned long size0,
  25                               unsigned long addr1, unsigned long size1)
  26 {
  27         return addr0 + size0 > addr1 && addr1 + size1 > addr0;
  28 }
  29
  30 static unsigned long find_bootdata_space(struct ipl_rb_components *comps,
  31                                          struct ipl_rb_certificates *certs,
  32                                          unsigned long safe_addr)
  33 {
  34         struct ipl_rb_certificate_entry *cert;
  35         struct ipl_rb_component_entry *comp;
  36         size_t size;
  37
  38         /*
  39          * Find the length for the IPL report boot data
  40          */
  41         early_ipl_comp_list_size = 0;
  42         for_each_rb_entry(comp, comps)
  43                 early_ipl_comp_list_size += sizeof(*comp);
  44         ipl_cert_list_size = 0;
  45         for_each_rb_entry(cert, certs)
  46                 ipl_cert_list_size += sizeof(unsigned int) + cert->len;
  47         size = ipl_cert_list_size + early_ipl_comp_list_size;
  48
  49         /*
  50          * Start from safe_addr to find a free memory area large
  51          * enough for the IPL report boot data. This area is used
  52          * for ipl_cert_list_addr/ipl_cert_list_size and
  53          * early_ipl_comp_list_addr/early_ipl_comp_list_size. It must
  54          * not overlap with any component or any certificate.
  55          */
  56 repeat:
  57         if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && INITRD_START && INITRD_SIZE &&
  58             intersects(INITRD_START, INITRD_SIZE, safe_addr, size))
  59                 safe_addr = INITRD_START + INITRD_SIZE;
  60         for_each_rb_entry(comp, comps)
  61                 if (intersects(safe_addr, size, comp->addr, comp->len)) {
  62                         safe_addr = comp->addr + comp->len;
  63                         goto repeat;
  64                 }
  65         for_each_rb_entry(cert, certs)
  66                 if (intersects(safe_addr, size, cert->addr, cert->len)) {
  67                         safe_addr = cert->addr + cert->len;
  68                         goto repeat;
  69                 }
  70         early_ipl_comp_list_addr = safe_addr;
  71         ipl_cert_list_addr = safe_addr + early_ipl_comp_list_size;
  72
  73         return safe_addr + size;
  74 }
  75
  76 static void copy_components_bootdata(struct ipl_rb_components *comps)
  77 {
  78         struct ipl_rb_component_entry *comp, *ptr;
  79
  80         ptr = (struct ipl_rb_component_entry *) early_ipl_comp_list_addr;
  81         for_each_rb_entry(comp, comps)
  82                 memcpy(ptr++, comp, sizeof(*ptr));
  83 }
  84
  85 static void copy_certificates_bootdata(struct ipl_rb_certificates *certs)
  86 {
  87         struct ipl_rb_certificate_entry *cert;
  88         void *ptr;
  89
  90         ptr = (void *) ipl_cert_list_addr;
  91         for_each_rb_entry(cert, certs) {
  92                 *(unsigned int *) ptr = cert->len;
  93                 ptr += sizeof(unsigned int);
  94                 memcpy(ptr, (void *) cert->addr, cert->len);
  95                 ptr += cert->len;
  96         }
  97 }
  98
  99 unsigned long read_ipl_report(unsigned long safe_addr)
 100 {
 101         struct ipl_rb_certificates *certs;
 102         struct ipl_rb_components *comps;
 103         struct ipl_pl_hdr *pl_hdr;
 104         struct ipl_rl_hdr *rl_hdr;
 105         struct ipl_rb_hdr *rb_hdr;
 106         unsigned long tmp;
 107         void *rl_end;
 108
 109         /*
 110          * Check if there is a IPL report by looking at the copy
 111          * of the IPL parameter information block.
 112          */
 113         if (!ipl_block_valid ||
 114             !(ipl_block.hdr.flags & IPL_PL_FLAG_IPLSR))
 115                 return safe_addr;
 116         ipl_secure_flag = !!(ipl_block.hdr.flags & IPL_PL_FLAG_SIPL);
 117         /*
 118          * There is an IPL report, to find it load the pointer to the
 119          * IPL parameter information block from lowcore and skip past
 120          * the IPL parameter list, then align the address to a double
 121          * word boundary.
 122          */
 123         tmp = (unsigned long) S390_lowcore.ipl_parmblock_ptr;
 124         pl_hdr = (struct ipl_pl_hdr *) tmp;
 125         tmp = (tmp + pl_hdr->len + 7) & -8UL;
 126         rl_hdr = (struct ipl_rl_hdr *) tmp;
 127         /* Walk through the IPL report blocks in the IPL Report list */
 128         certs = NULL;
 129         comps = NULL;
 130         rl_end = (void *) rl_hdr + rl_hdr->len;
 131         rb_hdr = (void *) rl_hdr + sizeof(*rl_hdr);
 132         while ((void *) rb_hdr + sizeof(*rb_hdr) < rl_end &&
 133                (void *) rb_hdr + rb_hdr->len <= rl_end) {
 134
 135                 switch (rb_hdr->rbt) {
 136                 case IPL_RBT_CERTIFICATES:
 137                         certs = (struct ipl_rb_certificates *) rb_hdr;
 138                         break;
 139                 case IPL_RBT_COMPONENTS:
 140                         comps = (struct ipl_rb_components *) rb_hdr;
 141                         break;
 142                 default:
 143                         break;
 144                 }
 145
 146                 rb_hdr = (void *) rb_hdr + rb_hdr->len;
 147         }
 148
 149         /*
 150          * With either the component list or the certificate list
 151          * missing the kernel will stay ignorant of secure IPL.
 152          */
 153         if (!comps || !certs)
 154                 return safe_addr;
 155
 156         /*
 157          * Copy component and certificate list to a safe area
 158          * where the decompressed kernel can find them.
 159          */
 160         safe_addr = find_bootdata_space(comps, certs, safe_addr);
 161         copy_components_bootdata(comps);
 162         copy_certificates_bootdata(certs);
 163
 164         return safe_addr;
 165 }