arm64 support for stuart

["Ard Biesheuvel" <ardb@kernel.org>]

Hello all,

Given some recent issues with OVMF and ArmVirtPkg, where regressions
were not caught, or resulted in different behavior between TCG
(emulation) and KVM (virtualized executon) when running under KVM.

So I have started with increasing the test coverage for ArmVIrtPkg,
even for configurations that are not necessarily used in production.
(E.g., ArmVirtQemu can be built with secure boot support, even though
the virtual platform is not constructed in a way where using it makes
a lot of sense). This should increase the likelihood that we will
catch CryptoPkg or SecurityPkg build time regressions that could
potentially affect other ARM platforms as well.

Another thing I would like to implement is support for running QEMU in
KVM mode from stuart_build.py. One aspect of that is deciding whether
or not KVM is available and accessible (suggestions welcome,
especially with the containerized build env now in the mix)

On arm64, the architecture is much more finicky when it comes to
memory ordering, alignment and mismatched memory attributes and
coherency, and so enabling boot testing under KVM would be a
meaningful addition there as well, given that TCG emulation does not
model any of these behaviors However, the stuart stack fails to locate
some of its dependencies (notably mu_nasm and iasl), and so I cannot
even build the firmware on a arm64 Linux system, let alone execute it
under virtualization.

Given that nasm is x86 specific, we should be able to work around this
by moving the nasm_ext_dep.yaml file into the right place. Then,
if/when mu_nasm for arm64 becomes available, we will also be able to
build OVMF from arm64 (although I am probably the only person in the
world who does that regularly.)

iasl is a different matter, as we need it to build for arm64 as well.
iasl is already available in the arm64 distros, so as I see it, there
are 3 options here:
- build iasl for Linux/arm64 and add it to the nuget repo
- allow a fallback to system-wide iasl (how?)
- install the x86 version and run it under qemu user mode emulation
(which can be enabled transparently on most distros using binfmt-misc)

I have no idea whether or not the latter is feasible in terms of
dependencies (i.e., if the binaries are statically built, it should be
straightforward, but otherwise it is going to be tricky)

With this out of the way, I can happily run stuart_setup/update/build
and build and boot test ArmVirtQemu under KVM virtualization.