Return to context.c CVS log

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

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

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

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