OSDev.org

sancho1980 wrote:yes i have checked that
an my tss really looks fine
i was just wondering: when an iret occurs from ring0 to ring3, is there any kind of stack switch involved?
the reason im asking is the following: the tss data structure provides fields for ss/esp0-2 and another two fields for the programs stack segment and stack pointer registers.
i only use these last two fields, i.e. the fields for storing the esp and ss, because my os doesnt use call gates
i "misuse" the ss/esp0-2 for other purposes, because i use the tss data structure as my process data structure, so i store stuff like the process' quantum and so on in there
is there any problem with that?

sancho1980 wrote: stack switching really shouldn't be an issue because this way stack switches should never occur

sancho1980 wrote:hi sorry i didnt reply earlier but didnt have time:
i'm pretty sure you're wrong here; there really shouldn't be any stack switching in my os; what you need to take into account here *reallyreallyreally* is that i'm using hardware task switching; and that means (quotation from http://download.intel.com/design/proces ... 253668.pdf chapter 6.4):

When a CALL instruction, an interrupt, or an exception causes a task switch: the
processor copies the segment selector for the current TSS to the previous task link
field of the TSS for the new task; it then sets EFLAGS.NT = 1. If software uses an
IRET instruction to suspend the new task, the processor checks for EFLAGS.NT = 1;
it then uses the value in the previous task link field to return to the previous task. See
Figures 6-8.

This is what I'm doing. I am NOT doing software task switches.

Section 6.1:
If an operating system or executive uses the processor’s privilege-level protection mechanism, the task execution space also provides a separate stack for each privilege level.

Description
Returns program control from an exception or interrupt handler to a program or
procedure that was interrupted by an exception, an external interrupt, or a software-
generated interrupt. These instructions are also used to perform a return from a
nested task. (A nested task is created when a CALL instruction is used to initiate a
task switch or when an interrupt or exception causes a task switch to an interrupt or
exception handler.) See the section titled “Task Linking” in Chapter 6 of the Intel® 64
and IA-32 Architectures Software Developer’s Manual, Volume 3A.
IRET and IRETD are mnemonics for the same opcode. The IRETD mnemonic (inter-
rupt return double) is intended for use when returning from an interrupt when using
the 32-bit operand size; however, most assemblers use the IRET mnemonic inter-
changeably for both operand sizes.
In Real-Address Mode, the IRET instruction preforms a far return to the interrupted
program or procedure. During this operation, the processor pops the return instruc-
tion pointer, return code segment selector, and EFLAGS image from the stack to the
EIP, CS, and EFLAGS registers, respectively, and then resumes execution of the inter-
rupted program or procedure.
In Protected Mode, the action of the IRET instruction depends on the settings of the
NT (nested task) and VM flags in the EFLAGS register and the VM flag in the EFLAGS
image stored on the current stack. Depending on the setting of these flags, the
processor performs the following types of interrupt returns:
• Return from virtual-8086 mode.
• Return to virtual-8086 mode.
• Intra-privilege level return.
• Inter-privilege level return.
• Return from nested task (task switch).
If the NT flag (EFLAGS register) is cleared, the IRET instruction performs a far return
from the interrupt procedure, without a task switch. The code segment being
returned to must be equally or less privileged than the interrupt handler routine (as
indicated by the RPL field of the code segment selector popped from the stack).
3-530 Vol. 2A IRET/IRETD—Interrupt Return
INSTRUCTION SET REFERENCE, A-M
As with a real-address mode interrupt return, the IRET instruction pops the return
instruction pointer, return code segment selector, and EFLAGS image from the stack
to the EIP, CS, and EFLAGS registers, respectively, and then resumes execution of
the interrupted program or procedure. If the return is to another privilege level, the
IRET instruction also pops the stack pointer and SS from the stack, before resuming
program execution. If the return is to virtual-8086 mode, the processor also pops the
data segment registers from the stack.
If the NT flag is set, the IRET instruction performs a task switch (return) from a
nested task (a task called with a CALL instruction, an interrupt, or an exception) back
to the calling or interrupted task. The updated state of the task executing the IRET
instruction is saved in its TSS. If the task is re-entered later, the code that follows the
IRET instruction is executed.