Return to context.c CVS log

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

Annotation of qemu/roms/openbios/arch/x86/context.c, revision 1.1

1.1     ! root        1: /* tag: x86  context switching
        !             2:  *
        !             3:  * 2003-10 by SONE Takeshi
        !             4:  *
        !             5:  * See the file "COPYING" for further information about
        !             6:  * the copyright and warranty status of this work.
        !             7:  */
        !             8: 
        !             9: #include "config.h"
        !            10: #include "kernel/kernel.h"
        !            11: #include "segment.h"
        !            12: #include "context.h"
        !            13: #include "libopenbios/sys_info.h"
        !            14: #include "boot.h"
        !            15: #include "openbios.h"
        !            16: 
        !            17: #define MAIN_STACK_SIZE 16384
        !            18: #define IMAGE_STACK_SIZE 4096
        !            19: 
        !            20: #define debug printk
        !            21: 
        !            22: static void start_main(void); /* forward decl. */
        !            23: void __exit_context(void); /* assembly routine */
        !            24: 
        !            25: /*
        !            26:  * Main context structure
        !            27:  * It is placed at the bottom of our stack, and loaded by assembly routine
        !            28:  * to start us up.
        !            29:  */
        !            30: static struct context main_ctx __attribute__((section (".initctx"))) = {
        !            31:     .gdt_base = (uint32_t) gdt,
        !            32:     .gdt_limit = GDT_LIMIT,
        !            33:     .cs = FLAT_CS,
        !            34:     .ds = FLAT_DS,
        !            35:     .es = FLAT_DS,
        !            36:     .fs = FLAT_DS,
        !            37:     .gs = FLAT_DS,
        !            38:     .ss = FLAT_DS,
        !            39:     .esp = (uint32_t) ESP_LOC(&main_ctx),
        !            40:     .eip = (uint32_t) start_main,
        !            41:     .return_addr = (uint32_t) __exit_context,
        !            42: };
        !            43: 
        !            44: /* This is used by assembly routine to load/store the context which
        !            45:  * it is to switch/switched.  */
        !            46: struct context *__context = &main_ctx;
        !            47: 
        !            48: /* Stack for loaded ELF image */
        !            49: static uint8_t image_stack[IMAGE_STACK_SIZE];
        !            50: 
        !            51: /* Pointer to startup context (physical address) */
        !            52: unsigned long __boot_ctx;
        !            53: 
        !            54: /*
        !            55:  * Main starter
        !            56:  * This is the C function that runs first.
        !            57:  */
        !            58: static void start_main(void)
        !            59: {
        !            60:     int retval;
        !            61: 
        !            62:     /* Save startup context, so we can refer to it later.
        !            63:      * We have to keep it in physical address since we will relocate. */
        !            64:     __boot_ctx = virt_to_phys(__context);
        !            65: 
        !            66:     init_exceptions();
        !            67:     /* Start the real fun */
        !            68:     retval = openbios();
        !            69: 
        !            70:     /* Pass return value to startup context. Bootloader may see it. */
        !            71:     boot_ctx->eax = retval;
        !            72: 
        !            73:     /* Returning from here should jump to __exit_context */
        !            74:     __context = boot_ctx;
        !            75: }
        !            76: 
        !            77: /* Setup a new context using the given stack.
        !            78:  */
        !            79: struct context *
        !            80: init_context(uint8_t *stack, uint32_t stack_size, int num_params)
        !            81: {
        !            82:     struct context *ctx;
        !            83: 
        !            84:     ctx = (struct context *)
        !            85:        (stack + stack_size - (sizeof(*ctx) + num_params*sizeof(uint32_t)));
        !            86:     memset(ctx, 0, sizeof(*ctx));
        !            87: 
        !            88:     /* Fill in reasonable default for flat memory model */
        !            89:     ctx->gdt_base = virt_to_phys(gdt);
        !            90:     ctx->gdt_limit = GDT_LIMIT;
        !            91:     ctx->cs = FLAT_CS;
        !            92:     ctx->ds = FLAT_DS;
        !            93:     ctx->es = FLAT_DS;
        !            94:     ctx->fs = FLAT_DS;
        !            95:     ctx->gs = FLAT_DS;
        !            96:     ctx->ss = FLAT_DS;
        !            97:     ctx->esp = virt_to_phys(ESP_LOC(ctx));
        !            98:     ctx->return_addr = virt_to_phys(__exit_context);
        !            99: 
        !           100:     return ctx;
        !           101: }
        !           102: 
        !           103: /* Switch to another context. */
        !           104: struct context *switch_to(struct context *ctx)
        !           105: {
        !           106:     struct context *save, *ret;
        !           107: 
        !           108:     debug("switching to new context:\n");
        !           109:     save = __context;
        !           110:     __context = ctx;
        !           111:     asm ("pushl %cs; call __switch_context");
        !           112:     ret = __context;
        !           113:     __context = save;
        !           114:     return ret;
        !           115: }
        !           116: 
        !           117: /* Start ELF Boot image */
        !           118: unsigned int start_elf(unsigned long entry_point, unsigned long param)
        !           119: {
        !           120:     struct context *ctx;
        !           121: 
        !           122:     ctx = init_context(image_stack, sizeof image_stack, 1);
        !           123:     ctx->eip = entry_point;
        !           124:     ctx->param[0] = param;
        !           125:     ctx->eax = 0xe1fb007;
        !           126:     ctx->ebx = param;
        !           127: 
        !           128:     ctx = switch_to(ctx);
        !           129:     return ctx->eax;
        !           130: }

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