Fork us on GitHub Follow us on Facebook Follow us on Twitter

Ignore:
Timestamp:
2010-07-02T15:42:19Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
bbfdf62
Parents:
e3ee9b9
Message:

improve kernel function tracing

  • add support for more generic kernel sources
  • replace attribute((no_instrument_function)) with NO_TRACE macro (shorter and for future compatibility with different compilers)
  • to be on the safe side, do not instrument most of the inline and static functions (plus some specific non-static functions)

collateral code cleanup (no change in functionality)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/sparc64/include/barrier.h

    re3ee9b9 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
     
    3636#define KERN_sparc64_BARRIER_H_
    3737
     38#include <trace.h>
     39
    3840#ifdef KERNEL
     41
    3942#include <typedefs.h>
     43
    4044#else
     45
    4146#include <stdint.h>
     47
    4248#endif
    4349
     
    4551 * Our critical section barriers are prepared for the weakest RMO memory model.
    4652 */
    47 #define CS_ENTER_BARRIER()                              \
    48         asm volatile (                                  \
    49                 "membar #LoadLoad | #LoadStore\n"       \
    50                 ::: "memory"                            \
    51         )
    52 #define CS_LEAVE_BARRIER()                              \
    53         asm volatile (                                  \
    54                 "membar #StoreStore\n"                  \
    55                 "membar #LoadStore\n"                   \
    56                 ::: "memory"                            \
     53#define CS_ENTER_BARRIER() \
     54        asm volatile ( \
     55                "membar #LoadLoad | #LoadStore\n" \
     56                ::: "memory" \
    5757        )
    5858
    59 #define memory_barrier()        \
    60         asm volatile ("membar #LoadLoad | #StoreStore\n" ::: "memory")
    61 #define read_barrier()          \
    62         asm volatile ("membar #LoadLoad\n" ::: "memory")
    63 #define write_barrier()         \
    64         asm volatile ("membar #StoreStore\n" ::: "memory")
     59#define CS_LEAVE_BARRIER() \
     60        asm volatile ( \
     61                "membar #StoreStore\n" \
     62                "membar #LoadStore\n" \
     63                ::: "memory" \
     64        )
    6565
    66 #define flush(a)                \
    67         asm volatile ("flush %0\n" :: "r" ((a)) : "memory")
     66#define memory_barrier() \
     67        asm volatile ( \
     68                "membar #LoadLoad | #StoreStore\n" \
     69                ::: "memory" \
     70        )
     71
     72#define read_barrier() \
     73        asm volatile ( \
     74                "membar #LoadLoad\n" \
     75                ::: "memory" \
     76        )
     77
     78#define write_barrier() \
     79        asm volatile ( \
     80                "membar #StoreStore\n" \
     81                ::: "memory" \
     82        )
     83
     84#define flush(a) \
     85        asm volatile ( \
     86                "flush %[reg]\n" \
     87                :: [reg] "r" ((a)) \
     88                : "memory" \
     89        )
    6890
    6991/** Flush Instruction pipeline. */
    70 static inline void flush_pipeline(void)
     92NO_TRACE static inline void flush_pipeline(void)
    7193{
    7294        uint64_t pc;
    73 
     95       
    7496        /*
    7597         * The FLUSH instruction takes address parameter.
     
    80102         * the %pc register will always be in the range mapped by
    81103         * DTLB.
     104         *
    82105         */
    83          
    84         asm volatile (
    85                 "rd %%pc, %0\n"
    86                 "flush %0\n"
    87                 : "=&r" (pc)
     106       
     107        asm volatile (
     108                "rd %%pc, %[pc]\n"
     109                "flush %[pc]\n"
     110                : [pc] "=&r" (pc)
    88111        );
    89112}
    90113
    91114/** Memory Barrier instruction. */
    92 static inline void membar(void)
     115NO_TRACE static inline void membar(void)
    93116{
    94         asm volatile ("membar #Sync\n");
     117        asm volatile (
     118                "membar #Sync\n"
     119        );
    95120}
    96121
    97122#if defined (US)
    98123
    99 #define smc_coherence(a)        \
    100 {                               \
    101         write_barrier();        \
    102         flush((a));             \
    103 }
     124#define FLUSH_INVAL_MIN  4
    104125
    105 #define FLUSH_INVAL_MIN         4
    106 #define smc_coherence_block(a, l)                       \
    107 {                                                       \
    108         unsigned long i;                                \
    109         write_barrier();                                \
    110         for (i = 0; i < (l); i += FLUSH_INVAL_MIN)      \
    111                 flush((void *)(a) + i);                 \
    112 }
     126#define smc_coherence(a) \
     127        do { \
     128                write_barrier(); \
     129                flush((a)); \
     130        } while (0)
     131
     132#define smc_coherence_block(a, l) \
     133        do { \
     134                unsigned long i; \
     135                write_barrier(); \
     136                \
     137                for (i = 0; i < (l); i += FLUSH_INVAL_MIN) \
     138                        flush((void *)(a) + i); \
     139        } while (0)
    113140
    114141#elif defined (US3)
    115142
    116 #define smc_coherence(a)        \
    117 {                               \
    118         write_barrier();        \
    119         flush_pipeline();       \
    120 }
     143#define smc_coherence(a) \
     144        do { \
     145                write_barrier(); \
     146                flush_pipeline(); \
     147        } while (0)
    121148
    122 #define smc_coherence_block(a, l)       \
    123 {                                       \
    124         write_barrier();                \
    125         flush_pipeline();               \
    126 }
     149#define smc_coherence_block(a, l) \
     150        do { \
     151                write_barrier(); \
     152                flush_pipeline(); \
     153        } while (0)
    127154
    128 #endif  /* defined(US3) */
     155#endif  /* defined(US3) */
    129156
    130157#endif
Note: See TracChangeset for help on using the changeset viewer.