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
13 #include "s390-arch.h"
19 /* #define DEBUG_FALLBACK */
24 do { sclp_print("zipl: " txt); } while (0)
26 #define dputs(fmt, ...) \
31 static uint8_t sec
[MAX_SECTOR_SIZE
*4] __attribute__((__aligned__(PAGE_SIZE
)));
33 const uint8_t el_torito_magic
[] = "EL TORITO SPECIFICATION"
34 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
37 * Match two CCWs located after PSW and eight filler bytes.
38 * From libmagic and arch/s390/kernel/head.S.
40 const uint8_t linux_s390_magic
[] = "\x02\x00\x00\x18\x60\x00\x00\x50\x02\x00"
41 "\x00\x68\x60\x00\x00\x50\x40\x40\x40\x40"
44 static inline bool is_iso_vd_valid(IsoVolDesc
*vd
)
46 const uint8_t vol_desc_magic
[] = "CD001";
48 return !memcmp(&vd
->ident
[0], vol_desc_magic
, 5) &&
50 vd
->type
<= VOL_DESC_TYPE_PARTITION
;
53 /***********************************************************************
54 * IPL an ECKD DASD (CDL or LDL/CMS format)
57 static unsigned char _bprs
[8*1024]; /* guessed "max" ECKD sector size */
58 static const int max_bprs_entries
= sizeof(_bprs
) / sizeof(ExtEckdBlockPtr
);
59 static uint8_t _s2
[MAX_SECTOR_SIZE
* 3] __attribute__((__aligned__(PAGE_SIZE
)));
60 static void *s2_prev_blk
= _s2
;
61 static void *s2_cur_blk
= _s2
+ MAX_SECTOR_SIZE
;
62 static void *s2_next_blk
= _s2
+ MAX_SECTOR_SIZE
* 2;
64 static inline void verify_boot_info(BootInfo
*bip
)
66 IPL_assert(magic_match(bip
->magic
, ZIPL_MAGIC
), "No zIPL sig in BootInfo");
67 IPL_assert(bip
->version
== BOOT_INFO_VERSION
, "Wrong zIPL version");
68 IPL_assert(bip
->bp_type
== BOOT_INFO_BP_TYPE_IPL
, "DASD is not for IPL");
69 IPL_assert(bip
->dev_type
== BOOT_INFO_DEV_TYPE_ECKD
, "DASD is not ECKD");
70 IPL_assert(bip
->flags
== BOOT_INFO_FLAGS_ARCH
, "Not for this arch");
71 IPL_assert(block_size_ok(bip
->bp
.ipl
.bm_ptr
.eckd
.bptr
.size
),
72 "Bad block size in zIPL section of the 1st record.");
75 static void eckd_format_chs(ExtEckdBlockPtr
*ptr
, bool ldipl
,
81 *c
= ptr
->ldptr
.chs
.cylinder
;
82 *h
= ptr
->ldptr
.chs
.head
;
83 *s
= ptr
->ldptr
.chs
.sector
;
85 *c
= ptr
->bptr
.chs
.cylinder
;
86 *h
= ptr
->bptr
.chs
.head
;
87 *s
= ptr
->bptr
.chs
.sector
;
91 static block_number_t
eckd_chs_to_block(uint64_t c
, uint64_t h
, uint64_t s
)
93 const uint64_t sectors
= virtio_get_sectors();
94 const uint64_t heads
= virtio_get_heads();
95 const uint64_t cylinder
= c
+ ((h
& 0xfff0) << 12);
96 const uint64_t head
= h
& 0x000f;
97 const block_number_t block
= sectors
* heads
* cylinder
99 + s
- 1; /* block nr starts with zero */
103 static block_number_t
eckd_block_num(EckdCHS
*chs
)
105 return eckd_chs_to_block(chs
->cylinder
, chs
->head
, chs
->sector
);
108 static block_number_t
gen_eckd_block_num(ExtEckdBlockPtr
*ptr
, bool ldipl
)
110 uint64_t cyl
, head
, sec
;
111 eckd_format_chs(ptr
, ldipl
, &cyl
, &head
, &sec
);
112 return eckd_chs_to_block(cyl
, head
, sec
);
115 static bool eckd_valid_chs(uint64_t cyl
, uint64_t head
, uint64_t sector
)
117 if (head
>= virtio_get_heads()
118 || sector
> virtio_get_sectors()
123 if (!virtio_guessed_disk_nature() &&
124 eckd_chs_to_block(cyl
, head
, sector
) >= virtio_get_blocks()) {
131 static bool eckd_valid_address(ExtEckdBlockPtr
*ptr
, bool ldipl
)
133 uint64_t cyl
, head
, sec
;
134 eckd_format_chs(ptr
, ldipl
, &cyl
, &head
, &sec
);
135 return eckd_valid_chs(cyl
, head
, sec
);
138 static block_number_t
load_eckd_segments(block_number_t blk
, bool ldipl
,
141 block_number_t block_nr
;
143 BootMapPointer
*bprs
= (void *)_bprs
;
146 memset(_bprs
, FREE_SPACE_FILLER
, sizeof(_bprs
));
147 read_block(blk
, bprs
, "BPRS read failed");
152 block_nr
= gen_eckd_block_num(&bprs
[j
].xeckd
, ldipl
);
153 if (is_null_block_number(block_nr
)) { /* end of chunk */
157 /* we need the updated blockno for the next indirect entry
158 * in the chain, but don't want to advance address
160 if (j
== (max_bprs_entries
- 1)) {
164 /* List directed pointer does not store block size */
165 IPL_assert(ldipl
|| block_size_ok(bprs
[j
].xeckd
.bptr
.size
),
166 "bad chunk block size");
168 if (!eckd_valid_address(&bprs
[j
].xeckd
, ldipl
)) {
170 * If an invalid address is found during LD-IPL then break and
173 IPL_assert(ldipl
, "bad chunk ECKD addr");
178 count
= bprs
[j
].xeckd
.ldptr
.count
;
180 count
= bprs
[j
].xeckd
.bptr
.count
;
183 if (count
== 0 && unused_space(&bprs
[j
+ 1],
184 sizeof(EckdBlockPtr
))) {
185 /* This is a "continue" pointer.
186 * This ptr should be the last one in the current
188 * I.e. the next ptr must point to the unused memory area
190 memset(_bprs
, FREE_SPACE_FILLER
, sizeof(_bprs
));
191 read_block(block_nr
, bprs
, "BPRS continuation read failed");
196 /* Load (count+1) blocks of code at (block_nr)
197 * to memory (address).
199 rc
= virtio_read_many(block_nr
, (void *)(*address
), count
+ 1);
200 IPL_assert(rc
== 0, "code chunk read failed");
202 *address
+= (count
+ 1) * virtio_get_block_size();
208 static bool find_zipl_boot_menu_banner(int *offset
)
212 /* Menu banner starts with "zIPL" */
213 for (i
= 0; i
<= virtio_get_block_size() - 4; i
++) {
214 if (magic_match(s2_cur_blk
+ i
, ZIPL_MAGIC_EBCDIC
)) {
223 static int eckd_get_boot_menu_index(block_number_t s1b_block_nr
)
225 block_number_t cur_block_nr
;
226 block_number_t prev_block_nr
= 0;
227 block_number_t next_block_nr
= 0;
228 EckdStage1b
*s1b
= (void *)sec
;
232 /* Get Stage1b data */
233 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
234 read_block(s1b_block_nr
, s1b
, "Cannot read stage1b boot loader");
236 memset(_s2
, FREE_SPACE_FILLER
, sizeof(_s2
));
238 /* Get Stage2 data */
239 for (i
= 0; i
< STAGE2_BLK_CNT_MAX
; i
++) {
240 cur_block_nr
= eckd_block_num(&s1b
->seek
[i
].chs
);
242 if (!cur_block_nr
|| is_null_block_number(cur_block_nr
)) {
246 read_block(cur_block_nr
, s2_cur_blk
, "Cannot read stage2 boot loader");
248 if (find_zipl_boot_menu_banner(&banner_offset
)) {
250 * Load the adjacent blocks to account for the
251 * possibility of menu data spanning multiple blocks.
254 read_block(prev_block_nr
, s2_prev_blk
,
255 "Cannot read stage2 boot loader");
258 if (i
+ 1 < STAGE2_BLK_CNT_MAX
) {
259 next_block_nr
= eckd_block_num(&s1b
->seek
[i
+ 1].chs
);
262 if (next_block_nr
&& !is_null_block_number(next_block_nr
)) {
263 read_block(next_block_nr
, s2_next_blk
,
264 "Cannot read stage2 boot loader");
267 return menu_get_zipl_boot_index(s2_cur_blk
+ banner_offset
);
270 prev_block_nr
= cur_block_nr
;
273 sclp_print("No zipl boot menu data found. Booting default entry.");
277 static void run_eckd_boot_script(block_number_t bmt_block_nr
,
278 block_number_t s1b_block_nr
)
281 unsigned int loadparm
= get_loadparm_index();
282 block_number_t block_nr
;
284 BootMapTable
*bmt
= (void *)sec
;
285 BootMapScript
*bms
= (void *)sec
;
286 /* The S1B block number is NULL_BLOCK_NR if and only if it's an LD-IPL */
287 bool ldipl
= (s1b_block_nr
== NULL_BLOCK_NR
);
289 if (menu_is_enabled_zipl() && !ldipl
) {
290 loadparm
= eckd_get_boot_menu_index(s1b_block_nr
);
293 debug_print_int("loadparm", loadparm
);
294 IPL_assert(loadparm
< MAX_BOOT_ENTRIES
, "loadparm value greater than"
295 " maximum number of boot entries allowed");
297 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
298 read_block(bmt_block_nr
, sec
, "Cannot read Boot Map Table");
300 block_nr
= gen_eckd_block_num(&bmt
->entry
[loadparm
].xeckd
, ldipl
);
301 IPL_assert(block_nr
!= -1, "Cannot find Boot Map Table Entry");
303 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
304 read_block(block_nr
, sec
, "Cannot read Boot Map Script");
306 for (i
= 0; bms
->entry
[i
].type
== BOOT_SCRIPT_LOAD
||
307 bms
->entry
[i
].type
== BOOT_SCRIPT_SIGNATURE
; i
++) {
309 /* We don't support secure boot yet, so we skip signature entries */
310 if (bms
->entry
[i
].type
== BOOT_SCRIPT_SIGNATURE
) {
314 address
= bms
->entry
[i
].address
.load_address
;
315 block_nr
= gen_eckd_block_num(&bms
->entry
[i
].blkptr
.xeckd
, ldipl
);
318 block_nr
= load_eckd_segments(block_nr
, ldipl
, &address
);
319 } while (block_nr
!= -1);
322 if (ldipl
&& bms
->entry
[i
].type
!= BOOT_SCRIPT_EXEC
) {
323 /* Abort LD-IPL and retry as CCW-IPL */
327 IPL_assert(bms
->entry
[i
].type
== BOOT_SCRIPT_EXEC
,
328 "Unknown script entry type");
329 write_reset_psw(bms
->entry
[i
].address
.load_address
); /* no return */
330 jump_to_IPL_code(0); /* no return */
333 static void ipl_eckd_cdl(void)
336 EckdCdlIpl2
*ipl2
= (void *)sec
;
337 IplVolumeLabel
*vlbl
= (void *)sec
;
338 block_number_t bmt_block_nr
, s1b_block_nr
;
340 /* we have just read the block #0 and recognized it as "IPL1" */
343 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
344 read_block(1, ipl2
, "Cannot read IPL2 record at block 1");
347 if (!magic_match(mbr
, ZIPL_MAGIC
)) {
348 sclp_print("No zIPL section in IPL2 record.\n");
351 if (!block_size_ok(mbr
->blockptr
.xeckd
.bptr
.size
)) {
352 sclp_print("Bad block size in zIPL section of IPL2 record.\n");
355 if (mbr
->dev_type
!= DEV_TYPE_ECKD
) {
356 sclp_print("Non-ECKD device type in zIPL section of IPL2 record.\n");
360 /* save pointer to Boot Map Table */
361 bmt_block_nr
= eckd_block_num(&mbr
->blockptr
.xeckd
.bptr
.chs
);
363 /* save pointer to Stage1b Data */
364 s1b_block_nr
= eckd_block_num(&ipl2
->stage1
.seek
[0].chs
);
366 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
367 read_block(2, vlbl
, "Cannot read Volume Label at block 2");
368 if (!magic_match(vlbl
->key
, VOL1_MAGIC
)) {
369 sclp_print("Invalid magic of volume label block.\n");
372 if (!magic_match(vlbl
->f
.key
, VOL1_MAGIC
)) {
373 sclp_print("Invalid magic of volser block.\n");
376 print_volser(vlbl
->f
.volser
);
378 run_eckd_boot_script(bmt_block_nr
, s1b_block_nr
);
382 static void print_eckd_ldl_msg(ECKD_IPL_mode_t mode
)
384 LDL_VTOC
*vlbl
= (void *)sec
; /* already read, 3rd block */
385 char msg
[4] = { '?', '.', '\n', '\0' };
387 sclp_print((mode
== ECKD_CMS
) ? "CMS" : "LDL");
388 sclp_print(" version ");
389 switch (vlbl
->LDL_version
) {
397 msg
[0] = ebc2asc
[vlbl
->LDL_version
];
402 print_volser(vlbl
->volser
);
405 static void ipl_eckd_ldl(ECKD_IPL_mode_t mode
)
407 block_number_t bmt_block_nr
, s1b_block_nr
;
408 EckdLdlIpl1
*ipl1
= (void *)sec
;
410 if (mode
!= ECKD_LDL_UNLABELED
) {
411 print_eckd_ldl_msg(mode
);
414 /* DO NOT read BootMap pointer (only one, xECKD) at block #2 */
416 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
417 read_block(0, sec
, "Cannot read block 0 to grab boot info.");
418 if (mode
== ECKD_LDL_UNLABELED
) {
419 if (!magic_match(ipl1
->bip
.magic
, ZIPL_MAGIC
)) {
420 return; /* not applicable layout */
422 sclp_print("unlabeled LDL.\n");
424 verify_boot_info(&ipl1
->bip
);
426 /* save pointer to Boot Map Table */
427 bmt_block_nr
= eckd_block_num(&ipl1
->bip
.bp
.ipl
.bm_ptr
.eckd
.bptr
.chs
);
429 /* save pointer to Stage1b Data */
430 s1b_block_nr
= eckd_block_num(&ipl1
->stage1
.seek
[0].chs
);
432 run_eckd_boot_script(bmt_block_nr
, s1b_block_nr
);
436 static block_number_t
eckd_find_bmt(ExtEckdBlockPtr
*ptr
)
438 block_number_t blockno
;
439 uint8_t tmp_sec
[MAX_SECTOR_SIZE
];
442 blockno
= gen_eckd_block_num(ptr
, 0);
443 read_block(blockno
, tmp_sec
, "Cannot read boot record");
444 br
= (BootRecord
*)tmp_sec
;
445 if (!magic_match(br
->magic
, ZIPL_MAGIC
)) {
446 /* If the boot record is invalid, return and try CCW-IPL instead */
447 return NULL_BLOCK_NR
;
450 return gen_eckd_block_num(&br
->pgt
.xeckd
, 1);
453 static void print_eckd_msg(void)
455 char msg
[] = "Using ECKD scheme (block size *****), ";
456 char *p
= &msg
[34], *q
= &msg
[30];
457 int n
= virtio_get_block_size();
459 /* Fill in the block size and show up the message */
460 if (n
> 0 && n
<= 99999) {
462 *p
-- = '0' + (n
% 10);
472 static void ipl_eckd(void)
474 IplVolumeLabel
*vlbl
= (void *)sec
;
475 LDL_VTOC
*vtoc
= (void *)sec
;
476 block_number_t ldipl_bmt
; /* Boot Map Table for List-Directed IPL */
480 /* Block 2 can contain either the CDL VOL1 label or the LDL VTOC */
481 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
482 read_block(2, vlbl
, "Cannot read block 2");
485 * First check for a list-directed-format pointer which would
486 * supersede the CCW pointer.
488 if (eckd_valid_address((ExtEckdBlockPtr
*)&vlbl
->f
.br
, 0)) {
489 ldipl_bmt
= eckd_find_bmt((ExtEckdBlockPtr
*)&vlbl
->f
.br
);
491 sclp_print("List-Directed\n");
492 /* LD-IPL does not use the S1B bock, just make it NULL */
493 run_eckd_boot_script(ldipl_bmt
, NULL_BLOCK_NR
);
494 /* Only return in error, retry as CCW-IPL */
495 sclp_print("Retrying IPL ");
498 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
499 read_block(2, vtoc
, "Cannot read block 2");
502 /* Not list-directed */
503 if (magic_match(vtoc
->magic
, VOL1_MAGIC
)) {
504 ipl_eckd_cdl(); /* may return in error */
507 if (magic_match(vtoc
->magic
, CMS1_MAGIC
)) {
508 ipl_eckd_ldl(ECKD_CMS
); /* no return */
510 if (magic_match(vtoc
->magic
, LNX1_MAGIC
)) {
511 ipl_eckd_ldl(ECKD_LDL
); /* no return */
514 ipl_eckd_ldl(ECKD_LDL_UNLABELED
); /* it still may return */
516 * Ok, it is not a LDL by any means.
517 * It still might be a CDL with zero record keys for IPL1 and IPL2
522 /***********************************************************************
526 static void zipl_load_segment(ComponentEntry
*entry
)
528 const int max_entries
= (MAX_SECTOR_SIZE
/ sizeof(ScsiBlockPtr
));
529 ScsiBlockPtr
*bprs
= (void *)sec
;
530 const int bprs_size
= sizeof(sec
);
531 block_number_t blockno
;
534 char err_msg
[] = "zIPL failed to read BPRS at 0xZZZZZZZZZZZZZZZZ";
535 char *blk_no
= &err_msg
[30]; /* where to print blockno in (those ZZs) */
537 blockno
= entry
->data
.blockno
;
538 address
= entry
->compdat
.load_addr
;
540 debug_print_int("loading segment at block", blockno
);
541 debug_print_int("addr", address
);
544 memset(bprs
, FREE_SPACE_FILLER
, bprs_size
);
545 fill_hex_val(blk_no
, &blockno
, sizeof(blockno
));
546 read_block(blockno
, bprs
, err_msg
);
549 uint64_t *cur_desc
= (void *)&bprs
[i
];
551 blockno
= bprs
[i
].blockno
;
556 /* we need the updated blockno for the next indirect entry in the
557 chain, but don't want to advance address */
558 if (i
== (max_entries
- 1)) {
562 if (bprs
[i
].blockct
== 0 && unused_space(&bprs
[i
+ 1],
563 sizeof(ScsiBlockPtr
))) {
564 /* This is a "continue" pointer.
565 * This ptr is the last one in the current script section.
566 * I.e. the next ptr must point to the unused memory area.
567 * The blockno is not zero, so the upper loop must continue
568 * reading next section of BPRS.
572 address
= virtio_load_direct(cur_desc
[0], cur_desc
[1], 0,
574 IPL_assert(address
!= -1, "zIPL load segment failed");
579 /* Run a zipl program */
580 static void zipl_run(ScsiBlockPtr
*pte
)
582 ComponentHeader
*header
;
583 ComponentEntry
*entry
;
584 uint8_t tmp_sec
[MAX_SECTOR_SIZE
];
586 read_block(pte
->blockno
, tmp_sec
, "Cannot read header");
587 header
= (ComponentHeader
*)tmp_sec
;
589 IPL_assert(magic_match(tmp_sec
, ZIPL_MAGIC
), "No zIPL magic in header");
590 IPL_assert(header
->type
== ZIPL_COMP_HEADER_IPL
, "Bad header type");
592 dputs("start loading images\n");
594 /* Load image(s) into RAM */
595 entry
= (ComponentEntry
*)(&header
[1]);
596 while (entry
->component_type
== ZIPL_COMP_ENTRY_LOAD
||
597 entry
->component_type
== ZIPL_COMP_ENTRY_SIGNATURE
) {
599 /* We don't support secure boot yet, so we skip signature entries */
600 if (entry
->component_type
== ZIPL_COMP_ENTRY_SIGNATURE
) {
605 zipl_load_segment(entry
);
609 IPL_assert((uint8_t *)(&entry
[1]) <= (tmp_sec
+ MAX_SECTOR_SIZE
),
610 "Wrong entry value");
613 IPL_assert(entry
->component_type
== ZIPL_COMP_ENTRY_EXEC
, "No EXEC entry");
615 /* should not return */
616 write_reset_psw(entry
->compdat
.load_psw
);
620 static void ipl_scsi(void)
622 ScsiMbr
*mbr
= (void *)sec
;
623 int program_table_entries
= 0;
624 BootMapTable
*prog_table
= (void *)sec
;
625 unsigned int loadparm
= get_loadparm_index();
626 bool valid_entries
[MAX_BOOT_ENTRIES
] = {false};
630 memset(sec
, FREE_SPACE_FILLER
, sizeof(sec
));
631 read_block(0, mbr
, "Cannot read block 0");
633 if (!magic_match(mbr
->magic
, ZIPL_MAGIC
)) {
637 sclp_print("Using SCSI scheme.\n");
638 debug_print_int("MBR Version", mbr
->version_id
);
639 IPL_check(mbr
->version_id
== 1,
640 "Unknown MBR layout version, assuming version 1");
641 debug_print_int("program table", mbr
->pt
.blockno
);
642 IPL_assert(mbr
->pt
.blockno
, "No Program Table");
644 /* Parse the program table */
645 read_block(mbr
->pt
.blockno
, sec
, "Error reading Program Table");
646 IPL_assert(magic_match(sec
, ZIPL_MAGIC
), "No zIPL magic in PT");
648 for (i
= 0; i
< MAX_BOOT_ENTRIES
; i
++) {
649 if (prog_table
->entry
[i
].scsi
.blockno
) {
650 valid_entries
[i
] = true;
651 program_table_entries
++;
655 debug_print_int("program table entries", program_table_entries
);
656 IPL_assert(program_table_entries
!= 0, "Empty Program Table");
658 if (menu_is_enabled_enum()) {
659 loadparm
= menu_get_enum_boot_index(valid_entries
);
662 debug_print_int("loadparm", loadparm
);
663 IPL_assert(loadparm
< MAX_BOOT_ENTRIES
, "loadparm value greater than"
664 " maximum number of boot entries allowed");
666 zipl_run(&prog_table
->entry
[loadparm
].scsi
); /* no return */
669 /***********************************************************************
670 * IPL El Torito ISO9660 image or DVD
673 static bool is_iso_bc_entry_compatible(IsoBcSection
*s
)
675 uint8_t *magic_sec
= (uint8_t *)(sec
+ ISO_SECTOR_SIZE
);
677 if (s
->unused
|| !s
->sector_count
) {
680 read_iso_sector(bswap32(s
->load_rba
), magic_sec
,
681 "Failed to read image sector 0");
683 /* Checking bytes 8 - 32 for S390 Linux magic */
684 return !memcmp(magic_sec
+ 8, linux_s390_magic
, 24);
687 /* Location of the current sector of the directory */
688 static uint32_t sec_loc
[ISO9660_MAX_DIR_DEPTH
];
689 /* Offset in the current sector of the directory */
690 static uint32_t sec_offset
[ISO9660_MAX_DIR_DEPTH
];
691 /* Remained directory space in bytes */
692 static uint32_t dir_rem
[ISO9660_MAX_DIR_DEPTH
];
694 static inline uint32_t iso_get_file_size(uint32_t load_rba
)
696 IsoVolDesc
*vd
= (IsoVolDesc
*)sec
;
697 IsoDirHdr
*cur_record
= &vd
->vd
.primary
.rootdir
;
698 uint8_t *temp
= sec
+ ISO_SECTOR_SIZE
;
701 read_iso_sector(ISO_PRIMARY_VD_SECTOR
, sec
,
702 "Failed to read ISO primary descriptor");
703 sec_loc
[0] = iso_733_to_u32(cur_record
->ext_loc
);
708 IPL_assert(sec_offset
[level
] <= ISO_SECTOR_SIZE
,
709 "Directory tree structure violation");
711 cur_record
= (IsoDirHdr
*)(temp
+ sec_offset
[level
]);
713 if (sec_offset
[level
] == 0) {
714 read_iso_sector(sec_loc
[level
], temp
,
715 "Failed to read ISO directory");
716 if (dir_rem
[level
] == 0) {
717 /* Skip self and parent records */
718 dir_rem
[level
] = iso_733_to_u32(cur_record
->data_len
) -
720 sec_offset
[level
] += cur_record
->dr_len
;
722 cur_record
= (IsoDirHdr
*)(temp
+ sec_offset
[level
]);
723 dir_rem
[level
] -= cur_record
->dr_len
;
724 sec_offset
[level
] += cur_record
->dr_len
;
729 if (!cur_record
->dr_len
|| sec_offset
[level
] == ISO_SECTOR_SIZE
) {
730 /* Zero-padding and/or the end of current sector */
731 dir_rem
[level
] -= ISO_SECTOR_SIZE
- sec_offset
[level
];
732 sec_offset
[level
] = 0;
735 /* The directory record is valid */
736 if (load_rba
== iso_733_to_u32(cur_record
->ext_loc
)) {
737 return iso_733_to_u32(cur_record
->data_len
);
740 dir_rem
[level
] -= cur_record
->dr_len
;
741 sec_offset
[level
] += cur_record
->dr_len
;
743 if (cur_record
->file_flags
& 0x2) {
745 if (level
== ISO9660_MAX_DIR_DEPTH
- 1) {
746 sclp_print("ISO-9660 directory depth limit exceeded\n");
749 sec_loc
[level
] = iso_733_to_u32(cur_record
->ext_loc
);
750 sec_offset
[level
] = 0;
757 if (dir_rem
[level
] == 0) {
758 /* Nothing remaining */
760 read_iso_sector(sec_loc
[level
], temp
,
761 "Failed to read ISO directory");
768 static void load_iso_bc_entry(IsoBcSection
*load
)
770 IsoBcSection s
= *load
;
772 * According to spec, extent for each file
773 * is padded and ISO_SECTOR_SIZE bytes aligned
775 uint32_t blks_to_load
= bswap16(s
.sector_count
) >> ET_SECTOR_SHIFT
;
776 uint32_t real_size
= iso_get_file_size(bswap32(s
.load_rba
));
779 /* Round up blocks to load */
780 blks_to_load
= (real_size
+ ISO_SECTOR_SIZE
- 1) / ISO_SECTOR_SIZE
;
781 sclp_print("ISO boot image size verified\n");
783 sclp_print("ISO boot image size could not be verified\n");
786 read_iso_boot_image(bswap32(s
.load_rba
),
787 (void *)((uint64_t)bswap16(s
.load_segment
)),
790 jump_to_low_kernel();
793 static uint32_t find_iso_bc(void)
795 IsoVolDesc
*vd
= (IsoVolDesc
*)sec
;
796 uint32_t block_num
= ISO_PRIMARY_VD_SECTOR
;
798 if (virtio_read_many(block_num
++, sec
, 1)) {
799 /* If primary vd cannot be read, there is no boot catalog */
803 while (is_iso_vd_valid(vd
) && vd
->type
!= VOL_DESC_TERMINATOR
) {
804 if (vd
->type
== VOL_DESC_TYPE_BOOT
) {
805 IsoVdElTorito
*et
= &vd
->vd
.boot
;
807 if (!memcmp(&et
->el_torito
[0], el_torito_magic
, 32)) {
808 return bswap32(et
->bc_offset
);
811 read_iso_sector(block_num
++, sec
,
812 "Failed to read ISO volume descriptor");
818 static IsoBcSection
*find_iso_bc_entry(void)
820 IsoBcEntry
*e
= (IsoBcEntry
*)sec
;
821 uint32_t offset
= find_iso_bc();
823 unsigned int loadparm
= get_loadparm_index();
829 read_iso_sector(offset
, sec
, "Failed to read El Torito boot catalog");
831 if (!is_iso_bc_valid(e
)) {
832 /* The validation entry is mandatory */
833 panic("No valid boot catalog found!\n");
838 * Each entry has 32 bytes size, so one sector cannot contain > 64 entries.
839 * We consider only boot catalogs with no more than 64 entries.
841 for (i
= 1; i
< ISO_BC_ENTRY_PER_SECTOR
; i
++) {
842 if (e
[i
].id
== ISO_BC_BOOTABLE_SECTION
) {
843 if (is_iso_bc_entry_compatible(&e
[i
].body
.sect
)) {
845 /* found, default, or unspecified */
846 return &e
[i
].body
.sect
;
853 panic("No suitable boot entry found on ISO-9660 media!\n");
858 static void ipl_iso_el_torito(void)
860 IsoBcSection
*s
= find_iso_bc_entry();
863 load_iso_bc_entry(s
);
869 * Detect whether we're trying to boot from an .ISO image.
870 * These always have a signature string "CD001" at offset 0x8001.
872 static bool has_iso_signature(void)
874 int blksize
= virtio_get_block_size();
876 if (!blksize
|| virtio_read(0x8000 / blksize
, sec
)) {
880 return !memcmp("CD001", &sec
[1], 5);
883 /***********************************************************************
884 * Bus specific IPL sequences
887 static void zipl_load_vblk(void)
889 int blksize
= virtio_get_block_size();
891 if (blksize
== VIRTIO_ISO_BLOCK_SIZE
|| has_iso_signature()) {
892 if (blksize
!= VIRTIO_ISO_BLOCK_SIZE
) {
893 virtio_assume_iso9660();
898 if (blksize
!= VIRTIO_DASD_DEFAULT_BLOCK_SIZE
) {
899 sclp_print("Using guessed DASD geometry.\n");
900 virtio_assume_eckd();
905 static void zipl_load_vscsi(void)
907 if (virtio_get_block_size() == VIRTIO_ISO_BLOCK_SIZE
) {
908 /* Is it an ISO image in non-CD drive? */
912 sclp_print("Using guessed DASD geometry.\n");
913 virtio_assume_eckd();
917 /***********************************************************************
923 VDev
*vdev
= virtio_get_device();
925 if (vdev
->is_cdrom
) {
927 panic("\n! Cannot IPL this ISO image !\n");
930 if (virtio_get_device_type() == VIRTIO_ID_NET
) {
931 jump_to_IPL_code(vdev
->netboot_start_addr
);
936 switch (virtio_get_device_type()) {
937 case VIRTIO_ID_BLOCK
:
944 panic("\n! Unknown IPL device type !\n");
947 sclp_print("zIPL load failed.\n");