4. The Virtual Flags

Info written by Hans <lermen@fgan.de> to describe the virtual flags used by DOSEmu

• DOS sees only IF, but IF will never really set in the CPU flagregister, because this would block Linux. So Linus maintains a virtual IF (VIF), which he sets and resets accordingly to CLI, STI, POPFx, IRETx. Because the DOS programm cannot look directly into the flagregister (exception the low 8 bits, but the IF is in bit 9), it does not realize, that the IF isn't set. To see it, it has to perform PUSHF and look at the stack. Well, but PUSHF or INTxx is intercepted by vm86 and then Linus looks at his virtual IF to set the IF on the stack. Also, if IRETx or POPFx happen, Linus is getting the IF from the stack, sets VIF accordingly, but leaves the real IF untouched.
• Now, how is this realized? This is a bit more complicated. We have 3 places were the eflag register is stored in memory:

  vm86s.regs.eflags

  in user space, seen by dosemu

  current->tss.v86flags

  virtual flags, macro VEFLAGS

  current->tss.vm86_info->regs.eflags

  the real flags, CPU reg. VM86

  The last one is a kernel space copy of vm86_struct.regs.eflags. Also there are some masks to define, which bits of the flag should be passed to DOS and which should be taken from DOS:

  current->tss.v86mask

  CPU model dependent bits

  SAFE_MASK (0xDD5)

  used the way to DOS

  RETURN_MASK (0xDFF)

  used the way from DOS

  When sys_vm86 is entered, it first makes a copy of the whole vm86_struct vm86s (containing regs.eflags) and saves a pointer to it to current->tss.vm86_info. It merges the flags from 32-bit user space (NOTE: IF is always set) over SAFE_MASK and current->tss.v86mask into current->tss.v86mask. From this point on, all changes to VIF, VIP (virtual interrupt pending) are only done in VEFLAGS. To handle the flag setting there are macros within vm86.c, which do the following:

  set_IF, clear_IF

  only modifies VEFLAGS;

  clear_TF

  sets a bit in the real flags;

  set_vflags(x)

  set flags x over SAFE_MASK to real flags (IF is not touched)

  x=get_vflags

  returns real flags over RETURN_MASK and translates VIF of VEFLAGS to IF in x;

  When it's time to return from vm86() to user space, the real flags are merged together with VIF and VIP from VEFLAGS and put into the userspace vm86s.regs.eflags. This is done by save_v86_state() and this does not translate the VIF to IF, it should be as it was on entry of sys_vm86: set to 1.
• Now what are we doing with eflags in dosemu ? Well, this I don't really know. I saw IF used (told it Larry), I saw VIF tested an set, I saw TF cleared, and NT flag e.t.c. But I know what Linus thinks that we should do: Always interpret and set VIF, and let IF untouched, it will nevertheless set to 1 at entry of sys_vm86. How I think we should proceed? Well this I did describe in my last mail. ,,,, and this from a follow-up mail: NOTE VIF and VIP in DOS-CPU-flagsregister are inherited from 32-bit, so actually they are both ZERO. On return to 32-bit, only VIF will appear in vm86s.regs.eflags ! VIP will be ZERO, again: VIP will be used only once !!!!

  [ ,,, ]

  I have to add, that VIP will be cleared, because it is not in any of the masks of vm86.