2 * QEMU S390 bootmap interpreter
4 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
6 * This work is licensed under the terms of the GNU GPL, version 2 or (at
7 * your option) any later version. See the COPYING file in the top-level
16 /* #define DEBUG_FALLBACK */
21 do { sclp_print("zipl: " txt); } while (0)
23 #define dputs(fmt, ...) \
28 static uint8_t sec
[MAX_SECTOR_SIZE
*4] __attribute__((__aligned__(PAGE_SIZE
)));
30 typedef struct ResetInfo
{
33 uint32_t ipl_continue
;
36 static ResetInfo save
;
38 static void jump_to_IPL_2(void)
40 ResetInfo
*current
= 0;
42 void (*ipl
)(void) = (void *) (uint64_t) current
->ipl_continue
;
44 ipl(); /* should not return */
47 static void jump_to_IPL_code(uint64_t address
)
49 /* store the subsystem information _after_ the bootmap was loaded */
50 write_subsystem_identification();
52 * The IPL PSW is at address 0. We also must not overwrite the
53 * content of non-BIOS memory after we loaded the guest, so we
54 * save the original content and restore it in jump_to_IPL_2.
56 ResetInfo
*current
= 0;
59 current
->ipl_addr
= (uint32_t) (uint64_t) &jump_to_IPL_2
;
60 current
->ipl_continue
= address
& 0x7fffffff;
62 debug_print_int("set IPL addr to", current
->ipl_continue
);
64 /* Ensure the guest output starts fresh */
69 * We use the load normal reset to keep r15 unchanged. jump_to_IPL_2
70 * can then use r15 as its stack pointer.
72 asm volatile("lghi 1,1\n\t"
75 panic("\n! IPL returns !\n");
78 /***********************************************************************
79 * IPL an ECKD DASD (CDL or LDL/CMS format)
82 static unsigned char _bprs
[8*1024]; /* guessed "max" ECKD sector size */
83 static const int max_bprs_entries
= sizeof(_bprs
) / sizeof(ExtEckdBlockPtr
);
85 static inline void verify_boot_info(BootInfo
*bip
)
87 IPL_assert(magic_match(bip
->magic
, ZIPL_MAGIC
), "No zIPL sig in BootInfo");
88 IPL_assert(bip
->version
== BOOT_INFO_VERSION
, "Wrong zIPL version");
89 IPL_assert(bip
->bp_type
== BOOT_INFO_BP_TYPE_IPL
, "DASD is not for IPL");
90 IPL_assert(bip
->dev_type
== BOOT_INFO_DEV_TYPE_ECKD
, "DASD is not ECKD");
91 IPL_assert(bip
->flags
== BOOT_INFO_FLAGS_ARCH
, "Not for this arch");
92 IPL_assert(block_size_ok(bip
->bp
.ipl
.bm_ptr
.eckd
.bptr
.size
),
93 "Bad block size in zIPL section of the 1st record.");
96 static block_number_t
eckd_block_num(BootMapPointer
*p
)
98 const uint64_t sectors
= virtio_get_sectors();
99 const uint64_t heads
= virtio_get_heads();
100 const uint64_t cylinder
= p
->eckd
.cylinder
101 + ((p
->eckd
.head
& 0xfff0) << 12);
102 const uint64_t head
= p
->eckd
.head
& 0x000f;
103 const block_number_t block
= sectors
* heads
* cylinder
106 - 1; /* block nr starts with zero */
110 static bool eckd_valid_address(BootMapPointer
*p
)
112 const uint64_t head
= p
->eckd
.head
& 0x000f;
114 if (head
>= virtio_get_heads()
115 || p
->eckd
.sector
> virtio_get_sectors()
116 || p
->eckd
.sector
<= 0) {
120 if (!virtio_guessed_disk_nature() &&
121 eckd_block_num(p
) >= virtio_get_blocks()) {
128 static block_number_t
load_eckd_segments(block_number_t blk
, uint64_t *address
)
130 block_number_t block_nr
;
132 BootMapPointer
*bprs
= (void *)_bprs
;
135 memset(_bprs
, FREE_SPACE_FILLER
, sizeof(_bprs
));
136 read_block(blk
, bprs
, "BPRS read failed");
141 block_nr
= eckd_block_num((void *)&(bprs
[j
].xeckd
));
142 if (is_null_block_number(block_nr
)) { /* end of chunk */
146 /* we need the updated blockno for the next indirect entry
147 * in the chain, but don't want to advance address
149 if (j
== (max_bprs_entries
- 1)) {
153 IPL_assert(block_size_ok(bprs
[j
].xeckd
.bptr
.size
),
154 "bad chunk block size");
155 IPL_assert(eckd_valid_address(&bprs
[j
]), "bad chunk ECKD addr");
157 if ((bprs
[j
].xeckd
.bptr
.count
== 0) && unused_space(&(bprs
[j
+1]),
158 sizeof(EckdBlockPtr
))) {
159 /* This is a "continue" pointer.
160 * This ptr should be the last one in the current
162 * I.e. the next ptr must point to the unused memory area
164 memset(_bprs
, FREE_SPACE_FILLER
, sizeof(_bprs
));
165 read_block(block_nr
, bprs
, "BPRS continuation read failed");
170 /* Load (count+1) blocks of code at (block_nr)
171 * to memory (address).
173 rc
= virtio_read_many(block_nr
, (void *)(*address
),
174 bprs
[j
].xeckd
.bptr
.count
+1);
175 IPL_assert(rc
== 0, "code chunk read failed");
177 *address
+= (bprs
[j
].xeckd
.bptr
.count
+1) * virtio_get_block_size();
183 static void run_eckd_boot_script(block_number_t mbr_block_nr
)
186 unsigned int loadparm
= get_loadparm_index();
187 block_number_t block_nr
;
189 ScsiMbr
*bte
= (void *)sec
; /* Eckd bootmap table entry */
190 BootMapScript
*bms
= (void *)sec
;
192 debug_print_int("loadparm", loadparm
);
193 IPL_assert(loadparm
< 31, "loadparm value greater than"
194 " maximum number of boot entries allowed");
196 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
197 read_block(mbr_block_nr
, sec
, "Cannot read MBR");
199 block_nr
= eckd_block_num((void *)&(bte
->blockptr
[loadparm
]));
200 IPL_assert(block_nr
!= -1, "No Boot Map");
202 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
203 read_block(block_nr
, sec
, "Cannot read Boot Map Script");
205 for (i
= 0; bms
->entry
[i
].type
== BOOT_SCRIPT_LOAD
; i
++) {
206 address
= bms
->entry
[i
].address
.load_address
;
207 block_nr
= eckd_block_num(&(bms
->entry
[i
].blkptr
));
210 block_nr
= load_eckd_segments(block_nr
, &address
);
211 } while (block_nr
!= -1);
214 IPL_assert(bms
->entry
[i
].type
== BOOT_SCRIPT_EXEC
,
215 "Unknown script entry type");
216 jump_to_IPL_code(bms
->entry
[i
].address
.load_address
); /* no return */
219 static void ipl_eckd_cdl(void)
222 Ipl2
*ipl2
= (void *)sec
;
223 IplVolumeLabel
*vlbl
= (void *)sec
;
224 block_number_t block_nr
;
226 /* we have just read the block #0 and recognized it as "IPL1" */
229 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
230 read_block(1, ipl2
, "Cannot read IPL2 record at block 1");
232 mbr
= &ipl2
->u
.x
.mbr
;
233 IPL_assert(magic_match(mbr
, ZIPL_MAGIC
), "No zIPL section in IPL2 record.");
234 IPL_assert(block_size_ok(mbr
->blockptr
.xeckd
.bptr
.size
),
235 "Bad block size in zIPL section of IPL2 record.");
236 IPL_assert(mbr
->dev_type
== DEV_TYPE_ECKD
,
237 "Non-ECKD device type in zIPL section of IPL2 record.");
239 /* save pointer to Boot Script */
240 block_nr
= eckd_block_num((void *)&(mbr
->blockptr
));
242 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
243 read_block(2, vlbl
, "Cannot read Volume Label at block 2");
244 IPL_assert(magic_match(vlbl
->key
, VOL1_MAGIC
),
245 "Invalid magic of volume label block");
246 IPL_assert(magic_match(vlbl
->f
.key
, VOL1_MAGIC
),
247 "Invalid magic of volser block");
248 print_volser(vlbl
->f
.volser
);
250 run_eckd_boot_script(block_nr
);
254 static void print_eckd_ldl_msg(ECKD_IPL_mode_t mode
)
256 LDL_VTOC
*vlbl
= (void *)sec
; /* already read, 3rd block */
257 char msg
[4] = { '?', '.', '\n', '\0' };
259 sclp_print((mode
== ECKD_CMS
) ? "CMS" : "LDL");
260 sclp_print(" version ");
261 switch (vlbl
->LDL_version
) {
269 msg
[0] = vlbl
->LDL_version
;
270 msg
[0] &= 0x0f; /* convert EBCDIC */
271 msg
[0] |= 0x30; /* to ASCII (digit) */
276 print_volser(vlbl
->volser
);
279 static void ipl_eckd_ldl(ECKD_IPL_mode_t mode
)
281 block_number_t block_nr
;
282 BootInfo
*bip
= (void *)(sec
+ 0x70); /* BootInfo is MBR for LDL */
284 if (mode
!= ECKD_LDL_UNLABELED
) {
285 print_eckd_ldl_msg(mode
);
288 /* DO NOT read BootMap pointer (only one, xECKD) at block #2 */
290 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
291 read_block(0, sec
, "Cannot read block 0 to grab boot info.");
292 if (mode
== ECKD_LDL_UNLABELED
) {
293 if (!magic_match(bip
->magic
, ZIPL_MAGIC
)) {
294 return; /* not applicable layout */
296 sclp_print("unlabeled LDL.\n");
298 verify_boot_info(bip
);
300 block_nr
= eckd_block_num((void *)&(bip
->bp
.ipl
.bm_ptr
.eckd
.bptr
));
301 run_eckd_boot_script(block_nr
);
305 static void print_eckd_msg(void)
307 char msg
[] = "Using ECKD scheme (block size *****), ";
308 char *p
= &msg
[34], *q
= &msg
[30];
309 int n
= virtio_get_block_size();
311 /* Fill in the block size and show up the message */
312 if (n
> 0 && n
<= 99999) {
314 *p
-- = '0' + (n
% 10);
324 static void ipl_eckd(void)
326 ScsiMbr
*mbr
= (void *)sec
;
327 LDL_VTOC
*vlbl
= (void *)sec
;
331 /* Grab the MBR again */
332 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
333 read_block(0, mbr
, "Cannot read block 0 on DASD");
335 if (magic_match(mbr
->magic
, IPL1_MAGIC
)) {
336 ipl_eckd_cdl(); /* no return */
340 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
341 read_block(2, vlbl
, "Cannot read block 2");
343 if (magic_match(vlbl
->magic
, CMS1_MAGIC
)) {
344 ipl_eckd_ldl(ECKD_CMS
); /* no return */
346 if (magic_match(vlbl
->magic
, LNX1_MAGIC
)) {
347 ipl_eckd_ldl(ECKD_LDL
); /* no return */
350 ipl_eckd_ldl(ECKD_LDL_UNLABELED
); /* it still may return */
352 * Ok, it is not a LDL by any means.
353 * It still might be a CDL with zero record keys for IPL1 and IPL2
358 /***********************************************************************
362 static void zipl_load_segment(ComponentEntry
*entry
)
364 const int max_entries
= (MAX_SECTOR_SIZE
/ sizeof(ScsiBlockPtr
));
365 ScsiBlockPtr
*bprs
= (void *)sec
;
366 const int bprs_size
= sizeof(sec
);
367 block_number_t blockno
;
370 char err_msg
[] = "zIPL failed to read BPRS at 0xZZZZZZZZZZZZZZZZ";
371 char *blk_no
= &err_msg
[30]; /* where to print blockno in (those ZZs) */
373 blockno
= entry
->data
.blockno
;
374 address
= entry
->load_address
;
376 debug_print_int("loading segment at block", blockno
);
377 debug_print_int("addr", address
);
380 memset(bprs
, FREE_SPACE_FILLER
, bprs_size
);
381 fill_hex_val(blk_no
, &blockno
, sizeof(blockno
));
382 read_block(blockno
, bprs
, err_msg
);
385 uint64_t *cur_desc
= (void *)&bprs
[i
];
387 blockno
= bprs
[i
].blockno
;
392 /* we need the updated blockno for the next indirect entry in the
393 chain, but don't want to advance address */
394 if (i
== (max_entries
- 1)) {
398 if (bprs
[i
].blockct
== 0 && unused_space(&bprs
[i
+ 1],
399 sizeof(ScsiBlockPtr
))) {
400 /* This is a "continue" pointer.
401 * This ptr is the last one in the current script section.
402 * I.e. the next ptr must point to the unused memory area.
403 * The blockno is not zero, so the upper loop must continue
404 * reading next section of BPRS.
408 address
= virtio_load_direct(cur_desc
[0], cur_desc
[1], 0,
410 IPL_assert(address
!= -1, "zIPL load segment failed");
415 /* Run a zipl program */
416 static void zipl_run(ScsiBlockPtr
*pte
)
418 ComponentHeader
*header
;
419 ComponentEntry
*entry
;
420 uint8_t tmp_sec
[MAX_SECTOR_SIZE
];
422 read_block(pte
->blockno
, tmp_sec
, "Cannot read header");
423 header
= (ComponentHeader
*)tmp_sec
;
425 IPL_assert(magic_match(tmp_sec
, ZIPL_MAGIC
), "No zIPL magic in header");
426 IPL_assert(header
->type
== ZIPL_COMP_HEADER_IPL
, "Bad header type");
428 dputs("start loading images\n");
430 /* Load image(s) into RAM */
431 entry
= (ComponentEntry
*)(&header
[1]);
432 while (entry
->component_type
== ZIPL_COMP_ENTRY_LOAD
) {
433 zipl_load_segment(entry
);
437 IPL_assert((uint8_t *)(&entry
[1]) <= (tmp_sec
+ MAX_SECTOR_SIZE
),
438 "Wrong entry value");
441 IPL_assert(entry
->component_type
== ZIPL_COMP_ENTRY_EXEC
, "No EXEC entry");
443 /* should not return */
444 jump_to_IPL_code(entry
->load_address
);
447 static void ipl_scsi(void)
449 ScsiMbr
*mbr
= (void *)sec
;
450 uint8_t *ns
, *ns_end
;
451 int program_table_entries
= 0;
452 const int pte_len
= sizeof(ScsiBlockPtr
);
453 ScsiBlockPtr
*prog_table_entry
= NULL
;
454 unsigned int loadparm
= get_loadparm_index();
457 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
458 read_block(0, mbr
, "Cannot read block 0");
460 if (!magic_match(mbr
->magic
, ZIPL_MAGIC
)) {
464 sclp_print("Using SCSI scheme.\n");
465 debug_print_int("MBR Version", mbr
->version_id
);
466 IPL_check(mbr
->version_id
== 1,
467 "Unknown MBR layout version, assuming version 1");
468 debug_print_int("program table", mbr
->blockptr
[0].blockno
);
469 IPL_assert(mbr
->blockptr
[0].blockno
, "No Program Table");
471 /* Parse the program table */
472 read_block(mbr
->blockptr
[0].blockno
, sec
,
473 "Error reading Program Table");
475 IPL_assert(magic_match(sec
, ZIPL_MAGIC
), "No zIPL magic in PT");
477 debug_print_int("loadparm index", loadparm
);
478 ns_end
= sec
+ virtio_get_block_size();
479 for (ns
= (sec
+ pte_len
); (ns
+ pte_len
) < ns_end
; ns
+= pte_len
) {
480 prog_table_entry
= (ScsiBlockPtr
*)ns
;
481 if (!prog_table_entry
->blockno
) {
485 program_table_entries
++;
486 if (program_table_entries
== loadparm
+ 1) {
487 break; /* selected entry found */
491 debug_print_int("program table entries", program_table_entries
);
493 IPL_assert(program_table_entries
!= 0, "Empty Program Table");
495 zipl_run(prog_table_entry
); /* no return */
498 /***********************************************************************
499 * IPL El Torito ISO9660 image or DVD
502 static bool is_iso_bc_entry_compatible(IsoBcSection
*s
)
504 uint8_t *magic_sec
= (uint8_t *)(sec
+ ISO_SECTOR_SIZE
);
506 if (s
->unused
|| !s
->sector_count
) {
509 read_iso_sector(bswap32(s
->load_rba
), magic_sec
,
510 "Failed to read image sector 0");
512 /* Checking bytes 8 - 32 for S390 Linux magic */
513 return !_memcmp(magic_sec
+ 8, linux_s390_magic
, 24);
516 /* Location of the current sector of the directory */
517 static uint32_t sec_loc
[ISO9660_MAX_DIR_DEPTH
];
518 /* Offset in the current sector of the directory */
519 static uint32_t sec_offset
[ISO9660_MAX_DIR_DEPTH
];
520 /* Remained directory space in bytes */
521 static uint32_t dir_rem
[ISO9660_MAX_DIR_DEPTH
];
523 static inline uint32_t iso_get_file_size(uint32_t load_rba
)
525 IsoVolDesc
*vd
= (IsoVolDesc
*)sec
;
526 IsoDirHdr
*cur_record
= &vd
->vd
.primary
.rootdir
;
527 uint8_t *temp
= sec
+ ISO_SECTOR_SIZE
;
530 read_iso_sector(ISO_PRIMARY_VD_SECTOR
, sec
,
531 "Failed to read ISO primary descriptor");
532 sec_loc
[0] = iso_733_to_u32(cur_record
->ext_loc
);
537 IPL_assert(sec_offset
[level
] <= ISO_SECTOR_SIZE
,
538 "Directory tree structure violation");
540 cur_record
= (IsoDirHdr
*)(temp
+ sec_offset
[level
]);
542 if (sec_offset
[level
] == 0) {
543 read_iso_sector(sec_loc
[level
], temp
,
544 "Failed to read ISO directory");
545 if (dir_rem
[level
] == 0) {
546 /* Skip self and parent records */
547 dir_rem
[level
] = iso_733_to_u32(cur_record
->data_len
) -
549 sec_offset
[level
] += cur_record
->dr_len
;
551 cur_record
= (IsoDirHdr
*)(temp
+ sec_offset
[level
]);
552 dir_rem
[level
] -= cur_record
->dr_len
;
553 sec_offset
[level
] += cur_record
->dr_len
;
558 if (!cur_record
->dr_len
|| sec_offset
[level
] == ISO_SECTOR_SIZE
) {
559 /* Zero-padding and/or the end of current sector */
560 dir_rem
[level
] -= ISO_SECTOR_SIZE
- sec_offset
[level
];
561 sec_offset
[level
] = 0;
564 /* The directory record is valid */
565 if (load_rba
== iso_733_to_u32(cur_record
->ext_loc
)) {
566 return iso_733_to_u32(cur_record
->data_len
);
569 dir_rem
[level
] -= cur_record
->dr_len
;
570 sec_offset
[level
] += cur_record
->dr_len
;
572 if (cur_record
->file_flags
& 0x2) {
574 if (level
== ISO9660_MAX_DIR_DEPTH
- 1) {
575 sclp_print("ISO-9660 directory depth limit exceeded\n");
578 sec_loc
[level
] = iso_733_to_u32(cur_record
->ext_loc
);
579 sec_offset
[level
] = 0;
586 if (dir_rem
[level
] == 0) {
587 /* Nothing remaining */
589 read_iso_sector(sec_loc
[level
], temp
,
590 "Failed to read ISO directory");
597 static void load_iso_bc_entry(IsoBcSection
*load
)
599 IsoBcSection s
= *load
;
601 * According to spec, extent for each file
602 * is padded and ISO_SECTOR_SIZE bytes aligned
604 uint32_t blks_to_load
= bswap16(s
.sector_count
) >> ET_SECTOR_SHIFT
;
605 uint32_t real_size
= iso_get_file_size(bswap32(s
.load_rba
));
608 /* Round up blocks to load */
609 blks_to_load
= (real_size
+ ISO_SECTOR_SIZE
- 1) / ISO_SECTOR_SIZE
;
610 sclp_print("ISO boot image size verified\n");
612 sclp_print("ISO boot image size could not be verified\n");
615 read_iso_boot_image(bswap32(s
.load_rba
),
616 (void *)((uint64_t)bswap16(s
.load_segment
)),
619 /* Trying to get PSW at zero address */
620 if (*((uint64_t *)0) & IPL_PSW_MASK
) {
621 jump_to_IPL_code((*((uint64_t *)0)) & 0x7fffffff);
624 /* Try default linux start address */
625 jump_to_IPL_code(KERN_IMAGE_START
);
628 static uint32_t find_iso_bc(void)
630 IsoVolDesc
*vd
= (IsoVolDesc
*)sec
;
631 uint32_t block_num
= ISO_PRIMARY_VD_SECTOR
;
633 if (virtio_read_many(block_num
++, sec
, 1)) {
634 /* If primary vd cannot be read, there is no boot catalog */
638 while (is_iso_vd_valid(vd
) && vd
->type
!= VOL_DESC_TERMINATOR
) {
639 if (vd
->type
== VOL_DESC_TYPE_BOOT
) {
640 IsoVdElTorito
*et
= &vd
->vd
.boot
;
642 if (!_memcmp(&et
->el_torito
[0], el_torito_magic
, 32)) {
643 return bswap32(et
->bc_offset
);
646 read_iso_sector(block_num
++, sec
,
647 "Failed to read ISO volume descriptor");
653 static IsoBcSection
*find_iso_bc_entry(void)
655 IsoBcEntry
*e
= (IsoBcEntry
*)sec
;
656 uint32_t offset
= find_iso_bc();
658 unsigned int loadparm
= get_loadparm_index();
664 read_iso_sector(offset
, sec
, "Failed to read El Torito boot catalog");
666 if (!is_iso_bc_valid(e
)) {
667 /* The validation entry is mandatory */
668 panic("No valid boot catalog found!\n");
673 * Each entry has 32 bytes size, so one sector cannot contain > 64 entries.
674 * We consider only boot catalogs with no more than 64 entries.
676 for (i
= 1; i
< ISO_BC_ENTRY_PER_SECTOR
; i
++) {
677 if (e
[i
].id
== ISO_BC_BOOTABLE_SECTION
) {
678 if (is_iso_bc_entry_compatible(&e
[i
].body
.sect
)) {
680 /* found, default, or unspecified */
681 return &e
[i
].body
.sect
;
688 panic("No suitable boot entry found on ISO-9660 media!\n");
693 static void ipl_iso_el_torito(void)
695 IsoBcSection
*s
= find_iso_bc_entry();
698 load_iso_bc_entry(s
);
703 /***********************************************************************
704 * Bus specific IPL sequences
707 static void zipl_load_vblk(void)
709 if (virtio_guessed_disk_nature()) {
710 virtio_assume_iso9660();
714 if (virtio_guessed_disk_nature()) {
715 sclp_print("Using guessed DASD geometry.\n");
716 virtio_assume_eckd();
721 static void zipl_load_vscsi(void)
723 if (virtio_get_block_size() == VIRTIO_ISO_BLOCK_SIZE
) {
724 /* Is it an ISO image in non-CD drive? */
728 sclp_print("Using guessed DASD geometry.\n");
729 virtio_assume_eckd();
733 /***********************************************************************
739 VDev
*vdev
= virtio_get_device();
741 if (vdev
->is_cdrom
) {
743 panic("\n! Cannot IPL this ISO image !\n");
746 if (virtio_get_device_type() == VIRTIO_ID_NET
) {
747 jump_to_IPL_code(vdev
->netboot_start_addr
);
752 switch (virtio_get_device_type()) {
753 case VIRTIO_ID_BLOCK
:
760 panic("\n! Unknown IPL device type !\n");
763 panic("\n* this can never happen *\n");