tree 397411e3f833b1b185efb0206938a028dc7cf8b2
parent 4a015826ec48a9927258c328e849796033655d71
author Andrew Geissler <geissonator@yahoo.com> 1671724074 -0600
committer Andrew Geissler <geissonator@yahoo.com> 1671724074 -0600

qemu: misc fixes for new qemu release

- Ensure qemu is built in same ubuntu distro as where it is run
- Add new libslirp-dev dep to docker container that executes qemu

Signed-off-by: Andrew Geissler <geissonator@yahoo.com>
Change-Id: Iaa58d097de0377e4bb5ee229c5ec267ebe4565a7
