Changes in / [216cb85:45d5f86] in mainline


Ignore:
Files:
2 deleted
8 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/arm32/Makefile.inc

    r216cb85 r45d5f86  
    6161        arch/$(KARCH)/src/mm/page.c \
    6262        arch/$(KARCH)/src/mm/tlb.c \
    63         arch/$(KARCH)/src/mm/page_fault.c \
    64         arch/$(KARCH)/src/ras.c
     63        arch/$(KARCH)/src/mm/page_fault.c
    6564
    6665ifeq ($(MACHINE),testarm)

  • kernel/arch/arm32/src/arm32.c

    r216cb85 r45d5f86  
    4848#include <macros.h>
    4949#include <string.h>
    50 #include <arch/ras.h>
    5150
    5251#ifdef MACHINE_testarm
    … …  
    8988        exception_init();
    9089        interrupt_init();
    91 
    92         /* Initialize Restartable Atomic Sequences support. */
    93         ras_init();
    9490       
    9591        machine_output_init();

  • kernel/arch/arm32/src/exc_handler.S

    r216cb85 r45d5f86  
    148148        mov r0, #0
    149149        mov r1, r13
    150         bl ras_check
     150        bl exc_dispatch
    151151        LOAD_REGS_FROM_STACK
    152152
    … …  
    156156        mov r0, #5
    157157        mov r1, r13
    158         bl ras_check
     158        bl exc_dispatch
    159159        LOAD_REGS_FROM_STACK
    160160
    … …  
    164164        mov r0, #6
    165165        mov r1, r13
    166         bl ras_check
     166        bl exc_dispatch
    167167        LOAD_REGS_FROM_STACK
    168168
    … …  
    171171        mov r0, #1
    172172        mov r1, r13
    173         bl ras_check
     173        bl exc_dispatch
    174174        LOAD_REGS_FROM_STACK
    175175
    … …  
    179179        mov r0, #3
    180180        mov r1, r13
    181         bl ras_check
     181        bl exc_dispatch
    182182        LOAD_REGS_FROM_STACK
    183183
    … …  
    187187        mov r0, #4
    188188        mov r1, r13
    189         bl ras_check
     189        bl exc_dispatch
    190190        LOAD_REGS_FROM_STACK
    191191
    … …  
    195195        mov r0, #2
    196196        mov r1, r13
    197         bl ras_check
     197        bl exc_dispatch
    198198        LOAD_REGS_FROM_STACK
    199199

  • kernel/arch/arm32/src/userspace.c

    r216cb85 r45d5f86  
    3535
    3636#include <userspace.h>
    37 #include <arch/ras.h>
    3837
    3938/** Struct for holding all general purpose registers.
    … …  
    7574        ustate.r1 = 0;
    7675
    77         /* pass the RAS page address in %r2 */
    78         ustate.r2 = (uintptr_t) ras_page;
    79 
    8076        /* clear other registers */
    81         ustate.r3  = ustate.r4  = ustate.r5 = ustate.r6 = ustate.r7 =
    82             ustate.r8 = ustate.r9 = ustate.r10 = ustate.r11 = ustate.r12 =
    83             ustate.lr = 0;
     77        ustate.r2 = ustate.r3  = ustate.r4  = ustate.r5 =
     78            ustate.r6  = ustate.r7  = ustate.r8  = ustate.r9 = ustate.r10 =
     79            ustate.r11 = ustate.r12 = ustate.lr = 0;
    8480
    8581        /* set user stack */

  • uspace/lib/libc/arch/arm32/include/atomic.h

    r216cb85 r45d5f86  
    3737#define LIBC_arm32_ATOMIC_H_
    3838
    39 #define LIBC_ARCH_ATOMIC_H_
    40 #define CAS
     39#include <bool.h>
    4140
    42 #include <atomicdflt.h>
    43 #include <bool.h>
    44 #include <sys/types.h>
     41typedef struct atomic {
     42        volatile long count;
     43} atomic_t;
    4544
    46 extern uintptr_t *ras_page;
     45static inline void atomic_set(atomic_t *val, long i)
     46{
     47        val->count = i;
     48}
     49
     50static inline long atomic_get(atomic_t *val)
     51{
     52        return val->count;
     53}
    4754
    4855static inline bool cas(atomic_t *val, long ov, long nv)
    4956{
    50         long ret = 0;
    51 
    52         /*
    53          * The following instructions between labels 1 and 2 constitute a
    54          * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
    55          * the kernel will restart it.
    56          */
    57         asm volatile (
    58                 "1:\n"
    59                 "       adr %[ret], 1b\n"
    60                 "       str %[ret], %[rp0]\n"
    61                 "       adr %[ret], 2f\n"
    62                 "       str %[ret], %[rp1]\n"
    63                 "       ldr %[ret], %[addr]\n"
    64                 "       cmp %[ret], %[ov]\n"
    65                 "       streq %[nv], %[addr]\n"
    66                 "2:\n"
    67                 "       moveq %[ret], #1\n"
    68                 "       movne %[ret], #0\n"
    69                 : [ret] "+&r" (ret),
    70                   [rp0] "=m" (ras_page[0]),
    71                   [rp1] "=m" (ras_page[1]),
    72                   [addr] "+m" (val->count)
    73                 : [ov] "r" (ov),
    74                   [nv] "r" (nv)
    75                 : "memory"
    76         );
    77 
    78         ras_page[0] = 0;
    79         asm volatile ("" ::: "memory");
    80         ras_page[1] = 0xffffffff;
    81 
    82         return (bool) ret;
     57        /* FIXME: is not atomic */
     58        if (val->count == ov) {
     59                val->count = nv;
     60                return true;
     61        }
     62        return false;
    8363}
    8464
    … …  
    9272static inline long atomic_add(atomic_t *val, int i)
    9373{
    94         long ret = 0;
     74        int ret;
     75        volatile long * mem = &(val->count);
    9576
    96         /*
    97          * The following instructions between labels 1 and 2 constitute a
    98          * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
    99          * the kernel will restart it.
    100          */
     77        /* FIXME: is not atomic, is broken */
    10178        asm volatile (
    102                 "1:\n"
    103                 "       adr %[ret], 1b\n"
    104                 "       str %[ret], %[rp0]\n"
    105                 "       adr %[ret], 2f\n"
    106                 "       str %[ret], %[rp1]\n"
    107                 "       ldr %[ret], %[addr]\n"
    108                 "       add %[ret], %[ret], %[imm]\n"
    109                 "       str %[ret], %[addr]\n"
    110                 "2:\n"
    111                 : [ret] "+&r" (ret),
    112                   [rp0] "=m" (ras_page[0]),
    113                   [rp1] "=m" (ras_page[1]),
    114                   [addr] "+m" (val->count)
    115                 : [imm] "r" (i)
     79        "1:\n"
     80                "ldr r2, [%1]\n"
     81                "add r3, r2, %2\n"
     82                "str r3, %0\n"
     83                "swp r3, r3, [%1]\n"
     84                "cmp r3, r2\n"
     85                "bne 1b\n"
     86
     87                : "=m" (ret)
     88                : "r" (mem), "r" (i)
     89                : "r3", "r2"
    11690        );
    117 
    118         ras_page[0] = 0;
    119         asm volatile ("" ::: "memory");
    120         ras_page[1] = 0xffffffff;
    12191
    12292        return ret;

  • uspace/lib/libc/arch/arm32/src/entry.s

    r216cb85 r45d5f86  
    3636#
    3737# r1 contains the PCB pointer
    38 # r2 contains the RAS page address
    3938#
    4039__entry:
    41         # Store the RAS page address into the ras_page variable
    42         ldr r0, =ras_page
    43         str r2, [r0]
    44 
    4540        # Pass pcb_ptr to __main as the first argument (in r0)
    4641        mov r0, r1
    … …  
    4843
    4944        bl __exit
    50 
    51 .data
    52 
    53 .global ras_page
    54 ras_page:
    55         .long 0
    56 

  • uspace/lib/libc/include/atomicdflt.h

    r216cb85 r45d5f86  
    5656}
    5757
    58 #ifndef CAS
    5958static inline bool cas(atomic_t *val, long ov, long nv)
    6059{
    6160        return __sync_bool_compare_and_swap(&val->count, ov, nv);
    6261}
    63 #endif
    6462
    6563#endif

  • uspace/srv/loader/arch/arm32/arm32.s

    r216cb85 r45d5f86  
    3636# Jump to a program entry point
    3737program_run:
    38         # load ras_page address to r2
    39         ldr r2, =ras_page
    40         ldr r2, [r2]
    4138        # pcb is passed to the entry point in r1 (where it already is)
    4239        mov r15, r0
Note: See TracChangeset for help on using the changeset viewer.