xref: /openbmc/qemu/pc-bios/s390-ccw/bootmap.h (revision e17e57e862faf6e1f372385c18dcf6d3fd31158e)
1  /*
2   * QEMU S390 bootmap interpreter -- declarations
3   *
4   * Copyright 2014 IBM Corp.
5   * Author(s): Eugene (jno) Dvurechenski <jno@linux.vnet.ibm.com>
6   *
7   * This work is licensed under the terms of the GNU GPL, version 2 or (at
8   * your option) any later version. See the COPYING file in the top-level
9   * directory.
10   */
11  #ifndef _PC_BIOS_S390_CCW_BOOTMAP_H
12  #define _PC_BIOS_S390_CCW_BOOTMAP_H
13  
14  #include "s390-ccw.h"
15  #include "virtio.h"
16  
17  typedef uint64_t block_number_t;
18  #define NULL_BLOCK_NR 0xffffffffffffffffULL
19  #define ERROR_BLOCK_NR 0xfffffffffffffffeULL
20  
21  #define FREE_SPACE_FILLER '\xAA'
22  
23  typedef struct ScsiBlockPtr {
24      uint64_t blockno;
25      uint16_t size;
26      uint16_t blockct;
27      uint8_t reserved[4];
28  } __attribute__ ((packed)) ScsiBlockPtr;
29  
30  typedef struct FbaBlockPtr {
31      uint32_t blockno;
32      uint16_t size;
33      uint16_t blockct;
34  } __attribute__ ((packed)) FbaBlockPtr;
35  
36  typedef struct EckdCHS {
37      uint16_t cylinder;
38      uint16_t head;
39      uint8_t sector;
40  } __attribute__ ((packed)) EckdCHS;
41  
42  typedef struct EckdBlockPtr {
43      EckdCHS chs; /* cylinder/head/sector is an address of the block */
44      uint16_t size;
45      uint8_t count; /* (size_in_blocks-1);
46                      * it's 0 for TablePtr, ScriptPtr, and SectionPtr */
47  } __attribute__ ((packed)) EckdBlockPtr;
48  
49  typedef struct LdEckdCHS {
50      uint32_t cylinder;
51      uint8_t head;
52      uint8_t sector;
53  } __attribute__ ((packed)) LdEckdCHS;
54  
55  typedef struct LdEckdBlockPtr {
56      LdEckdCHS chs; /* cylinder/head/sector is an address of the block */
57      uint8_t reserved[4];
58      uint16_t count;
59      uint32_t pad;
60  } __attribute__ ((packed)) LdEckdBlockPtr;
61  
62  /* bptr is used for CCW type IPL, while ldptr is for list-directed IPL */
63  typedef union ExtEckdBlockPtr {
64      EckdBlockPtr bptr;
65      LdEckdBlockPtr ldptr;
66  } __attribute__ ((packed)) ExtEckdBlockPtr;
67  
68  typedef union BootMapPointer {
69      ScsiBlockPtr scsi;
70      FbaBlockPtr fba;
71      EckdBlockPtr eckd;
72      ExtEckdBlockPtr xeckd;
73  } __attribute__ ((packed)) BootMapPointer;
74  
75  typedef struct BootRecord {
76      uint8_t magic[4];
77      uint32_t version;
78      uint64_t res1;
79      BootMapPointer pgt;
80      uint8_t reserved[510 - 32];
81      uint16_t os_id;
82  } __attribute__ ((packed)) BootRecord;
83  
84  /* aka Program Table */
85  typedef struct BootMapTable {
86      uint8_t magic[4];
87      uint8_t reserved[12];
88      BootMapPointer entry[];
89  } __attribute__ ((packed)) BootMapTable;
90  
91  typedef union ComponentEntryData {
92      uint64_t load_psw;
93      uint64_t load_addr;
94  } ComponentEntryData;
95  
96  typedef struct ComponentEntry {
97      ScsiBlockPtr data;
98      uint8_t pad[7];
99      uint8_t component_type;
100      ComponentEntryData compdat;
101  } __attribute((packed)) ComponentEntry;
102  
103  typedef struct ComponentHeader {
104      uint8_t magic[4];   /* == "zIPL"                    */
105      uint8_t type;       /* == ZIPL_COMP_HEADER_*        */
106      uint8_t reserved[27];
107  } __attribute((packed)) ComponentHeader;
108  
109  typedef struct ScsiMbr {
110      uint8_t magic[4];
111      uint32_t version_id;
112      uint8_t reserved[8];
113      ScsiBlockPtr pt;   /* block pointer to program table */
114  } __attribute__ ((packed)) ScsiMbr;
115  
116  #define ZIPL_MAGIC              "zIPL"
117  #define ZIPL_MAGIC_EBCDIC       "\xa9\xc9\xd7\xd3"
118  #define IPL1_MAGIC "\xc9\xd7\xd3\xf1" /* == "IPL1" in EBCDIC */
119  #define IPL2_MAGIC "\xc9\xd7\xd3\xf2" /* == "IPL2" in EBCDIC */
120  #define VOL1_MAGIC "\xe5\xd6\xd3\xf1" /* == "VOL1" in EBCDIC */
121  #define LNX1_MAGIC "\xd3\xd5\xe7\xf1" /* == "LNX1" in EBCDIC */
122  #define CMS1_MAGIC "\xc3\xd4\xe2\xf1" /* == "CMS1" in EBCDIC */
123  
124  #define LDL1_VERSION '\x40' /* == ' ' in EBCDIC */
125  #define LDL2_VERSION '\xf2' /* == '2' in EBCDIC */
126  
127  #define ZIPL_COMP_HEADER_IPL    0x00
128  #define ZIPL_COMP_HEADER_DUMP   0x01
129  
130  #define ZIPL_COMP_ENTRY_EXEC      0x01
131  #define ZIPL_COMP_ENTRY_LOAD      0x02
132  #define ZIPL_COMP_ENTRY_SIGNATURE 0x03
133  
134  typedef struct XEckdMbr {
135      uint8_t magic[4];   /* == "xIPL"        */
136      uint8_t version;
137      uint8_t bp_type;
138      uint8_t dev_type;   /* == DEV_TYPE_*    */
139  #define DEV_TYPE_ECKD 0x00
140  #define DEV_TYPE_FBA  0x01
141      uint8_t flags;
142      BootMapPointer blockptr;
143      uint8_t reserved[8];
144  } __attribute__ ((packed)) XEckdMbr; /* see also BootInfo */
145  
146  typedef struct BootMapScriptEntry {
147      BootMapPointer blkptr;
148      uint8_t pad[7];
149      uint8_t type;   /* == BOOT_SCRIPT_* */
150  #define BOOT_SCRIPT_EXEC      0x01
151  #define BOOT_SCRIPT_LOAD      0x02
152  #define BOOT_SCRIPT_SIGNATURE 0x03
153      union {
154          uint64_t load_address;
155          uint64_t load_psw;
156      } address;
157  } __attribute__ ((packed)) BootMapScriptEntry;
158  
159  typedef struct BootMapScriptHeader {
160      uint32_t magic;
161      uint8_t type;
162  #define BOOT_SCRIPT_HDR_IPL 0x00
163      uint8_t reserved[27];
164  } __attribute__ ((packed)) BootMapScriptHeader;
165  
166  typedef struct BootMapScript {
167      BootMapScriptHeader header;
168      BootMapScriptEntry  entry[];
169  } __attribute__ ((packed)) BootMapScript;
170  
171  /*
172   * These aren't real VTOCs, but referred to this way in some docs.
173   * They are "volume labels" actually.
174   *
175   * Some structures looks similar to described above, but left
176   * separate as there is no indication that they are the same.
177   * So, the value definitions are left separate too.
178   */
179  typedef struct LDL_VTOC {       /* @ rec.3 cyl.0 trk.0 for ECKD */
180      char magic[4];              /* "LNX1", EBCDIC               */
181      char volser[6];             /* volser, EBCDIC               */
182      uint8_t reserved[69];       /* reserved, 0x40               */
183      uint8_t LDL_version;        /* 0x40 or 0xF2                 */
184      uint64_t formatted_blocks;  /* if LDL_version >= 0xF2       */
185  } __attribute__ ((packed)) LDL_VTOC;
186  
187  typedef struct format_date {
188      uint8_t YY;
189      uint8_t MM;
190      uint8_t DD;
191      uint8_t hh;
192      uint8_t mm;
193      uint8_t ss;
194  } __attribute__ ((packed)) format_date_t;
195  
196  typedef struct CMS_VTOC {       /* @ rec.3 cyl.0 trk.0 for ECKD */
197                                  /* @ blk.1 (zero based) for FBA */
198      char magic[4];              /* 'CMS1', EBCDIC               */
199      char volser[6];             /* volser, EBCDIC               */
200      uint16_t version;           /* = 0                          */
201      uint32_t block_size;        /* = 512, 1024, 2048, or 4096   */
202      uint32_t disk_origin;       /* = 4 or 5                     */
203      uint32_t blocks;            /* Number of usable cyls/blocks */
204      uint32_t formatted;         /* Max number of fmtd cyls/blks */
205      uint32_t CMS_blocks;        /* disk size in CMS blocks      */
206      uint32_t CMS_used;          /* Number of CMS blocks in use  */
207      uint32_t FST_size;          /* = 64, bytes                  */
208      uint32_t FST_per_CMS_blk;   /*                              */
209      format_date_t format_date;  /* YYMMDDhhmmss as 6 bytes      */
210      uint8_t reserved1[2];       /* = 0                          */
211      uint32_t offset;            /* disk offset when reserved    */
212      uint32_t next_hole;         /* block nr                     */
213      uint32_t HBLK_hole_offset;  /* >> HBLK data of next hole    */
214      uint32_t alloc_map_usr_off; /* >> user part of Alloc map    */
215      uint8_t reserved2[4];       /* = 0                          */
216      char shared_seg_name[8];    /*                              */
217  } __attribute__ ((packed)) CMS_VTOC;
218  
219  /* from zipl/include/boot.h */
220  typedef struct BootInfoBpIpl {
221      union {
222          ExtEckdBlockPtr eckd;
223          ScsiBlockPtr linr;
224      } bm_ptr;
225      uint8_t unused[16];
226  } __attribute__ ((packed)) BootInfoBpIpl;
227  
228  typedef struct EckdDumpParam {
229      uint32_t        start_blk;
230      uint32_t        end_blk;
231      uint16_t        blocksize;
232      uint8_t         num_heads;
233      uint8_t         bpt;
234      char            reserved[4];
235  } __attribute((packed, may_alias)) EckdDumpParam;
236  
237  typedef struct FbaDumpParam {
238      uint64_t        start_blk;
239      uint64_t        blockct;
240  } __attribute((packed)) FbaDumpParam;
241  
242  typedef struct BootInfoBpDump {
243      union {
244          EckdDumpParam eckd;
245          FbaDumpParam fba;
246      } param;
247      uint8_t         unused[16];
248  } __attribute__ ((packed)) BootInfoBpDump;
249  
250  typedef struct BootInfo {          /* @ 0x70, record #0    */
251      unsigned char magic[4]; /* = 'zIPL', ASCII      */
252      uint8_t version;        /* = 1                  */
253  #define BOOT_INFO_VERSION               1
254      uint8_t bp_type;        /* = 0                  */
255  #define BOOT_INFO_BP_TYPE_IPL           0x00
256  #define BOOT_INFO_BP_TYPE_DUMP          0x01
257      uint8_t dev_type;       /* = 0                  */
258  #define BOOT_INFO_DEV_TYPE_ECKD         0x00
259  #define BOOT_INFO_DEV_TYPE_FBA          0x01
260      uint8_t flags;          /* = 1                  */
261  #ifdef __s390x__
262  #define BOOT_INFO_FLAGS_ARCH            0x01
263  #else
264  #define BOOT_INFO_FLAGS_ARCH            0x00
265  #endif
266      union {
267          BootInfoBpDump dump;
268          BootInfoBpIpl ipl;
269      } bp;
270  } __attribute__ ((packed)) BootInfo; /* see also XEckdMbr   */
271  
272  /*
273   * Structs for IPL
274   */
275  #define STAGE2_BLK_CNT_MAX  24 /* Stage 1b can load up to 24 blocks */
276  
277  typedef struct EckdCdlIpl1 {
278      uint8_t key[4]; /* == "IPL1" */
279      uint8_t data[24];
280  } __attribute__((packed)) EckdCdlIpl1;
281  
282  typedef struct EckdSeekArg {
283      uint16_t pad;
284      EckdCHS chs;
285      uint8_t pad2;
286  } __attribute__ ((packed)) EckdSeekArg;
287  
288  typedef struct EckdStage1b {
289      uint8_t reserved[32 * STAGE2_BLK_CNT_MAX];
290      struct EckdSeekArg seek[STAGE2_BLK_CNT_MAX];
291      uint8_t unused[64];
292  } __attribute__ ((packed)) EckdStage1b;
293  
294  typedef struct EckdStage1 {
295      uint8_t reserved[72];
296      struct EckdSeekArg seek[2];
297  } __attribute__ ((packed)) EckdStage1;
298  
299  typedef struct EckdCdlIpl2 {
300      uint8_t key[4]; /* == "IPL2" */
301      struct EckdStage1 stage1;
302      XEckdMbr mbr;
303      uint8_t reserved[24];
304  } __attribute__((packed)) EckdCdlIpl2;
305  
306  typedef struct EckdLdlIpl1 {
307      uint8_t reserved[24];
308      struct EckdStage1 stage1;
309      BootInfo bip; /* BootInfo is MBR for LDL */
310  } __attribute__((packed)) EckdLdlIpl1;
311  
312  typedef struct IplVolumeLabel {
313      unsigned char key[4]; /* == "VOL1" */
314      union {
315          unsigned char data[80];
316          struct {
317              unsigned char key[4]; /* == "VOL1" */
318              unsigned char volser[6];
319              unsigned char reserved[64];
320              EckdCHS br; /* Location of Boot Record for list-directed IPL */
321          } f;
322      };
323  } __attribute__((packed)) IplVolumeLabel;
324  
325  typedef enum {
326      ECKD_NO_IPL,
327      ECKD_CMS,
328      ECKD_LDL,
329      ECKD_LDL_UNLABELED,
330  } ECKD_IPL_mode_t;
331  
332  /* utility code below */
333  
print_volser(const void * volser)334  static inline void print_volser(const void *volser)
335  {
336      char ascii[8];
337  
338      ebcdic_to_ascii((char *)volser, ascii, 6);
339      ascii[6] = '\0';
340      printf("VOLSER=[%s]\n", ascii);
341  }
342  
unused_space(const void * p,size_t size)343  static inline bool unused_space(const void *p, size_t size)
344  {
345      size_t i;
346      const unsigned char *m = p;
347  
348      for (i = 0; i < size; i++) {
349          if (m[i] != FREE_SPACE_FILLER) {
350              return false;
351          }
352      }
353      return true;
354  }
355  
is_null_block_number(block_number_t x)356  static inline bool is_null_block_number(block_number_t x)
357  {
358      return x == NULL_BLOCK_NR;
359  }
360  
read_block(block_number_t blockno,void * buffer,const char * errmsg)361  static inline void read_block(block_number_t blockno,
362                                void *buffer,
363                                const char *errmsg)
364  {
365      IPL_assert(virtio_read(blockno, buffer) == 0, errmsg);
366  }
367  
block_size_ok(uint32_t block_size)368  static inline bool block_size_ok(uint32_t block_size)
369  {
370      return block_size == virtio_get_block_size();
371  }
372  
magic_match(const void * data,const void * magic)373  static inline bool magic_match(const void *data, const void *magic)
374  {
375      return *((uint32_t *)data) == *((uint32_t *)magic);
376  }
377  
iso_733_to_u32(uint64_t x)378  static inline uint32_t iso_733_to_u32(uint64_t x)
379  {
380      return (uint32_t)x;
381  }
382  
383  #define ISO_SECTOR_SIZE 2048
384  /* El Torito specifies boot image size in 512 byte blocks */
385  #define ET_SECTOR_SHIFT 2
386  
387  #define ISO_PRIMARY_VD_SECTOR 16
388  
read_iso_boot_image(uint32_t block_offset,void * load_addr,uint32_t blks_to_load)389  static inline int read_iso_boot_image(uint32_t block_offset, void *load_addr,
390                                         uint32_t blks_to_load)
391  {
392      if (virtio_read_many(block_offset, load_addr, blks_to_load)) {
393          puts("Failed to read boot image!");
394          return -1;
395      }
396      return 0;
397  }
398  
399  #define ISO9660_MAX_DIR_DEPTH 8
400  
401  typedef struct IsoDirHdr {
402      uint8_t dr_len;
403      uint8_t ear_len;
404      uint64_t ext_loc;
405      uint64_t data_len;
406      uint8_t recording_datetime[7];
407      uint8_t file_flags;
408      uint8_t file_unit_size;
409      uint8_t gap_size;
410      uint32_t vol_seqnum;
411      uint8_t fileid_len;
412  } __attribute__((packed)) IsoDirHdr;
413  
414  typedef struct IsoVdElTorito {
415      uint8_t el_torito[32]; /* must contain el_torito_magic value */
416      uint8_t unused0[32];
417      uint32_t bc_offset;
418      uint8_t unused1[1974];
419  } __attribute__((packed)) IsoVdElTorito;
420  
421  typedef struct IsoVdPrimary {
422      uint8_t unused1;
423      uint8_t sys_id[32];
424      uint8_t vol_id[32];
425      uint8_t unused2[8];
426      uint64_t vol_space_size;
427      uint8_t unused3[32];
428      uint32_t vol_set_size;
429      uint32_t vol_seqnum;
430      uint32_t log_block_size;
431      uint64_t path_table_size;
432      uint32_t l_path_table;
433      uint32_t opt_l_path_table;
434      uint32_t m_path_table;
435      uint32_t opt_m_path_table;
436      IsoDirHdr rootdir;
437      uint8_t root_null;
438      uint8_t reserved2[1858];
439  } __attribute__((packed)) IsoVdPrimary;
440  
441  typedef struct IsoVolDesc {
442      uint8_t type;
443      uint8_t ident[5];
444      uint8_t version;
445      union {
446          IsoVdElTorito boot;
447          IsoVdPrimary primary;
448      } vd;
449  } __attribute__((packed)) IsoVolDesc;
450  
451  #define VOL_DESC_TYPE_BOOT 0
452  #define VOL_DESC_TYPE_PRIMARY 1
453  #define VOL_DESC_TYPE_SUPPLEMENT 2
454  #define VOL_DESC_TYPE_PARTITION 3
455  #define VOL_DESC_TERMINATOR 255
456  
457  typedef struct IsoBcValid {
458      uint8_t platform_id;
459      uint16_t reserved;
460      uint8_t id[24];
461      uint16_t checksum;
462      uint8_t key[2];
463  } __attribute__((packed)) IsoBcValid;
464  
465  typedef struct IsoBcSection {
466      uint8_t boot_type;
467      uint16_t load_segment;
468      uint8_t sys_type;
469      uint8_t unused;
470      uint16_t sector_count;
471      uint32_t load_rba;
472      uint8_t selection[20];
473  } __attribute__((packed)) IsoBcSection;
474  
475  typedef struct IsoBcHdr {
476      uint8_t platform_id;
477      uint16_t sect_num;
478      uint8_t id[28];
479  } __attribute__((packed)) IsoBcHdr;
480  
481  typedef struct IsoBcEntry {
482      uint8_t id;
483      union {
484          IsoBcValid valid; /* id == 0x01 */
485          IsoBcSection sect; /* id == 0x88 || id == 0x0 */
486          IsoBcHdr hdr; /* id == 0x90 || id == 0x91 */
487      } body;
488  } __attribute__((packed)) IsoBcEntry;
489  
490  #define ISO_BC_ENTRY_PER_SECTOR (ISO_SECTOR_SIZE / sizeof(IsoBcEntry))
491  #define ISO_BC_HDR_VALIDATION 0x01
492  #define ISO_BC_BOOTABLE_SECTION 0x88
493  #define ISO_BC_MAGIC_55 0x55
494  #define ISO_BC_MAGIC_AA 0xaa
495  #define ISO_BC_PLATFORM_X86 0x0
496  #define ISO_BC_PLATFORM_PPC 0x1
497  #define ISO_BC_PLATFORM_MAC 0x2
498  
is_iso_bc_valid(IsoBcEntry * e)499  static inline bool is_iso_bc_valid(IsoBcEntry *e)
500  {
501      IsoBcValid *v = &e->body.valid;
502  
503      if (e->id != ISO_BC_HDR_VALIDATION) {
504          return false;
505      }
506  
507      if (v->platform_id != ISO_BC_PLATFORM_X86 &&
508          v->platform_id != ISO_BC_PLATFORM_PPC &&
509          v->platform_id != ISO_BC_PLATFORM_MAC) {
510          return false;
511      }
512  
513      return v->key[0] == ISO_BC_MAGIC_55 &&
514             v->key[1] == ISO_BC_MAGIC_AA &&
515             v->reserved == 0x0;
516  }
517  
518  #endif /* _PC_BIOS_S390_CCW_BOOTMAP_H */
519