Changeset 0f250f9 in mainline


Ignore:
Timestamp:
2006-03-17T18:07:56Z (19 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
69f293e
Parents:
6c6a19e6
Message:

Improved uspace threads.
ia64 needs fixing.

Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed

  • arch/amd64/src/userspace.c

    r6c6a19e6 r0f250f9  
    3131#include <arch/types.h>
    3232#include <arch.h>
    33 #include <proc/thread.h>
     33#include <proc/uarg.h>
    3434#include <mm/as.h>
    3535
    … …  
    4040 *
    4141 */
    42 void userspace(uspace_arg_t *uarg)
     42void userspace(uspace_arg_t *kernel_uarg)
    4343{
    4444        ipl_t ipl;
    … …  
    5252                          "pushq %3\n"
    5353                          "pushq %4\n"
     54                          "movq %5, %%rax\n"
    5455                          "iretq\n"
    5556                          : :
    5657                          "i" (gdtselector(UDATA_DES) | PL_USER),
    57                           "r" (uarg->uspace_stack+THREAD_STACK_SIZE),
     58                          "r" (kernel_uarg->uspace_stack+THREAD_STACK_SIZE),
    5859                          "r" (ipl),
    5960                          "i" (gdtselector(UTEXT_DES) | PL_USER),
    60                           "r" (uarg->uspace_entry));
     61                          "r" (kernel_uarg->uspace_entry),
     62                          "r" (kernel_uarg->uspace_uarg)
     63                          : "rax"
     64                          );
    6165       
    6266        /* Unreachable */
    63         for(;;);
     67        for(;;)
     68                ;
    6469}

  • arch/ia32/src/userspace.c

    r6c6a19e6 r0f250f9  
    3131#include <arch/types.h>
    3232#include <arch.h>
    33 #include <proc/thread.h>
     33#include <proc/uarg.h>
    3434#include <mm/as.h>
    3535
    … …  
    4040 *
    4141 */
    42 void userspace(uspace_arg_t *uarg)
     42void userspace(uspace_arg_t *kernel_uarg)
    4343{
    4444        ipl_t ipl;
    … …  
    4747
    4848        __asm__ volatile (
    49                 /* CLNT */
     49                /*
     50                 * Clear nested task flag.
     51                 */
    5052                "pushfl\n"
    5153                "pop %%eax\n"
    52                 "and $0xffffbfff,%%eax\n"
     54                "and $0xffffbfff, %%eax\n"
    5355                "push %%eax\n"
    5456                "popfl\n"
    … …  
    5961                "pushl %3\n"
    6062                "pushl %4\n"
     63                "movl %5, %%eax\n"
    6164                "iret"
    6265                :
    63                 : "i" (selector(UDATA_DES) | PL_USER), "r" (uarg->uspace_stack+THREAD_STACK_SIZE),
    64                   "r" (ipl), "i" (selector(UTEXT_DES) | PL_USER), "r" (uarg->uspace_entry)
     66                : "i" (selector(UDATA_DES) | PL_USER), "r" (kernel_uarg->uspace_stack+THREAD_STACK_SIZE),
     67                  "r" (ipl), "i" (selector(UTEXT_DES) | PL_USER), "r" (kernel_uarg->uspace_entry),
     68                  "r" (kernel_uarg->uspace_uarg)
    6569                : "eax");
    6670       

  • arch/ia64/include/asm.h

    r6c6a19e6 r0f250f9  
    259259extern void asm_delay_loop(__u32 t);
    260260
    261 extern void switch_to_userspace(__address entry, __address sp, __address bsp, __u64 ipsr, __u64 rsc);
     261extern void switch_to_userspace(__address entry, __address sp, __address bsp, __address uspace_uarg, __u64 ipsr, __u64 rsc);
    262262
    263263#endif

  • arch/ia64/include/faddr.h

    r6c6a19e6 r0f250f9  
    3232#include <arch/types.h>
    3333
    34 static __address FADDR(void (* fptr)(void));
    35 
    3634/**
    3735 *
    … …  
    4240 *
    4341 */
    44 inline __address FADDR(void (* fptr)(void)) {
     42static inline __address FADDR(void (* fptr)()) {
    4543        __address faddr;
    46 
    47         /*Deprecated assembler version*/
    48         /*     
    49         __asm__(
    50                 "ld8 %0 = [%1]\n\t"
    51                 : "=r" (faddr)
    52                 : "r" (fptr)
    53         );
    54         */
    5544
    5645        faddr = *((__address *)(fptr));;

  • arch/ia64/src/asm.S

    r6c6a19e6 r0f250f9  
    5555 * @param in1 Userspace stack pointer address.
    5656 * @param in2 Userspace register stack pointer address.
    57  * @param in3 Value to be stored in IPSR.
    58  * @param in4 Value to be stored in RSC.
     57 * @param in3 Userspace address of thread uspace_arg_t structure.
     58 * @param in4 Value to be stored in IPSR.
     59 * @param in5 Value to be stored in RSC.
    5960 */
    6061.global switch_to_userspace
    6162switch_to_userspace:
    62         alloc loc0 = ar.pfs, 5, 3, 0, 0
     63        alloc loc0 = ar.pfs, 6, 3, 0, 0
    6364        rsm (PSR_IC_MASK | PSR_I_MASK)          /* disable interruption collection and interrupts */
    6465        srlz.d ;;
    6566        srlz.i ;;
    6667       
    67         mov cr.ipsr = in3
     68        mov cr.ipsr = in4
    6869        mov cr.iip = in0
    6970        mov r12 = in1
    … …  
    8586       
    8687        mov ar.bspstore = in2 ;;
    87         mov ar.rsc = in4 ;;
     88        mov ar.rsc = in5 ;;
     89       
     90        mov r8 = in3
    8891       
    8992        rfi ;;

  • arch/ia64/src/ia64.c

    r6c6a19e6 r0f250f9  
    4242#include <userspace.h>
    4343#include <console/console.h>
    44 #include <proc/thread.h>
     44#include <proc/uarg.h>
    4545
    4646void arch_pre_mm_init(void)
    … …  
    7474
    7575/** Enter userspace and never return. */
    76 void userspace(uspace_arg_t *uarg)
     76void userspace(uspace_arg_t *kernel_uarg)
    7777{
    7878        psr_t psr;
    … …  
    9292        rsc.mode = 3;                           /* eager mode */
    9393
    94         switch_to_userspace(uarg->uspace_entry, uarg->uspace_stack+PAGE_SIZE-ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT), uarg->uspace_stack, psr.value, rsc.value);
     94        switch_to_userspace((__address) kernel_uarg->uspace_entry,
     95                            ((__address) kernel_uarg->uspace_stack)+PAGE_SIZE-ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT),
     96                            (__address) kernel_uarg->uspace_stack,
     97                            (__address) kernel_uarg->uspace_uarg,
     98                            psr.value, rsc.value);
    9599
    96100        while (1) {

  • arch/mips32/include/asm.h

    r6c6a19e6 r0f250f9  
    5858extern void cpu_halt(void);
    5959extern void asm_delay_loop(__u32 t);
    60 extern void userspace_asm(__address ustack);
     60extern void userspace_asm(__address ustack, __address uspace_uarg);
    6161
    6262#endif

  • arch/mips32/src/mips32.c

    r6c6a19e6 r0f250f9  
    3838#include <memstr.h>
    3939#include <proc/thread.h>
     40#include <proc/uarg.h>
    4041#include <print.h>
    4142
    … …  
    121122__address supervisor_sp __attribute__ ((section (".text")));
    122123
    123 void userspace(uspace_arg_t *uarg)
     124void userspace(uspace_arg_t *kernel_uarg)
    124125{
    125126        /* EXL=1, UM=1, IE=1 */
    … …  
    127128                                              cp0_status_um_bit |
    128129                                              cp0_status_ie_enabled_bit));
    129         cp0_epc_write(uarg->uspace_entry);
    130         userspace_asm(uarg->uspace_stack+PAGE_SIZE);
     130        cp0_epc_write((__address) kernel_uarg->uspace_entry);
     131        userspace_asm(((__address) kernel_uarg->uspace_stack+PAGE_SIZE), (__address) kernel_uarg->uspace_uarg);
    131132        while (1)
    132133                ;

  • arch/mips32/src/start.S

    r6c6a19e6 r0f250f9  
    227227userspace_asm:
    228228        add $sp, $a0, 0
    229         eret
    230         nop
    231 
     229        add $v0, $a1, 0
     230        eret
     231        nop
     232

  • generic/include/proc/thread.h

    r6c6a19e6 r0f250f9  
    4141#include <adt/list.h>
    4242#include <mm/slab.h>
     43#include <proc/uarg.h>
    4344
    4445#define THREAD_STACK_SIZE       STACK_SIZE
    … …  
    118119};
    119120
    120 /** Structure passed to uinit kernel thread as argument. */
    121 typedef struct uspace_arg {
    122         __address uspace_entry;
    123         __address uspace_stack;
    124 } uspace_arg_t;
    125 
    126121/** Thread list lock.
    127122 *
    … …  
    150145
    151146/** Thread syscall prototypes. */
    152 __native sys_thread_create(__address function, void *arg, void *stack, char *name);
    153 __native sys_thread_exit(int status);
     147__native sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name);
     148__native sys_thread_exit(int uspace_status);
    154149
    155150#endif

  • generic/src/main/uinit.c

    r6c6a19e6 r0f250f9  
    4444        uarg.uspace_entry = ((uspace_arg_t *) arg)->uspace_entry;
    4545        uarg.uspace_stack = ((uspace_arg_t *) arg)->uspace_stack;
     46        uarg.uspace_uarg = ((uspace_arg_t *) arg)->uspace_uarg;
     47        uarg.uspace_thread_function = NULL;
     48        uarg.uspace_thread_arg = NULL;
    4649
    4750        free((uspace_arg_t *) arg);

  • generic/src/proc/task.c

    r6c6a19e6 r0f250f9  
    3030#include <proc/thread.h>
    3131#include <proc/task.h>
     32#include <proc/uarg.h>
    3233#include <mm/as.h>
    3334#include <mm/slab.h>
    34 
    3535#include <synch/spinlock.h>
    3636#include <arch.h>
    … …  
    4040#include <memstr.h>
    4141#include <print.h>
    42 
    4342#include <elf.h>
    4443
    … …  
    116115        thread_t *t;
    117116        task_t *task;
    118         uspace_arg_t *uarg;
     117        uspace_arg_t *kernel_uarg;
    119118
    120119        as = as_create(0);
    … …  
    126125        }
    127126       
    128         uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
    129         uarg->uspace_entry = (__address) ((elf_header_t *) program_addr)->e_entry;
    130         uarg->uspace_stack = USTACK_ADDRESS;
     127        kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
     128        kernel_uarg->uspace_entry = (void *) ((elf_header_t *) program_addr)->e_entry;
     129        kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
     130        kernel_uarg->uspace_thread_function = NULL;
     131        kernel_uarg->uspace_thread_arg = NULL;
     132        kernel_uarg->uspace_uarg = NULL;
    131133       
    132134        task = task_create(as, name);
    133         t = thread_create(uinit, uarg, task, 0, "uinit");
     135        t = thread_create(uinit, kernel_uarg, task, 0, "uinit");
    134136       
    135137        /*

  • generic/src/proc/thread.c

    r6c6a19e6 r0f250f9  
    3030#include <proc/thread.h>
    3131#include <proc/task.h>
     32#include <proc/uarg.h>
    3233#include <mm/frame.h>
    3334#include <mm/page.h>
    … …  
    430431 *
    431432 */
    432 __native sys_thread_create(__address function, void *arg, void *stack, char *name)
     433__native sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
    433434{
    434435        thread_t *t;
    435436        char namebuf[THREAD_NAME_BUFLEN];
    436         uspace_arg_t *uarg;
     437        uspace_arg_t *kernel_uarg;              /* TODO: store kernel_uarg in thread_t */
    437438        __u32 tid;
    438439
    439         copy_from_uspace(namebuf, name, THREAD_NAME_BUFLEN);
    440         uarg = (uspace_arg_t *) malloc(sizeof(uarg), 0);
    441        
    442         uarg->uspace_entry = function;
    443         uarg->uspace_stack = (__address) stack;
    444 
    445         if ((t = thread_create(uinit, uarg, TASK, 0, namebuf))) {
     440        copy_from_uspace(namebuf, uspace_name, THREAD_NAME_BUFLEN);
     441
     442        kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
     443        copy_from_uspace(kernel_uarg, uspace_uarg, sizeof(uspace_arg_t));
     444
     445        if ((t = thread_create(uinit, kernel_uarg, TASK, 0, namebuf))) {
    446446                tid = t->tid;
    447447                thread_ready(t);
    448448                return (__native) tid;
    449449        } else {
    450                 free(namebuf);
     450                free(kernel_uarg);
    451451        }
    452452
    … …  
    457457 *
    458458 */
    459 __native sys_thread_exit(int status)
     459__native sys_thread_exit(int uspace_status)
    460460{
    461461        thread_exit();
Note: See TracChangeset for help on using the changeset viewer.