2 * vm86 linux syscall support
4 * Copyright (c) 2003 Fabrice Bellard
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
32 #define set_flags(X,new,mask) \
33 ((X) = ((X) & ~(mask)) | ((new) & (mask)))
35 #define SAFE_MASK (0xDD5)
36 #define RETURN_MASK (0xDFF)
38 static inline int is_revectored(int nr
, struct target_revectored_struct
*bitmap
)
40 return (((uint8_t *)bitmap
)[nr
>> 3] >> (nr
& 7)) & 1;
43 static inline void vm_putw(uint32_t segptr
, unsigned int reg16
, unsigned int val
)
45 stw(segptr
+ (reg16
& 0xffff), val
);
48 static inline void vm_putl(uint32_t segptr
, unsigned int reg16
, unsigned int val
)
50 stl(segptr
+ (reg16
& 0xffff), val
);
53 static inline unsigned int vm_getb(uint32_t segptr
, unsigned int reg16
)
55 return ldub(segptr
+ (reg16
& 0xffff));
58 static inline unsigned int vm_getw(uint32_t segptr
, unsigned int reg16
)
60 return lduw(segptr
+ (reg16
& 0xffff));
63 static inline unsigned int vm_getl(uint32_t segptr
, unsigned int reg16
)
65 return ldl(segptr
+ (reg16
& 0xffff));
68 void save_v86_state(CPUX86State
*env
)
70 TaskState
*ts
= env
->opaque
;
71 struct target_vm86plus_struct
* target_v86
;
73 if (!lock_user_struct(VERIFY_WRITE
, target_v86
, ts
->target_v86
, 0))
74 /* FIXME - should return an error */
76 /* put the VM86 registers in the userspace register structure */
77 target_v86
->regs
.eax
= tswap32(env
->regs
[R_EAX
]);
78 target_v86
->regs
.ebx
= tswap32(env
->regs
[R_EBX
]);
79 target_v86
->regs
.ecx
= tswap32(env
->regs
[R_ECX
]);
80 target_v86
->regs
.edx
= tswap32(env
->regs
[R_EDX
]);
81 target_v86
->regs
.esi
= tswap32(env
->regs
[R_ESI
]);
82 target_v86
->regs
.edi
= tswap32(env
->regs
[R_EDI
]);
83 target_v86
->regs
.ebp
= tswap32(env
->regs
[R_EBP
]);
84 target_v86
->regs
.esp
= tswap32(env
->regs
[R_ESP
]);
85 target_v86
->regs
.eip
= tswap32(env
->eip
);
86 target_v86
->regs
.cs
= tswap16(env
->segs
[R_CS
].selector
);
87 target_v86
->regs
.ss
= tswap16(env
->segs
[R_SS
].selector
);
88 target_v86
->regs
.ds
= tswap16(env
->segs
[R_DS
].selector
);
89 target_v86
->regs
.es
= tswap16(env
->segs
[R_ES
].selector
);
90 target_v86
->regs
.fs
= tswap16(env
->segs
[R_FS
].selector
);
91 target_v86
->regs
.gs
= tswap16(env
->segs
[R_GS
].selector
);
92 set_flags(env
->eflags
, ts
->v86flags
, VIF_MASK
| ts
->v86mask
);
93 target_v86
->regs
.eflags
= tswap32(env
->eflags
);
94 unlock_user_struct(target_v86
, ts
->target_v86
, 1);
96 fprintf(logfile
, "save_v86_state: eflags=%08x cs:ip=%04x:%04x\n",
97 env
->eflags
, env
->segs
[R_CS
].selector
, env
->eip
);
100 /* restore 32 bit registers */
101 env
->regs
[R_EAX
] = ts
->vm86_saved_regs
.eax
;
102 env
->regs
[R_EBX
] = ts
->vm86_saved_regs
.ebx
;
103 env
->regs
[R_ECX
] = ts
->vm86_saved_regs
.ecx
;
104 env
->regs
[R_EDX
] = ts
->vm86_saved_regs
.edx
;
105 env
->regs
[R_ESI
] = ts
->vm86_saved_regs
.esi
;
106 env
->regs
[R_EDI
] = ts
->vm86_saved_regs
.edi
;
107 env
->regs
[R_EBP
] = ts
->vm86_saved_regs
.ebp
;
108 env
->regs
[R_ESP
] = ts
->vm86_saved_regs
.esp
;
109 env
->eflags
= ts
->vm86_saved_regs
.eflags
;
110 env
->eip
= ts
->vm86_saved_regs
.eip
;
112 cpu_x86_load_seg(env
, R_CS
, ts
->vm86_saved_regs
.cs
);
113 cpu_x86_load_seg(env
, R_SS
, ts
->vm86_saved_regs
.ss
);
114 cpu_x86_load_seg(env
, R_DS
, ts
->vm86_saved_regs
.ds
);
115 cpu_x86_load_seg(env
, R_ES
, ts
->vm86_saved_regs
.es
);
116 cpu_x86_load_seg(env
, R_FS
, ts
->vm86_saved_regs
.fs
);
117 cpu_x86_load_seg(env
, R_GS
, ts
->vm86_saved_regs
.gs
);
120 /* return from vm86 mode to 32 bit. The vm86() syscall will return
122 static inline void return_to_32bit(CPUX86State
*env
, int retval
)
125 fprintf(logfile
, "return_to_32bit: ret=0x%x\n", retval
);
128 env
->regs
[R_EAX
] = retval
;
131 static inline int set_IF(CPUX86State
*env
)
133 TaskState
*ts
= env
->opaque
;
135 ts
->v86flags
|= VIF_MASK
;
136 if (ts
->v86flags
& VIP_MASK
) {
137 return_to_32bit(env
, TARGET_VM86_STI
);
143 static inline void clear_IF(CPUX86State
*env
)
145 TaskState
*ts
= env
->opaque
;
147 ts
->v86flags
&= ~VIF_MASK
;
150 static inline void clear_TF(CPUX86State
*env
)
152 env
->eflags
&= ~TF_MASK
;
155 static inline void clear_AC(CPUX86State
*env
)
157 env
->eflags
&= ~AC_MASK
;
160 static inline int set_vflags_long(unsigned long eflags
, CPUX86State
*env
)
162 TaskState
*ts
= env
->opaque
;
164 set_flags(ts
->v86flags
, eflags
, ts
->v86mask
);
165 set_flags(env
->eflags
, eflags
, SAFE_MASK
);
166 if (eflags
& IF_MASK
)
173 static inline int set_vflags_short(unsigned short flags
, CPUX86State
*env
)
175 TaskState
*ts
= env
->opaque
;
177 set_flags(ts
->v86flags
, flags
, ts
->v86mask
& 0xffff);
178 set_flags(env
->eflags
, flags
, SAFE_MASK
);
186 static inline unsigned int get_vflags(CPUX86State
*env
)
188 TaskState
*ts
= env
->opaque
;
191 flags
= env
->eflags
& RETURN_MASK
;
192 if (ts
->v86flags
& VIF_MASK
)
195 return flags
| (ts
->v86flags
& ts
->v86mask
);
198 #define ADD16(reg, val) reg = (reg & ~0xffff) | ((reg + (val)) & 0xffff)
200 /* handle VM86 interrupt (NOTE: the CPU core currently does not
201 support TSS interrupt revectoring, so this code is always executed) */
202 static void do_int(CPUX86State
*env
, int intno
)
204 TaskState
*ts
= env
->opaque
;
205 uint32_t int_addr
, segoffs
, ssp
;
208 if (env
->segs
[R_CS
].selector
== TARGET_BIOSSEG
)
210 if (is_revectored(intno
, &ts
->vm86plus
.int_revectored
))
212 if (intno
== 0x21 && is_revectored((env
->regs
[R_EAX
] >> 8) & 0xff,
213 &ts
->vm86plus
.int21_revectored
))
215 int_addr
= (intno
<< 2);
216 segoffs
= ldl(int_addr
);
217 if ((segoffs
>> 16) == TARGET_BIOSSEG
)
219 #if defined(DEBUG_VM86)
220 fprintf(logfile
, "VM86: emulating int 0x%x. CS:IP=%04x:%04x\n",
221 intno
, segoffs
>> 16, segoffs
& 0xffff);
224 ssp
= env
->segs
[R_SS
].selector
<< 4;
225 sp
= env
->regs
[R_ESP
] & 0xffff;
226 vm_putw(ssp
, sp
- 2, get_vflags(env
));
227 vm_putw(ssp
, sp
- 4, env
->segs
[R_CS
].selector
);
228 vm_putw(ssp
, sp
- 6, env
->eip
);
229 ADD16(env
->regs
[R_ESP
], -6);
230 /* goto interrupt handler */
231 env
->eip
= segoffs
& 0xffff;
232 cpu_x86_load_seg(env
, R_CS
, segoffs
>> 16);
238 #if defined(DEBUG_VM86)
239 fprintf(logfile
, "VM86: return to 32 bits int 0x%x\n", intno
);
241 return_to_32bit(env
, TARGET_VM86_INTx
| (intno
<< 8));
244 void handle_vm86_trap(CPUX86State
*env
, int trapno
)
246 if (trapno
== 1 || trapno
== 3) {
247 return_to_32bit(env
, TARGET_VM86_TRAP
+ (trapno
<< 8));
253 #define CHECK_IF_IN_TRAP() \
254 if ((ts->vm86plus.vm86plus.flags & TARGET_vm86dbg_active) && \
255 (ts->vm86plus.vm86plus.flags & TARGET_vm86dbg_TFpendig)) \
258 #define VM86_FAULT_RETURN \
259 if ((ts->vm86plus.vm86plus.flags & TARGET_force_return_for_pic) && \
260 (ts->v86flags & (IF_MASK | VIF_MASK))) \
261 return_to_32bit(env, TARGET_VM86_PICRETURN); \
264 void handle_vm86_fault(CPUX86State
*env
)
266 TaskState
*ts
= env
->opaque
;
268 unsigned int ip
, sp
, newflags
, newip
, newcs
, opcode
, intno
;
269 int data32
, pref_done
;
271 csp
= env
->segs
[R_CS
].selector
<< 4;
272 ip
= env
->eip
& 0xffff;
274 ssp
= env
->segs
[R_SS
].selector
<< 4;
275 sp
= env
->regs
[R_ESP
] & 0xffff;
277 #if defined(DEBUG_VM86)
278 fprintf(logfile
, "VM86 exception %04x:%08x\n",
279 env
->segs
[R_CS
].selector
, env
->eip
);
285 opcode
= vm_getb(csp
, ip
);
288 case 0x66: /* 32-bit data */ data32
=1; break;
289 case 0x67: /* 32-bit address */ break;
290 case 0x2e: /* CS */ break;
291 case 0x3e: /* DS */ break;
292 case 0x26: /* ES */ break;
293 case 0x36: /* SS */ break;
294 case 0x65: /* GS */ break;
295 case 0x64: /* FS */ break;
296 case 0xf2: /* repnz */ break;
297 case 0xf3: /* rep */ break;
298 default: pref_done
= 1;
300 } while (!pref_done
);
304 case 0x9c: /* pushf */
306 vm_putl(ssp
, sp
- 4, get_vflags(env
));
307 ADD16(env
->regs
[R_ESP
], -4);
309 vm_putw(ssp
, sp
- 2, get_vflags(env
));
310 ADD16(env
->regs
[R_ESP
], -2);
315 case 0x9d: /* popf */
317 newflags
= vm_getl(ssp
, sp
);
318 ADD16(env
->regs
[R_ESP
], 4);
320 newflags
= vm_getw(ssp
, sp
);
321 ADD16(env
->regs
[R_ESP
], 2);
326 if (set_vflags_long(newflags
, env
))
329 if (set_vflags_short(newflags
, env
))
335 intno
= vm_getb(csp
, ip
);
338 if (ts
->vm86plus
.vm86plus
.flags
& TARGET_vm86dbg_active
) {
339 if ( (ts
->vm86plus
.vm86plus
.vm86dbg_intxxtab
[intno
>> 3] >>
341 return_to_32bit(env
, TARGET_VM86_INTx
+ (intno
<< 8));
348 case 0xcf: /* iret */
350 newip
= vm_getl(ssp
, sp
) & 0xffff;
351 newcs
= vm_getl(ssp
, sp
+ 4) & 0xffff;
352 newflags
= vm_getl(ssp
, sp
+ 8);
353 ADD16(env
->regs
[R_ESP
], 12);
355 newip
= vm_getw(ssp
, sp
);
356 newcs
= vm_getw(ssp
, sp
+ 2);
357 newflags
= vm_getw(ssp
, sp
+ 4);
358 ADD16(env
->regs
[R_ESP
], 6);
361 cpu_x86_load_seg(env
, R_CS
, newcs
);
364 if (set_vflags_long(newflags
, env
))
367 if (set_vflags_short(newflags
, env
))
384 /* real VM86 GPF exception */
385 return_to_32bit(env
, TARGET_VM86_UNKNOWN
);
390 int do_vm86(CPUX86State
*env
, long subfunction
, abi_ulong vm86_addr
)
392 TaskState
*ts
= env
->opaque
;
393 struct target_vm86plus_struct
* target_v86
;
396 switch (subfunction
) {
397 case TARGET_VM86_REQUEST_IRQ
:
398 case TARGET_VM86_FREE_IRQ
:
399 case TARGET_VM86_GET_IRQ_BITS
:
400 case TARGET_VM86_GET_AND_RESET_IRQ
:
401 gemu_log("qemu: unsupported vm86 subfunction (%ld)\n", subfunction
);
402 ret
= -TARGET_EINVAL
;
404 case TARGET_VM86_PLUS_INSTALL_CHECK
:
405 /* NOTE: on old vm86 stuff this will return the error
406 from verify_area(), because the subfunction is
407 interpreted as (invalid) address to vm86_struct.
408 So the installation check works.
414 /* save current CPU regs */
415 ts
->vm86_saved_regs
.eax
= 0; /* default vm86 syscall return code */
416 ts
->vm86_saved_regs
.ebx
= env
->regs
[R_EBX
];
417 ts
->vm86_saved_regs
.ecx
= env
->regs
[R_ECX
];
418 ts
->vm86_saved_regs
.edx
= env
->regs
[R_EDX
];
419 ts
->vm86_saved_regs
.esi
= env
->regs
[R_ESI
];
420 ts
->vm86_saved_regs
.edi
= env
->regs
[R_EDI
];
421 ts
->vm86_saved_regs
.ebp
= env
->regs
[R_EBP
];
422 ts
->vm86_saved_regs
.esp
= env
->regs
[R_ESP
];
423 ts
->vm86_saved_regs
.eflags
= env
->eflags
;
424 ts
->vm86_saved_regs
.eip
= env
->eip
;
425 ts
->vm86_saved_regs
.cs
= env
->segs
[R_CS
].selector
;
426 ts
->vm86_saved_regs
.ss
= env
->segs
[R_SS
].selector
;
427 ts
->vm86_saved_regs
.ds
= env
->segs
[R_DS
].selector
;
428 ts
->vm86_saved_regs
.es
= env
->segs
[R_ES
].selector
;
429 ts
->vm86_saved_regs
.fs
= env
->segs
[R_FS
].selector
;
430 ts
->vm86_saved_regs
.gs
= env
->segs
[R_GS
].selector
;
432 ts
->target_v86
= vm86_addr
;
433 if (!lock_user_struct(VERIFY_READ
, target_v86
, vm86_addr
, 1))
434 return -TARGET_EFAULT
;
435 /* build vm86 CPU state */
436 ts
->v86flags
= tswap32(target_v86
->regs
.eflags
);
437 env
->eflags
= (env
->eflags
& ~SAFE_MASK
) |
438 (tswap32(target_v86
->regs
.eflags
) & SAFE_MASK
) | VM_MASK
;
440 ts
->vm86plus
.cpu_type
= tswapl(target_v86
->cpu_type
);
441 switch (ts
->vm86plus
.cpu_type
) {
446 ts
->v86mask
= NT_MASK
| IOPL_MASK
;
449 ts
->v86mask
= AC_MASK
| NT_MASK
| IOPL_MASK
;
452 ts
->v86mask
= ID_MASK
| AC_MASK
| NT_MASK
| IOPL_MASK
;
456 env
->regs
[R_EBX
] = tswap32(target_v86
->regs
.ebx
);
457 env
->regs
[R_ECX
] = tswap32(target_v86
->regs
.ecx
);
458 env
->regs
[R_EDX
] = tswap32(target_v86
->regs
.edx
);
459 env
->regs
[R_ESI
] = tswap32(target_v86
->regs
.esi
);
460 env
->regs
[R_EDI
] = tswap32(target_v86
->regs
.edi
);
461 env
->regs
[R_EBP
] = tswap32(target_v86
->regs
.ebp
);
462 env
->regs
[R_ESP
] = tswap32(target_v86
->regs
.esp
);
463 env
->eip
= tswap32(target_v86
->regs
.eip
);
464 cpu_x86_load_seg(env
, R_CS
, tswap16(target_v86
->regs
.cs
));
465 cpu_x86_load_seg(env
, R_SS
, tswap16(target_v86
->regs
.ss
));
466 cpu_x86_load_seg(env
, R_DS
, tswap16(target_v86
->regs
.ds
));
467 cpu_x86_load_seg(env
, R_ES
, tswap16(target_v86
->regs
.es
));
468 cpu_x86_load_seg(env
, R_FS
, tswap16(target_v86
->regs
.fs
));
469 cpu_x86_load_seg(env
, R_GS
, tswap16(target_v86
->regs
.gs
));
470 ret
= tswap32(target_v86
->regs
.eax
); /* eax will be restored at
471 the end of the syscall */
472 memcpy(&ts
->vm86plus
.int_revectored
,
473 &target_v86
->int_revectored
, 32);
474 memcpy(&ts
->vm86plus
.int21_revectored
,
475 &target_v86
->int21_revectored
, 32);
476 ts
->vm86plus
.vm86plus
.flags
= tswapl(target_v86
->vm86plus
.flags
);
477 memcpy(&ts
->vm86plus
.vm86plus
.vm86dbg_intxxtab
,
478 target_v86
->vm86plus
.vm86dbg_intxxtab
, 32);
479 unlock_user_struct(target_v86
, vm86_addr
, 0);
482 fprintf(logfile
, "do_vm86: cs:ip=%04x:%04x\n",
483 env
->segs
[R_CS
].selector
, env
->eip
);
485 /* now the virtual CPU is ready for vm86 execution ! */