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

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.