Google Git
Sign in
qemu / skiboot / f8f9d5ece92da8da5d7331a6e4c924e2f485cc81
commitf8f9d5ece92da8da5d7331a6e4c924e2f485cc81[log] [tgz]
authorAndrew Jeffery <andrew@aj.id.au>Mon Mar 25 18:15:58 2019 +1030
committeroohal <oohal@users.noreply.github.com>Thu May 09 17:04:30 2019 +1000
tree3a75fc6950f70c636e5cb93ad1eaa7925d460a87
parent749ce5cf1916af326ef46fad6d79cf52dd252a6f [diff]
core/flash: Retry requests as necessary in flash_load_resource()

[ Upstream commit cccf5d79de07844cf095b8f45146b92944d15c2e ]

We would like to successfully boot if we have a dependency on the BMC
for flash even if the BMC is not current ready to service flash
requests. On the assumption that it will become ready, retry for several
minutes to cover a BMC reboot cycle and *eventually* rather than
*immediately* crash out with:

    [  269.549748] reboot: Restarting system
    [  390.297462587,5] OPAL: Reboot request...
    [  390.297737995,5] RESET: Initiating fast reboot 1...
    [  391.074707590,5] Clearing unused memory:
    [  391.075198880,5] PCI: Clearing all devices...
    [  391.075201618,7] Clearing region 201ffe000000-201fff800000
    [  391.086235699,5] PCI: Resetting PHBs and training links...
    [  391.254089525,3] FFS: Error 17 reading flash header
    [  391.254159668,3] FLASH: Can't open ffs handle: 17
    [  392.307245135,5] PCI: Probing slots...
    [  392.363723191,5] PCI Summary:
    ...
    [  393.423255262,5] OCC: All Chip Rdy after 0 ms
    [  393.453092828,5] INIT: Starting kernel at 0x20000000, fdt at
    0x30800a88 390645 bytes
    [  393.453202605,0] FATAL: Kernel is zeros, can't execute!
    [  393.453247064,0] Assert fail: core/init.c:593:0
    [  393.453289682,0] Aborting!
    CPU 0040 Backtrace:
     S: 0000000031e03ca0 R: 000000003001af60   ._abort+0x4c
     S: 0000000031e03d20 R: 000000003001afdc   .assert_fail+0x34
     S: 0000000031e03da0 R: 00000000300146d8   .load_and_boot_kernel+0xb30
     S: 0000000031e03e70 R: 0000000030026cf0   .fast_reboot_entry+0x39c
     S: 0000000031e03f00 R: 0000000030002a4c   fast_reset_entry+0x2c
     --- OPAL boot ---

The OPAL flash API hooks directly into the blocklevel layer, so there's
no delay for e.g. the host kernel, just for asynchronously loaded
resources during boot.

Signed-off-by: Andrew Jeffery <andrew@aj.id.au>
Signed-off-by: Stewart Smith <stewart@linux.ibm.com>
Signed-off-by: Vasant Hegde <hegdevasant@linux.vnet.ibm.com>
1 file changed
tree: 3a75fc6950f70c636e5cb93ad1eaa7925d460a87
  1. asm/
  2. ccan/
  3. core/
  4. doc/
  5. external/
  6. hdata/
  7. hw/
  8. include/
  9. libc/
  10. libfdt/
  11. libflash/
  12. libpore/
  13. libstb/
  14. libxz/
  15. opal-ci/
  16. platforms/
  17. test/
  18. .gitignore
  19. .travis.yml
  20. CONTRIBUTING.md
  21. coverity-model.c
  22. extract-gcov.c
  23. LICENCE
  24. make_offsets.sh
  25. make_version.sh
  26. Makefile
  27. Makefile.main
  28. Makefile.rules
  29. README.md
  30. skiboot.lds.S
  31. skiboot.spec
README.md

skiboot

Firmware for OpenPower systems.

Source: https://github.com/open-power/skiboot

Mailing list: skiboot@lists.ozlabs.org

Info/subscribe: https://lists.ozlabs.org/listinfo/skiboot

Archives: https://lists.ozlabs.org/pipermail/skiboot/

Patchwork: http://patchwork.ozlabs.org/project/skiboot/list/

Overview

OPAL firmware (OpenPower Abstraction Layer) comes in several parts.

A simplified flow of what happens when the power button is pressed is:

  1. The baseboard management controller (BMC) powers the system on.
  2. The BMC selects the master chip and releases the self-boot engines (SBEs) on the POWER8 chips, master last.
  3. The BMC relinquishes control of the flexible service interface (FSI) SCAN/SCOM engines.
  4. The hostboot firmware IPLs the system. It initiates a secondary power-on sequence through a digital power systems sweep (DPSS).
  5. The hostboot firmware loads the OPAL image and moves all processors to their execution starting points.

Here, the OPAL image is three parts:

  1. skiboot (includes OPAL runtime services)
  2. skiroot - the bootloader environment
    • kernel
    • initramfs (containing petitboot bootloader)

They may be all part of one payload or three separate images (depending on platform).

The bootloader will kexec a host kernel (probably linux). The host OS can make OPAL calls. The OPAL API is documented in doc/opal-api/ (there are missing parts, patches are welcome!)

See doc/overview.rst for a more in depth overview of skiboot.

Building

Any host OS can build and test skiboot provided it has a C cross compiler for big endian powerpc64. All good Linux distributions (and several bad ones) provide a packaged compiler that can be installed through the usual package management tools.

To build on Ubuntu:

apt-get install gcc-powerpc64le-linux-gnu gcc valgrind \
	expect libssl-dev device-tree-compiler make \
	xz-utils
CROSS=powerpc64le-linux-gnu- make -j`nproc`

To build on Fedora:

dnf install gcc-powerpc64le-linux-gnu binutils-powerpc64-linux-gnu gcc make \
    diffutils findutils expect valgrind-devel dtc openssl-devel xz
CROSS=powerpc64le-linux-gnu- make -j`nproc`

(The little-endian powerpc64le compilers in Ubuntu and Fedora are actually bi-endian and can compile skiboot even though it's big-endian. We recommend installing a little-endian toolchain if you plan on building other projects.)

On any POWER system with a bi-endian system compiler:

CROSS="" make -j`nproc`

Alternatively, pre-built cross compilers for x86 systems can be downloaded from here: https://www.kernel.org/pub/tools/crosstool/ When using these compilers add /opt/cross/gcc-4.8.0-nolibc/powerpc64-linux/bin/ to your PATH. Once this is done skiboot can be compiler by just running make

Testing

Skiboot comes with a set of unit tests that can be run on your desktop. They can can be run with:

make check

To test in a simulator, install the IBM POWER8 Functional Simulator from: http://www-304.ibm.com/support/customercare/sas/f/pwrfs/home.html Also see external/mambo/README.md

Qemu (as of 2.2.0) is not suitable as it does not (yet) implement the HyperVisor mode of the POWER8 processor. See https://www.flamingspork.com/blog/2015/08/28/running-opal-in-qemu-the-powernv-platform/ for instructions on how to use a work-in-progress patchset to qemu that may be suitable for some work.

To run a boot-to-bootloader test, you'll need a zImage.papr built using the mambo_defconfig config for op-build. See https://github.com/open-power/op-build/ on howto build. Drop zImage.epapr in the skiboot directory and the skiboot test suite will automatically pick it up.

See opal-ci/README for further testing instructions.

To test on real hardware, you will need to understand how to flash new skiboot onto your system. This will vary from platform to platform.

You may want to start with external/boot-tests/boot_test.sh as it can (provided the correct usernames/passwords) automatically flash a new skiboot onto ASTBMC based OpenPower machines.

Hacking

All patches should be sent to the mailing list with linux-kernel style ‘Signed-Off-By’. The following git commands are your friends:

git commit -s
git format-patch

You probably want to read the linux https://kernel.org/doc/html/latest/process/submitting-patches.html as much of it applies to skiboot.

Output files

The Skiboot build process produces a bunch of different outputs. This is what they are, and where you should use them:

skiboot.elf: The output of the linker. Don't flash to a system, but useful when debugging

skiboot.lid: The raw binary object, named .lid because IBM. Flash this on really old P8 systems, the POWER Functional Simulator (mambo), or FSP systems

skiboot.lid.stb: Lid wrapped with secure boot header. Use on FSP systems

skiboot.lid.xz: Compressed raw binary. Use this on a OpenPower P8

skiboot.lid.xz.stb: Compressed raw binary wrapped with a secure boot header. Use this on OpenPower P9 systems

License

See LICENSE