Return to switch.S CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / arch / amd64

Annotation of qemu/roms/openbios/arch/amd64/switch.S, revision 1.1.1.1

1.1       root        1:        .globl  entry, __switch_context, __exit_context, halt
                      2: 
                      3:        .text
                      4:        .align  4
                      5: 
                      6: /*
                      7:  * Entry point
                      8:  * We start execution from here.
                      9:  * It is assumed that CPU is in 32-bit protected mode and
                     10:  * all segments are 4GB and base zero (flat model).
                     11:  */
                     12: entry:
                     13:        /* Save boot context and switch to our main context.
                     14:         * Main context is statically defined in C.
                     15:         */
                     16:        pushl   %cs
                     17:        call    __switch_context
                     18: 
                     19:        /* We get here when the main context switches back to
                     20:         * the boot context.
                     21:         * Return to previous bootloader.
                     22:         */
                     23:        ret
                     24: 
                     25: /*
                     26:  * Switch execution context
                     27:  * This saves registers, segments, and GDT in the stack, then
                     28:  * switches the stack, and restores everything from the new stack.
                     29:  * This function takes no argument. New stack pointer is
                     30:  * taken from global variable __context, and old stack pointer
                     31:  * is also saved to __context. This way we can just jump to
                     32:  * this routine to get back to the original context.
                     33:  *
                     34:  * Call this routine with lcall or pushl %cs; call.
                     35:  */
                     36: __switch_context:
                     37:        /* Save everything in current stack */
                     38:        pushfl              /* 56 */
                     39:        pushl   %ds         /* 52 */
                     40:        pushl   %es         /* 48 */
                     41:        pushl   %fs         /* 44 */
                     42:        pushl   %gs         /* 40 */
                     43:        pushal              /* 8 */
                     44:        subl    $8, %esp
                     45:        movw    %ss, (%esp) /* 0 */
                     46:        sgdt    2(%esp)     /* 2 */
                     47: 
                     48: #if 0
                     49:        /* Swap %cs and %eip on the stack, so lret will work */
                     50:        movl    60(%esp), %eax
                     51:        xchgl   %eax, 64(%esp)
                     52:        movl    %eax, 60(%esp)
                     53: #endif
                     54: 
                     55:        /* At this point we don't know if we are on flat segment
                     56:         * or relocated. So compute the address offset from %eip.
                     57:         * Assuming CS.base==DS.base==SS.base.
                     58:         */
                     59:        call    1f
                     60: 1:     popl    %ebx
                     61:        subl    $1b, %ebx
                     62: 
                     63:        /* Interrupts are not allowed... */
                     64:        cli
                     65: 
                     66:        /* Current context pointer is our stack pointer */
                     67:        movl    %esp, %esi
                     68: 
                     69:        /* Normalize the ctx pointer */
                     70:        subl    %ebx, %esi
                     71: 
                     72:        /* Swap it with new value */
                     73:        xchgl   %esi, __context(%ebx)
                     74: 
                     75:        /* Adjust new ctx pointer for current address offset */
                     76:        addl    %ebx, %esi
                     77: 
                     78:        /* Load new %ss and %esp to temporary */
                     79:        movzwl  (%esi), %edx
                     80:        movl    20(%esi), %eax
                     81: 
                     82:        /* Load new GDT */
                     83:        lgdt    2(%esi)
                     84: 
                     85:        /* Load new stack segment with new GDT */
                     86:        movl    %edx, %ss
                     87: 
                     88:        /* Set new stack pointer, but we have to adjust it because
                     89:         * pushal saves %esp value before pushal, and we want the value
                     90:         * after pushal.
                     91:         */
                     92:        leal    -32(%eax), %esp
                     93: 
                     94:        /* Load the rest from new stack */
                     95:        popal
                     96:        popl    %gs
                     97:        popl    %fs
                     98:        popl    %es
                     99:        popl    %ds
                    100:        popfl
                    101: 
                    102:        /* Finally, load new %cs and %eip */
                    103:        lret
                    104: 
                    105: __exit_context:
                    106:        /* Get back to the original context */
                    107:        pushl   %cs
                    108:        call    __switch_context
                    109: 
                    110:        /* We get here if the other context attempt to switch to this
                    111:         * dead context. This should not happen. */
                    112: 
                    113: halt:
                    114:        cli
                    115:        hlt
                    116:        jmp     halt

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.