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
18 /* #define DEBUG_FALLBACK */
23 do { sclp_print("zipl: " txt); } while (0)
25 #define dputs(fmt, ...) \
30 static uint8_t sec
[MAX_SECTOR_SIZE
*4] __attribute__((__aligned__(PAGE_SIZE
)));
32 typedef struct ResetInfo
{
35 uint32_t ipl_continue
;
38 static ResetInfo save
;
40 const uint8_t el_torito_magic
[] = "EL TORITO SPECIFICATION"
41 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
44 * Match two CCWs located after PSW and eight filler bytes.
45 * From libmagic and arch/s390/kernel/head.S.
47 const uint8_t linux_s390_magic
[] = "\x02\x00\x00\x18\x60\x00\x00\x50\x02\x00"
48 "\x00\x68\x60\x00\x00\x50\x40\x40\x40\x40"
51 static inline bool is_iso_vd_valid(IsoVolDesc
*vd
)
53 const uint8_t vol_desc_magic
[] = "CD001";
55 return !memcmp(&vd
->ident
[0], vol_desc_magic
, 5) &&
57 vd
->type
<= VOL_DESC_TYPE_PARTITION
;
60 static void jump_to_IPL_2(void)
62 ResetInfo
*current
= 0;
64 void (*ipl
)(void) = (void *) (uint64_t) current
->ipl_continue
;
66 ipl(); /* should not return */
69 static void jump_to_IPL_code(uint64_t address
)
71 /* store the subsystem information _after_ the bootmap was loaded */
72 write_subsystem_identification();
74 /* prevent unknown IPL types in the guest */
75 if (iplb
.pbt
== S390_IPL_TYPE_QEMU_SCSI
) {
76 iplb
.pbt
= S390_IPL_TYPE_CCW
;
81 * The IPL PSW is at address 0. We also must not overwrite the
82 * content of non-BIOS memory after we loaded the guest, so we
83 * save the original content and restore it in jump_to_IPL_2.
85 ResetInfo
*current
= 0;
88 current
->ipl_addr
= (uint32_t) (uint64_t) &jump_to_IPL_2
;
89 current
->ipl_continue
= address
& 0x7fffffff;
91 debug_print_int("set IPL addr to", current
->ipl_continue
);
93 /* Ensure the guest output starts fresh */
98 * We use the load normal reset to keep r15 unchanged. jump_to_IPL_2
99 * can then use r15 as its stack pointer.
101 asm volatile("lghi 1,1\n\t"
103 : : : "1", "memory");
104 panic("\n! IPL returns !\n");
107 /***********************************************************************
108 * IPL an ECKD DASD (CDL or LDL/CMS format)
111 static unsigned char _bprs
[8*1024]; /* guessed "max" ECKD sector size */
112 static const int max_bprs_entries
= sizeof(_bprs
) / sizeof(ExtEckdBlockPtr
);
113 static uint8_t _s2
[MAX_SECTOR_SIZE
* 3] __attribute__((__aligned__(PAGE_SIZE
)));
114 static void *s2_prev_blk
= _s2
;
115 static void *s2_cur_blk
= _s2
+ MAX_SECTOR_SIZE
;
116 static void *s2_next_blk
= _s2
+ MAX_SECTOR_SIZE
* 2;
118 static inline void verify_boot_info(BootInfo
*bip
)
120 IPL_assert(magic_match(bip
->magic
, ZIPL_MAGIC
), "No zIPL sig in BootInfo");
121 IPL_assert(bip
->version
== BOOT_INFO_VERSION
, "Wrong zIPL version");
122 IPL_assert(bip
->bp_type
== BOOT_INFO_BP_TYPE_IPL
, "DASD is not for IPL");
123 IPL_assert(bip
->dev_type
== BOOT_INFO_DEV_TYPE_ECKD
, "DASD is not ECKD");
124 IPL_assert(bip
->flags
== BOOT_INFO_FLAGS_ARCH
, "Not for this arch");
125 IPL_assert(block_size_ok(bip
->bp
.ipl
.bm_ptr
.eckd
.bptr
.size
),
126 "Bad block size in zIPL section of the 1st record.");
129 static block_number_t
eckd_block_num(EckdCHS
*chs
)
131 const uint64_t sectors
= virtio_get_sectors();
132 const uint64_t heads
= virtio_get_heads();
133 const uint64_t cylinder
= chs
->cylinder
134 + ((chs
->head
& 0xfff0) << 12);
135 const uint64_t head
= chs
->head
& 0x000f;
136 const block_number_t block
= sectors
* heads
* cylinder
139 - 1; /* block nr starts with zero */
143 static bool eckd_valid_address(BootMapPointer
*p
)
145 const uint64_t head
= p
->eckd
.chs
.head
& 0x000f;
147 if (head
>= virtio_get_heads()
148 || p
->eckd
.chs
.sector
> virtio_get_sectors()
149 || p
->eckd
.chs
.sector
<= 0) {
153 if (!virtio_guessed_disk_nature() &&
154 eckd_block_num(&p
->eckd
.chs
) >= virtio_get_blocks()) {
161 static block_number_t
load_eckd_segments(block_number_t blk
, uint64_t *address
)
163 block_number_t block_nr
;
165 BootMapPointer
*bprs
= (void *)_bprs
;
168 memset(_bprs
, FREE_SPACE_FILLER
, sizeof(_bprs
));
169 read_block(blk
, bprs
, "BPRS read failed");
174 block_nr
= eckd_block_num(&bprs
[j
].xeckd
.bptr
.chs
);
175 if (is_null_block_number(block_nr
)) { /* end of chunk */
179 /* we need the updated blockno for the next indirect entry
180 * in the chain, but don't want to advance address
182 if (j
== (max_bprs_entries
- 1)) {
186 IPL_assert(block_size_ok(bprs
[j
].xeckd
.bptr
.size
),
187 "bad chunk block size");
188 IPL_assert(eckd_valid_address(&bprs
[j
]), "bad chunk ECKD addr");
190 if ((bprs
[j
].xeckd
.bptr
.count
== 0) && unused_space(&(bprs
[j
+1]),
191 sizeof(EckdBlockPtr
))) {
192 /* This is a "continue" pointer.
193 * This ptr should be the last one in the current
195 * I.e. the next ptr must point to the unused memory area
197 memset(_bprs
, FREE_SPACE_FILLER
, sizeof(_bprs
));
198 read_block(block_nr
, bprs
, "BPRS continuation read failed");
203 /* Load (count+1) blocks of code at (block_nr)
204 * to memory (address).
206 rc
= virtio_read_many(block_nr
, (void *)(*address
),
207 bprs
[j
].xeckd
.bptr
.count
+1);
208 IPL_assert(rc
== 0, "code chunk read failed");
210 *address
+= (bprs
[j
].xeckd
.bptr
.count
+1) * virtio_get_block_size();
216 static bool find_zipl_boot_menu_banner(int *offset
)
220 /* Menu banner starts with "zIPL" */
221 for (i
= 0; i
< virtio_get_block_size() - 4; i
++) {
222 if (magic_match(s2_cur_blk
+ i
, ZIPL_MAGIC_EBCDIC
)) {
231 static int eckd_get_boot_menu_index(block_number_t s1b_block_nr
)
233 block_number_t cur_block_nr
;
234 block_number_t prev_block_nr
= 0;
235 block_number_t next_block_nr
= 0;
236 EckdStage1b
*s1b
= (void *)sec
;
240 /* Get Stage1b data */
241 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
242 read_block(s1b_block_nr
, s1b
, "Cannot read stage1b boot loader");
244 memset(_s2
, FREE_SPACE_FILLER
, sizeof(_s2
));
246 /* Get Stage2 data */
247 for (i
= 0; i
< STAGE2_BLK_CNT_MAX
; i
++) {
248 cur_block_nr
= eckd_block_num(&s1b
->seek
[i
].chs
);
254 read_block(cur_block_nr
, s2_cur_blk
, "Cannot read stage2 boot loader");
256 if (find_zipl_boot_menu_banner(&banner_offset
)) {
258 * Load the adjacent blocks to account for the
259 * possibility of menu data spanning multiple blocks.
262 read_block(prev_block_nr
, s2_prev_blk
,
263 "Cannot read stage2 boot loader");
266 if (i
+ 1 < STAGE2_BLK_CNT_MAX
) {
267 next_block_nr
= eckd_block_num(&s1b
->seek
[i
+ 1].chs
);
271 read_block(next_block_nr
, s2_next_blk
,
272 "Cannot read stage2 boot loader");
275 return menu_get_zipl_boot_index(s2_cur_blk
+ banner_offset
);
278 prev_block_nr
= cur_block_nr
;
281 sclp_print("No zipl boot menu data found. Booting default entry.");
285 static void run_eckd_boot_script(block_number_t bmt_block_nr
,
286 block_number_t s1b_block_nr
)
289 unsigned int loadparm
= get_loadparm_index();
290 block_number_t block_nr
;
292 BootMapTable
*bmt
= (void *)sec
;
293 BootMapScript
*bms
= (void *)sec
;
295 if (menu_is_enabled_zipl()) {
296 loadparm
= eckd_get_boot_menu_index(s1b_block_nr
);
299 debug_print_int("loadparm", loadparm
);
300 IPL_assert(loadparm
<= MAX_TABLE_ENTRIES
, "loadparm value greater than"
301 " maximum number of boot entries allowed");
303 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
304 read_block(bmt_block_nr
, sec
, "Cannot read Boot Map Table");
306 block_nr
= eckd_block_num(&bmt
->entry
[loadparm
].xeckd
.bptr
.chs
);
307 IPL_assert(block_nr
!= -1, "Cannot find Boot Map Table Entry");
309 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
310 read_block(block_nr
, sec
, "Cannot read Boot Map Script");
312 for (i
= 0; bms
->entry
[i
].type
== BOOT_SCRIPT_LOAD
; i
++) {
313 address
= bms
->entry
[i
].address
.load_address
;
314 block_nr
= eckd_block_num(&bms
->entry
[i
].blkptr
.xeckd
.bptr
.chs
);
317 block_nr
= load_eckd_segments(block_nr
, &address
);
318 } while (block_nr
!= -1);
321 IPL_assert(bms
->entry
[i
].type
== BOOT_SCRIPT_EXEC
,
322 "Unknown script entry type");
323 jump_to_IPL_code(bms
->entry
[i
].address
.load_address
); /* no return */
326 static void ipl_eckd_cdl(void)
329 EckdCdlIpl2
*ipl2
= (void *)sec
;
330 IplVolumeLabel
*vlbl
= (void *)sec
;
331 block_number_t bmt_block_nr
, s1b_block_nr
;
333 /* we have just read the block #0 and recognized it as "IPL1" */
336 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
337 read_block(1, ipl2
, "Cannot read IPL2 record at block 1");
340 IPL_assert(magic_match(mbr
, ZIPL_MAGIC
), "No zIPL section in IPL2 record.");
341 IPL_assert(block_size_ok(mbr
->blockptr
.xeckd
.bptr
.size
),
342 "Bad block size in zIPL section of IPL2 record.");
343 IPL_assert(mbr
->dev_type
== DEV_TYPE_ECKD
,
344 "Non-ECKD device type in zIPL section of IPL2 record.");
346 /* save pointer to Boot Map Table */
347 bmt_block_nr
= eckd_block_num(&mbr
->blockptr
.xeckd
.bptr
.chs
);
349 /* save pointer to Stage1b Data */
350 s1b_block_nr
= eckd_block_num(&ipl2
->stage1
.seek
[0].chs
);
352 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
353 read_block(2, vlbl
, "Cannot read Volume Label at block 2");
354 IPL_assert(magic_match(vlbl
->key
, VOL1_MAGIC
),
355 "Invalid magic of volume label block");
356 IPL_assert(magic_match(vlbl
->f
.key
, VOL1_MAGIC
),
357 "Invalid magic of volser block");
358 print_volser(vlbl
->f
.volser
);
360 run_eckd_boot_script(bmt_block_nr
, s1b_block_nr
);
364 static void print_eckd_ldl_msg(ECKD_IPL_mode_t mode
)
366 LDL_VTOC
*vlbl
= (void *)sec
; /* already read, 3rd block */
367 char msg
[4] = { '?', '.', '\n', '\0' };
369 sclp_print((mode
== ECKD_CMS
) ? "CMS" : "LDL");
370 sclp_print(" version ");
371 switch (vlbl
->LDL_version
) {
379 msg
[0] = vlbl
->LDL_version
;
380 msg
[0] &= 0x0f; /* convert EBCDIC */
381 msg
[0] |= 0x30; /* to ASCII (digit) */
386 print_volser(vlbl
->volser
);
389 static void ipl_eckd_ldl(ECKD_IPL_mode_t mode
)
391 block_number_t bmt_block_nr
, s1b_block_nr
;
392 EckdLdlIpl1
*ipl1
= (void *)sec
;
394 if (mode
!= ECKD_LDL_UNLABELED
) {
395 print_eckd_ldl_msg(mode
);
398 /* DO NOT read BootMap pointer (only one, xECKD) at block #2 */
400 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
401 read_block(0, sec
, "Cannot read block 0 to grab boot info.");
402 if (mode
== ECKD_LDL_UNLABELED
) {
403 if (!magic_match(ipl1
->bip
.magic
, ZIPL_MAGIC
)) {
404 return; /* not applicable layout */
406 sclp_print("unlabeled LDL.\n");
408 verify_boot_info(&ipl1
->bip
);
410 /* save pointer to Boot Map Table */
411 bmt_block_nr
= eckd_block_num(&ipl1
->bip
.bp
.ipl
.bm_ptr
.eckd
.bptr
.chs
);
413 /* save pointer to Stage1b Data */
414 s1b_block_nr
= eckd_block_num(&ipl1
->stage1
.seek
[0].chs
);
416 run_eckd_boot_script(bmt_block_nr
, s1b_block_nr
);
420 static void print_eckd_msg(void)
422 char msg
[] = "Using ECKD scheme (block size *****), ";
423 char *p
= &msg
[34], *q
= &msg
[30];
424 int n
= virtio_get_block_size();
426 /* Fill in the block size and show up the message */
427 if (n
> 0 && n
<= 99999) {
429 *p
-- = '0' + (n
% 10);
439 static void ipl_eckd(void)
441 XEckdMbr
*mbr
= (void *)sec
;
442 LDL_VTOC
*vlbl
= (void *)sec
;
446 /* Grab the MBR again */
447 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
448 read_block(0, mbr
, "Cannot read block 0 on DASD");
450 if (magic_match(mbr
->magic
, IPL1_MAGIC
)) {
451 ipl_eckd_cdl(); /* no return */
455 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
456 read_block(2, vlbl
, "Cannot read block 2");
458 if (magic_match(vlbl
->magic
, CMS1_MAGIC
)) {
459 ipl_eckd_ldl(ECKD_CMS
); /* no return */
461 if (magic_match(vlbl
->magic
, LNX1_MAGIC
)) {
462 ipl_eckd_ldl(ECKD_LDL
); /* no return */
465 ipl_eckd_ldl(ECKD_LDL_UNLABELED
); /* it still may return */
467 * Ok, it is not a LDL by any means.
468 * It still might be a CDL with zero record keys for IPL1 and IPL2
473 /***********************************************************************
477 static void zipl_load_segment(ComponentEntry
*entry
)
479 const int max_entries
= (MAX_SECTOR_SIZE
/ sizeof(ScsiBlockPtr
));
480 ScsiBlockPtr
*bprs
= (void *)sec
;
481 const int bprs_size
= sizeof(sec
);
482 block_number_t blockno
;
485 char err_msg
[] = "zIPL failed to read BPRS at 0xZZZZZZZZZZZZZZZZ";
486 char *blk_no
= &err_msg
[30]; /* where to print blockno in (those ZZs) */
488 blockno
= entry
->data
.blockno
;
489 address
= entry
->load_address
;
491 debug_print_int("loading segment at block", blockno
);
492 debug_print_int("addr", address
);
495 memset(bprs
, FREE_SPACE_FILLER
, bprs_size
);
496 fill_hex_val(blk_no
, &blockno
, sizeof(blockno
));
497 read_block(blockno
, bprs
, err_msg
);
500 uint64_t *cur_desc
= (void *)&bprs
[i
];
502 blockno
= bprs
[i
].blockno
;
507 /* we need the updated blockno for the next indirect entry in the
508 chain, but don't want to advance address */
509 if (i
== (max_entries
- 1)) {
513 if (bprs
[i
].blockct
== 0 && unused_space(&bprs
[i
+ 1],
514 sizeof(ScsiBlockPtr
))) {
515 /* This is a "continue" pointer.
516 * This ptr is the last one in the current script section.
517 * I.e. the next ptr must point to the unused memory area.
518 * The blockno is not zero, so the upper loop must continue
519 * reading next section of BPRS.
523 address
= virtio_load_direct(cur_desc
[0], cur_desc
[1], 0,
525 IPL_assert(address
!= -1, "zIPL load segment failed");
530 /* Run a zipl program */
531 static void zipl_run(ScsiBlockPtr
*pte
)
533 ComponentHeader
*header
;
534 ComponentEntry
*entry
;
535 uint8_t tmp_sec
[MAX_SECTOR_SIZE
];
537 read_block(pte
->blockno
, tmp_sec
, "Cannot read header");
538 header
= (ComponentHeader
*)tmp_sec
;
540 IPL_assert(magic_match(tmp_sec
, ZIPL_MAGIC
), "No zIPL magic in header");
541 IPL_assert(header
->type
== ZIPL_COMP_HEADER_IPL
, "Bad header type");
543 dputs("start loading images\n");
545 /* Load image(s) into RAM */
546 entry
= (ComponentEntry
*)(&header
[1]);
547 while (entry
->component_type
== ZIPL_COMP_ENTRY_LOAD
) {
548 zipl_load_segment(entry
);
552 IPL_assert((uint8_t *)(&entry
[1]) <= (tmp_sec
+ MAX_SECTOR_SIZE
),
553 "Wrong entry value");
556 IPL_assert(entry
->component_type
== ZIPL_COMP_ENTRY_EXEC
, "No EXEC entry");
558 /* should not return */
559 jump_to_IPL_code(entry
->load_address
);
562 static void ipl_scsi(void)
564 ScsiMbr
*mbr
= (void *)sec
;
565 int program_table_entries
= 0;
566 BootMapTable
*prog_table
= (void *)sec
;
567 unsigned int loadparm
= get_loadparm_index();
570 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
571 read_block(0, mbr
, "Cannot read block 0");
573 if (!magic_match(mbr
->magic
, ZIPL_MAGIC
)) {
577 sclp_print("Using SCSI scheme.\n");
578 debug_print_int("MBR Version", mbr
->version_id
);
579 IPL_check(mbr
->version_id
== 1,
580 "Unknown MBR layout version, assuming version 1");
581 debug_print_int("program table", mbr
->pt
.blockno
);
582 IPL_assert(mbr
->pt
.blockno
, "No Program Table");
584 /* Parse the program table */
585 read_block(mbr
->pt
.blockno
, sec
, "Error reading Program Table");
586 IPL_assert(magic_match(sec
, ZIPL_MAGIC
), "No zIPL magic in PT");
588 while (program_table_entries
<= MAX_TABLE_ENTRIES
) {
589 if (!prog_table
->entry
[program_table_entries
].scsi
.blockno
) {
592 program_table_entries
++;
595 debug_print_int("program table entries", program_table_entries
);
596 IPL_assert(program_table_entries
!= 0, "Empty Program Table");
598 if (menu_is_enabled_enum()) {
599 loadparm
= menu_get_enum_boot_index(program_table_entries
);
602 debug_print_int("loadparm", loadparm
);
603 IPL_assert(loadparm
<= MAX_TABLE_ENTRIES
, "loadparm value greater than"
604 " maximum number of boot entries allowed");
606 zipl_run(&prog_table
->entry
[loadparm
].scsi
); /* no return */
609 /***********************************************************************
610 * IPL El Torito ISO9660 image or DVD
613 static bool is_iso_bc_entry_compatible(IsoBcSection
*s
)
615 uint8_t *magic_sec
= (uint8_t *)(sec
+ ISO_SECTOR_SIZE
);
617 if (s
->unused
|| !s
->sector_count
) {
620 read_iso_sector(bswap32(s
->load_rba
), magic_sec
,
621 "Failed to read image sector 0");
623 /* Checking bytes 8 - 32 for S390 Linux magic */
624 return !memcmp(magic_sec
+ 8, linux_s390_magic
, 24);
627 /* Location of the current sector of the directory */
628 static uint32_t sec_loc
[ISO9660_MAX_DIR_DEPTH
];
629 /* Offset in the current sector of the directory */
630 static uint32_t sec_offset
[ISO9660_MAX_DIR_DEPTH
];
631 /* Remained directory space in bytes */
632 static uint32_t dir_rem
[ISO9660_MAX_DIR_DEPTH
];
634 static inline uint32_t iso_get_file_size(uint32_t load_rba
)
636 IsoVolDesc
*vd
= (IsoVolDesc
*)sec
;
637 IsoDirHdr
*cur_record
= &vd
->vd
.primary
.rootdir
;
638 uint8_t *temp
= sec
+ ISO_SECTOR_SIZE
;
641 read_iso_sector(ISO_PRIMARY_VD_SECTOR
, sec
,
642 "Failed to read ISO primary descriptor");
643 sec_loc
[0] = iso_733_to_u32(cur_record
->ext_loc
);
648 IPL_assert(sec_offset
[level
] <= ISO_SECTOR_SIZE
,
649 "Directory tree structure violation");
651 cur_record
= (IsoDirHdr
*)(temp
+ sec_offset
[level
]);
653 if (sec_offset
[level
] == 0) {
654 read_iso_sector(sec_loc
[level
], temp
,
655 "Failed to read ISO directory");
656 if (dir_rem
[level
] == 0) {
657 /* Skip self and parent records */
658 dir_rem
[level
] = iso_733_to_u32(cur_record
->data_len
) -
660 sec_offset
[level
] += cur_record
->dr_len
;
662 cur_record
= (IsoDirHdr
*)(temp
+ sec_offset
[level
]);
663 dir_rem
[level
] -= cur_record
->dr_len
;
664 sec_offset
[level
] += cur_record
->dr_len
;
669 if (!cur_record
->dr_len
|| sec_offset
[level
] == ISO_SECTOR_SIZE
) {
670 /* Zero-padding and/or the end of current sector */
671 dir_rem
[level
] -= ISO_SECTOR_SIZE
- sec_offset
[level
];
672 sec_offset
[level
] = 0;
675 /* The directory record is valid */
676 if (load_rba
== iso_733_to_u32(cur_record
->ext_loc
)) {
677 return iso_733_to_u32(cur_record
->data_len
);
680 dir_rem
[level
] -= cur_record
->dr_len
;
681 sec_offset
[level
] += cur_record
->dr_len
;
683 if (cur_record
->file_flags
& 0x2) {
685 if (level
== ISO9660_MAX_DIR_DEPTH
- 1) {
686 sclp_print("ISO-9660 directory depth limit exceeded\n");
689 sec_loc
[level
] = iso_733_to_u32(cur_record
->ext_loc
);
690 sec_offset
[level
] = 0;
697 if (dir_rem
[level
] == 0) {
698 /* Nothing remaining */
700 read_iso_sector(sec_loc
[level
], temp
,
701 "Failed to read ISO directory");
708 static void load_iso_bc_entry(IsoBcSection
*load
)
710 IsoBcSection s
= *load
;
712 * According to spec, extent for each file
713 * is padded and ISO_SECTOR_SIZE bytes aligned
715 uint32_t blks_to_load
= bswap16(s
.sector_count
) >> ET_SECTOR_SHIFT
;
716 uint32_t real_size
= iso_get_file_size(bswap32(s
.load_rba
));
719 /* Round up blocks to load */
720 blks_to_load
= (real_size
+ ISO_SECTOR_SIZE
- 1) / ISO_SECTOR_SIZE
;
721 sclp_print("ISO boot image size verified\n");
723 sclp_print("ISO boot image size could not be verified\n");
726 read_iso_boot_image(bswap32(s
.load_rba
),
727 (void *)((uint64_t)bswap16(s
.load_segment
)),
730 /* Trying to get PSW at zero address */
731 if (*((uint64_t *)0) & IPL_PSW_MASK
) {
732 jump_to_IPL_code((*((uint64_t *)0)) & 0x7fffffff);
735 /* Try default linux start address */
736 jump_to_IPL_code(KERN_IMAGE_START
);
739 static uint32_t find_iso_bc(void)
741 IsoVolDesc
*vd
= (IsoVolDesc
*)sec
;
742 uint32_t block_num
= ISO_PRIMARY_VD_SECTOR
;
744 if (virtio_read_many(block_num
++, sec
, 1)) {
745 /* If primary vd cannot be read, there is no boot catalog */
749 while (is_iso_vd_valid(vd
) && vd
->type
!= VOL_DESC_TERMINATOR
) {
750 if (vd
->type
== VOL_DESC_TYPE_BOOT
) {
751 IsoVdElTorito
*et
= &vd
->vd
.boot
;
753 if (!memcmp(&et
->el_torito
[0], el_torito_magic
, 32)) {
754 return bswap32(et
->bc_offset
);
757 read_iso_sector(block_num
++, sec
,
758 "Failed to read ISO volume descriptor");
764 static IsoBcSection
*find_iso_bc_entry(void)
766 IsoBcEntry
*e
= (IsoBcEntry
*)sec
;
767 uint32_t offset
= find_iso_bc();
769 unsigned int loadparm
= get_loadparm_index();
775 read_iso_sector(offset
, sec
, "Failed to read El Torito boot catalog");
777 if (!is_iso_bc_valid(e
)) {
778 /* The validation entry is mandatory */
779 panic("No valid boot catalog found!\n");
784 * Each entry has 32 bytes size, so one sector cannot contain > 64 entries.
785 * We consider only boot catalogs with no more than 64 entries.
787 for (i
= 1; i
< ISO_BC_ENTRY_PER_SECTOR
; i
++) {
788 if (e
[i
].id
== ISO_BC_BOOTABLE_SECTION
) {
789 if (is_iso_bc_entry_compatible(&e
[i
].body
.sect
)) {
791 /* found, default, or unspecified */
792 return &e
[i
].body
.sect
;
799 panic("No suitable boot entry found on ISO-9660 media!\n");
804 static void ipl_iso_el_torito(void)
806 IsoBcSection
*s
= find_iso_bc_entry();
809 load_iso_bc_entry(s
);
814 /***********************************************************************
815 * Bus specific IPL sequences
818 static void zipl_load_vblk(void)
820 if (virtio_guessed_disk_nature()) {
821 virtio_assume_iso9660();
825 if (virtio_guessed_disk_nature()) {
826 sclp_print("Using guessed DASD geometry.\n");
827 virtio_assume_eckd();
832 static void zipl_load_vscsi(void)
834 if (virtio_get_block_size() == VIRTIO_ISO_BLOCK_SIZE
) {
835 /* Is it an ISO image in non-CD drive? */
839 sclp_print("Using guessed DASD geometry.\n");
840 virtio_assume_eckd();
844 /***********************************************************************
850 VDev
*vdev
= virtio_get_device();
852 if (vdev
->is_cdrom
) {
854 panic("\n! Cannot IPL this ISO image !\n");
857 if (virtio_get_device_type() == VIRTIO_ID_NET
) {
858 jump_to_IPL_code(vdev
->netboot_start_addr
);
863 switch (virtio_get_device_type()) {
864 case VIRTIO_ID_BLOCK
:
871 panic("\n! Unknown IPL device type !\n");
874 panic("\n* this can never happen *\n");