seabios | This project implements

As you just removed the files instead of using apt-get or dpkg to uninstall the package, the package management is not aware of your manual removal, and so apt-get and dpkg still think the newest version is already installed, and so do nothing.

apt-get --reinstall install vagrant

should solve this.

I found what the issue was.

While using nested virtualization, the option -cpu host works. This advises qemu to use the same cpu format as the host, which in our case is also a VM, and which mostly will be using the host CPU format too..

The above setting works,

unless; you are using nested virtualization over a virtualbox, and trying to run qemu on the VM. Then, to make this work, we have to skip enable-kvm and the -cpu option altogether. It does make the qemu VM run slow, but it works.

In the Disk Access Packet (DAP) the segment:offset pair is stored with offset first followed by segment. This is because the x86 is a little endian processor and the pair is stored in reverse order. Your DAP should be changed to:

If you compile without optimization, asm("iret") will probably run while the stack pointer is still pointing at a saved EBP value, because -fno-omit-frame-pointer is the default and the cleanup epilogue happens after the last C statement of the function.

Or it could be pointing at other saved registers. Anyway, tricking the compiler and jumping out of an inline asm statement is never going to be safe (unless you use asm goto to maybe jump to a C label inside the function, but that doesn't solve your problem).

Also, the C calling convention allows functions to clobber EAX, ECX, EDX, and the FPU state. Even if you did manage to hack an iret into your function, it would corrupt the state of the code that was interrupted. GCC will use SSE/x87 to implement _Atomic int64_t load/store in 32-bit mode, and for copying large objects, unless you compile with -mgeneral-regs-only

Also see @MichaelPetch's answer on the linked duplicate: Creating a C function without compiler generated prologue/epilogue & RET instruction? for more interesting points, and some non-GCC info.

There are 2 solutions here:

• write a pure-asm wrapper that saves the call-clobbered regs, calls your C function, then returns with iret

• declare your function with __attribute__((interrupt)) to tell GCC it's an interrupt handler. The gcc manual's x86 function attributes has an example.

  x86 support for that attribute is somewhat recent compared to traditionally-embedded ISAs like ARM, but modern GCC does know how emit functions that preserve all regs and end with iret. But you still need -mgeneral-regs-only.

See also https://wiki.osdev.org/Interrupt_Service_Routines#GCC_.2F_G.2B.2B which tells you the same thing as this answer.

(It also suggests an evil hack with pushad / popad; leave; iret which only works with optimzation disabled. I would not recommend that if you can possibly use a newer GCC that supports the interrupt attribute.)

The earlier parts of the wiki page cover the general problems with trying to use your own iret, so you can see what the total asm (compiler-generated + yours) would look like for your attempt.

As the manual says .pushsection is one of the ELF section stack manipulation directives. The cygwin target is not ELF, it's COFF/PE. As such that directive is not available (even though it would make sense).