Changeset 7a0359b in mainline for kernel/arch/sparc64


Ignore:
Timestamp:
2010-07-02T15:42:19Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
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)

Location:
kernel/arch/sparc64/include
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/sparc64/include/asm.h

    re3ee9b9 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
    … …  
    4343#include <arch/stack.h>
    4444#include <arch/barrier.h>
    45 
    46 static inline void pio_write_8(ioport8_t *port, uint8_t v)
     45#include <trace.h>
     46
     47NO_TRACE static inline void pio_write_8(ioport8_t *port, uint8_t v)
    4748{
    4849        *port = v;
    … …  
    5051}
    5152
    52 static inline void pio_write_16(ioport16_t *port, uint16_t v)
     53NO_TRACE static inline void pio_write_16(ioport16_t *port, uint16_t v)
    5354{
    5455        *port = v;
    … …  
    5657}
    5758
    58 static inline void pio_write_32(ioport32_t *port, uint32_t v)
     59NO_TRACE static inline void pio_write_32(ioport32_t *port, uint32_t v)
    5960{
    6061        *port = v;
    … …  
    6263}
    6364
    64 static inline uint8_t pio_read_8(ioport8_t *port)
    65 {
    66         uint8_t rv;
    67 
    68         rv = *port;
     65NO_TRACE static inline uint8_t pio_read_8(ioport8_t *port)
     66{
     67        uint8_t rv = *port;
    6968        memory_barrier();
    70 
    7169        return rv;
    7270}
    7371
    74 static inline uint16_t pio_read_16(ioport16_t *port)
    75 {
    76         uint16_t rv;
    77 
    78         rv = *port;
     72NO_TRACE static inline uint16_t pio_read_16(ioport16_t *port)
     73{
     74        uint16_t rv = *port;
    7975        memory_barrier();
    80 
    8176        return rv;
    8277}
    8378
    84 static inline uint32_t pio_read_32(ioport32_t *port)
    85 {
    86         uint32_t rv;
    87 
    88         rv = *port;
     79NO_TRACE static inline uint32_t pio_read_32(ioport32_t *port)
     80{
     81        uint32_t rv = *port;
    8982        memory_barrier();
    90 
    9183        return rv;
    9284}
    … …  
    9587 *
    9688 * @return Value of PSTATE register.
    97  */
    98 static inline uint64_t pstate_read(void)
    99 {
    100         uint64_t v;
    101        
    102         asm volatile ("rdpr %%pstate, %0\n" : "=r" (v));
     89 *
     90 */
     91NO_TRACE static inline uint64_t pstate_read(void)
     92{
     93        uint64_t v;
     94       
     95        asm volatile (
     96                "rdpr %%pstate, %[v]\n"
     97                : [v] "=r" (v)
     98        );
    10399       
    104100        return v;
    … …  
    108104 *
    109105 * @param v New value of PSTATE register.
    110  */
    111 static inline void pstate_write(uint64_t v)
    112 {
    113         asm volatile ("wrpr %0, %1, %%pstate\n" : : "r" (v), "i" (0));
     106 *
     107 */
     108NO_TRACE static inline void pstate_write(uint64_t v)
     109{
     110        asm volatile (
     111                "wrpr %[v], %[zero], %%pstate\n"
     112                :: [v] "r" (v),
     113                   [zero] "i" (0)
     114        );
    114115}
    115116
    … …  
    117118 *
    118119 * @return Value of TICK_comapre register.
    119  */
    120 static inline uint64_t tick_compare_read(void)
    121 {
    122         uint64_t v;
    123        
    124         asm volatile ("rd %%tick_cmpr, %0\n" : "=r" (v));
     120 *
     121 */
     122NO_TRACE static inline uint64_t tick_compare_read(void)
     123{
     124        uint64_t v;
     125       
     126        asm volatile (
     127                "rd %%tick_cmpr, %[v]\n"
     128                : [v] "=r" (v)
     129        );
    125130       
    126131        return v;
    … …  
    130135 *
    131136 * @param v New value of TICK_comapre register.
    132  */
    133 static inline void tick_compare_write(uint64_t v)
    134 {
    135         asm volatile ("wr %0, %1, %%tick_cmpr\n" : : "r" (v), "i" (0));
     137 *
     138 */
     139NO_TRACE static inline void tick_compare_write(uint64_t v)
     140{
     141        asm volatile (
     142                "wr %[v], %[zero], %%tick_cmpr\n"
     143                :: [v] "r" (v),
     144                   [zero] "i" (0)
     145        );
    136146}
    137147
    … …  
    139149 *
    140150 * @return Value of STICK_compare register.
    141  */
    142 static inline uint64_t stick_compare_read(void)
    143 {
    144         uint64_t v;
    145        
    146         asm volatile ("rd %%asr25, %0\n" : "=r" (v));
     151 *
     152 */
     153NO_TRACE static inline uint64_t stick_compare_read(void)
     154{
     155        uint64_t v;
     156       
     157        asm volatile (
     158                "rd %%asr25, %[v]\n"
     159                : [v] "=r" (v)
     160        );
    147161       
    148162        return v;
    … …  
    152166 *
    153167 * @param v New value of STICK_comapre register.
    154  */
    155 static inline void stick_compare_write(uint64_t v)
    156 {
    157         asm volatile ("wr %0, %1, %%asr25\n" : : "r" (v), "i" (0));
     168 *
     169 */
     170NO_TRACE static inline void stick_compare_write(uint64_t v)
     171{
     172        asm volatile (
     173                "wr %[v], %[zero], %%asr25\n"
     174                :: [v] "r" (v),
     175                   [zero] "i" (0)
     176        );
    158177}
    159178
    … …  
    161180 *
    162181 * @return Value of TICK register.
    163  */
    164 static inline uint64_t tick_read(void)
    165 {
    166         uint64_t v;
    167        
    168         asm volatile ("rdpr %%tick, %0\n" : "=r" (v));
     182 *
     183 */
     184NO_TRACE static inline uint64_t tick_read(void)
     185{
     186        uint64_t v;
     187       
     188        asm volatile (
     189                "rdpr %%tick, %[v]\n"
     190                : [v] "=r" (v)
     191        );
    169192       
    170193        return v;
    … …  
    174197 *
    175198 * @param v New value of TICK register.
    176  */
    177 static inline void tick_write(uint64_t v)
    178 {
    179         asm volatile ("wrpr %0, %1, %%tick\n" : : "r" (v), "i" (0));
     199 *
     200 */
     201NO_TRACE static inline void tick_write(uint64_t v)
     202{
     203        asm volatile (
     204                "wrpr %[v], %[zero], %%tick\n"
     205                :: [v] "r" (v),
     206                   [zero] "i" (0)
     207        );
    180208}
    181209
    … …  
    183211 *
    184212 * @return Value of FPRS register.
    185  */
    186 static inline uint64_t fprs_read(void)
    187 {
    188         uint64_t v;
    189        
    190         asm volatile ("rd %%fprs, %0\n" : "=r" (v));
     213 *
     214 */
     215NO_TRACE static inline uint64_t fprs_read(void)
     216{
     217        uint64_t v;
     218       
     219        asm volatile (
     220                "rd %%fprs, %[v]\n"
     221                : [v] "=r" (v)
     222        );
    191223       
    192224        return v;
    … …  
    196228 *
    197229 * @param v New value of FPRS register.
    198  */
    199 static inline void fprs_write(uint64_t v)
    200 {
    201         asm volatile ("wr %0, %1, %%fprs\n" : : "r" (v), "i" (0));
     230 *
     231 */
     232NO_TRACE static inline void fprs_write(uint64_t v)
     233{
     234        asm volatile (
     235                "wr %[v], %[zero], %%fprs\n"
     236                :: [v] "r" (v),
     237                   [zero] "i" (0)
     238        );
    202239}
    203240
    … …  
    205242 *
    206243 * @return Value of SOFTINT register.
    207  */
    208 static inline uint64_t softint_read(void)
    209 {
    210         uint64_t v;
    211 
    212         asm volatile ("rd %%softint, %0\n" : "=r" (v));
    213 
     244 *
     245 */
     246NO_TRACE static inline uint64_t softint_read(void)
     247{
     248        uint64_t v;
     249       
     250        asm volatile (
     251                "rd %%softint, %[v]\n"
     252                : [v] "=r" (v)
     253        );
     254       
    214255        return v;
    215256}
    … …  
    218259 *
    219260 * @param v New value of SOFTINT register.
    220  */
    221 static inline void softint_write(uint64_t v)
    222 {
    223         asm volatile ("wr %0, %1, %%softint\n" : : "r" (v), "i" (0));
     261 *
     262 */
     263NO_TRACE static inline void softint_write(uint64_t v)
     264{
     265        asm volatile (
     266                "wr %[v], %[zero], %%softint\n"
     267                :: [v] "r" (v),
     268                   [zero] "i" (0)
     269        );
    224270}
    225271
    … …  
    229275 *
    230276 * @param v New value of CLEAR_SOFTINT register.
    231  */
    232 static inline void clear_softint_write(uint64_t v)
    233 {
    234         asm volatile ("wr %0, %1, %%clear_softint\n" : : "r" (v), "i" (0));
     277 *
     278 */
     279NO_TRACE static inline void clear_softint_write(uint64_t v)
     280{
     281        asm volatile (
     282                "wr %[v], %[zero], %%clear_softint\n"
     283                :: [v] "r" (v),
     284                   [zero] "i" (0)
     285        );
    235286}
    236287
    … …  
    240291 *
    241292 * @param v New value of SET_SOFTINT register.
    242  */
    243 static inline void set_softint_write(uint64_t v)
    244 {
    245         asm volatile ("wr %0, %1, %%set_softint\n" : : "r" (v), "i" (0));
     293 *
     294 */
     295NO_TRACE static inline void set_softint_write(uint64_t v)
     296{
     297        asm volatile (
     298                "wr %[v], %[zero], %%set_softint\n"
     299                :: [v] "r" (v),
     300                   [zero] "i" (0)
     301        );
    246302}
    247303
    … …  
    252308 *
    253309 * @return Old interrupt priority level.
    254  */
    255 static inline ipl_t interrupts_enable(void) {
     310 *
     311 */
     312NO_TRACE static inline ipl_t interrupts_enable(void) {
    256313        pstate_reg_t pstate;
    257         uint64_t value;
    258        
    259         value = pstate_read();
     314        uint64_t value = pstate_read();
     315       
    260316        pstate.value = value;
    261317        pstate.ie = true;
    … …  
    271327 *
    272328 * @return Old interrupt priority level.
    273  */
    274 static inline ipl_t interrupts_disable(void) {
     329 *
     330 */
     331NO_TRACE static inline ipl_t interrupts_disable(void) {
    275332        pstate_reg_t pstate;
    276         uint64_t value;
    277        
    278         value = pstate_read();
     333        uint64_t value = pstate_read();
     334       
    279335        pstate.value = value;
    280336        pstate.ie = false;
    … …  
    289345 *
    290346 * @param ipl Saved interrupt priority level.
    291  */
    292 static inline void interrupts_restore(ipl_t ipl) {
     347 *
     348 */
     349NO_TRACE static inline void interrupts_restore(ipl_t ipl) {
    293350        pstate_reg_t pstate;
    294351       
    … …  
    303360 *
    304361 * @return Current interrupt priority level.
    305  */
    306 static inline ipl_t interrupts_read(void) {
     362 *
     363 */
     364NO_TRACE static inline ipl_t interrupts_read(void) {
    307365        return (ipl_t) pstate_read();
    308366}
    … …  
    313371 *
    314372 */
    315 static inline bool interrupts_disabled(void)
     373NO_TRACE static inline bool interrupts_disabled(void)
    316374{
    317375        pstate_reg_t pstate;
    318 
     376       
    319377        pstate.value = pstate_read();
    320378        return !pstate.ie;
    … …  
    326384 * The stack is assumed to be STACK_SIZE bytes long.
    327385 * The stack must start on page boundary.
    328  */
    329 static inline uintptr_t get_stack_base(void)
     386 *
     387 */
     388NO_TRACE static inline uintptr_t get_stack_base(void)
    330389{
    331390        uintptr_t unbiased_sp;
    332391       
    333         asm volatile ("add %%sp, %1, %0\n" : "=r" (unbiased_sp) : "i" (STACK_BIAS));
     392        asm volatile (
     393                "add %%sp, %[stack_bias], %[unbiased_sp]\n"
     394                : [unbiased_sp] "=r" (unbiased_sp)
     395                : [stack_bias] "i" (STACK_BIAS)
     396        );
    334397       
    335398        return ALIGN_DOWN(unbiased_sp, STACK_SIZE);
    … …  
    339402 *
    340403 * @return Value of VER register.
    341  */
    342 static inline uint64_t ver_read(void)
    343 {
    344         uint64_t v;
    345        
    346         asm volatile ("rdpr %%ver, %0\n" : "=r" (v));
     404 *
     405 */
     406NO_TRACE static inline uint64_t ver_read(void)
     407{
     408        uint64_t v;
     409       
     410        asm volatile (
     411                "rdpr %%ver, %[v]\n"
     412                : [v] "=r" (v)
     413        );
    347414       
    348415        return v;
    … …  
    352419 *
    353420 * @return Current value in TPC.
    354  */
    355 static inline uint64_t tpc_read(void)
    356 {
    357         uint64_t v;
    358        
    359         asm volatile ("rdpr %%tpc, %0\n" : "=r" (v));
     421 *
     422 */
     423NO_TRACE static inline uint64_t tpc_read(void)
     424{
     425        uint64_t v;
     426       
     427        asm volatile (
     428                "rdpr %%tpc, %[v]\n"
     429                : [v] "=r" (v)
     430        );
    360431       
    361432        return v;
    … …  
    365436 *
    366437 * @return Current value in TL.
    367  */
    368 static inline uint64_t tl_read(void)
    369 {
    370         uint64_t v;
    371        
    372         asm volatile ("rdpr %%tl, %0\n" : "=r" (v));
     438 *
     439 */
     440NO_TRACE static inline uint64_t tl_read(void)
     441{
     442        uint64_t v;
     443       
     444        asm volatile (
     445                "rdpr %%tl, %[v]\n"
     446                : [v] "=r" (v)
     447        );
    373448       
    374449        return v;
    … …  
    378453 *
    379454 * @return Current value in TBA.
    380  */
    381 static inline uint64_t tba_read(void)
    382 {
    383         uint64_t v;
    384        
    385         asm volatile ("rdpr %%tba, %0\n" : "=r" (v));
     455 *
     456 */
     457NO_TRACE static inline uint64_t tba_read(void)
     458{
     459        uint64_t v;
     460       
     461        asm volatile (
     462                "rdpr %%tba, %[v]\n"
     463                : [v] "=r" (v)
     464        );
    386465       
    387466        return v;
    … …  
    391470 *
    392471 * @param v New value of TBA.
    393  */
    394 static inline void tba_write(uint64_t v)
    395 {
    396         asm volatile ("wrpr %0, %1, %%tba\n" : : "r" (v), "i" (0));
     472 *
     473 */
     474NO_TRACE static inline void tba_write(uint64_t v)
     475{
     476        asm volatile (
     477                "wrpr %[v], %[zero], %%tba\n"
     478                :: [v] "r" (v),
     479                   [zero] "i" (0)
     480        );
    397481}
    398482
    … …  
    400484 *
    401485 * @param asi ASI determining the alternate space.
    402  * @param va Virtual address within the ASI.
    403  *
    404  * @return Value read from the virtual address in the specified address space.
    405  */
    406 static inline uint64_t asi_u64_read(asi_t asi, uintptr_t va)
    407 {
    408         uint64_t v;
    409        
    410         asm volatile ("ldxa [%1] %2, %0\n" : "=r" (v) : "r" (va), "i" ((unsigned) asi));
     486 * @param va  Virtual address within the ASI.
     487 *
     488 * @return Value read from the virtual address in
     489 *         the specified address space.
     490 *
     491 */
     492NO_TRACE static inline uint64_t asi_u64_read(asi_t asi, uintptr_t va)
     493{
     494        uint64_t v;
     495       
     496        asm volatile (
     497                "ldxa [%[va]] %[asi], %[v]\n"
     498                : [v] "=r" (v)
     499                : [va] "r" (va),
     500                  [asi] "i" ((unsigned int) asi)
     501        );
    411502       
    412503        return v;
    … …  
    416507 *
    417508 * @param asi ASI determining the alternate space.
    418  * @param va Virtual address within the ASI.
    419  * @param v Value to be written.
    420  */
    421 static inline void asi_u64_write(asi_t asi, uintptr_t va, uint64_t v)
    422 {
    423         asm volatile ("stxa %0, [%1] %2\n" : :  "r" (v), "r" (va), "i" ((unsigned) asi) : "memory");
     509 * @param va  Virtual address within the ASI.
     510 * @param v   Value to be written.
     511 *
     512 */
     513NO_TRACE static inline void asi_u64_write(asi_t asi, uintptr_t va, uint64_t v)
     514{
     515        asm volatile (
     516                "stxa %[v], [%[va]] %[asi]\n"
     517                :: [v] "r" (v),
     518                   [va] "r" (va),
     519                   [asi] "i" ((unsigned int) asi)
     520                : "memory"
     521        );
    424522}
    425523
    426524/** Flush all valid register windows to memory. */
    427 static inline void flushw(void)
     525NO_TRACE static inline void flushw(void)
    428526{
    429527        asm volatile ("flushw\n");
    … …  
    431529
    432530/** Switch to nucleus by setting TL to 1. */
    433 static inline void nucleus_enter(void)
     531NO_TRACE static inline void nucleus_enter(void)
    434532{
    435533        asm volatile ("wrpr %g0, 1, %tl\n");
    … …  
    437535
    438536/** Switch from nucleus by setting TL to 0. */
    439 static inline void nucleus_leave(void)
     537NO_TRACE static inline void nucleus_leave(void)
    440538{
    441539        asm volatile ("wrpr %g0, %g0, %tl\n");

  • kernel/arch/sparc64/include/atomic.h

    re3ee9b9 r7a0359b  
    3939#include <typedefs.h>
    4040#include <preemption.h>
     41#include <trace.h>
    4142
    4243/** Atomic add operation.
    … …  
    5051 *
    5152 */
    52 static inline atomic_count_t atomic_add(atomic_t *val, atomic_count_t i)
     53NO_TRACE static inline atomic_count_t atomic_add(atomic_t *val,
     54    atomic_count_t i)
    5355{
    5456        atomic_count_t a;
    … …  
    7274}
    7375
    74 static inline atomic_count_t atomic_preinc(atomic_t *val)
     76NO_TRACE static inline atomic_count_t atomic_preinc(atomic_t *val)
    7577{
    7678        return atomic_add(val, 1) + 1;
    7779}
    7880
    79 static inline atomic_count_t atomic_postinc(atomic_t *val)
     81NO_TRACE static inline atomic_count_t atomic_postinc(atomic_t *val)
    8082{
    8183        return atomic_add(val, 1);
    8284}
    8385
    84 static inline atomic_count_t atomic_predec(atomic_t *val)
     86NO_TRACE static inline atomic_count_t atomic_predec(atomic_t *val)
    8587{
    8688        return atomic_add(val, -1) - 1;
    8789}
    8890
    89 static inline atomic_count_t atomic_postdec(atomic_t *val)
     91NO_TRACE static inline atomic_count_t atomic_postdec(atomic_t *val)
    9092{
    9193        return atomic_add(val, -1);
    9294}
    9395
    94 static inline void atomic_inc(atomic_t *val)
     96NO_TRACE static inline void atomic_inc(atomic_t *val)
    9597{
    9698        (void) atomic_add(val, 1);
    9799}
    98100
    99 static inline void atomic_dec(atomic_t *val)
     101NO_TRACE static inline void atomic_dec(atomic_t *val)
    100102{
    101103        (void) atomic_add(val, -1);
    102104}
    103105
    104 static inline atomic_count_t test_and_set(atomic_t *val)
     106NO_TRACE static inline atomic_count_t test_and_set(atomic_t *val)
    105107{
    106108        atomic_count_t v = 1;
    … …  
    117119}
    118120
    119 static inline void atomic_lock_arch(atomic_t *val)
     121NO_TRACE static inline void atomic_lock_arch(atomic_t *val)
    120122{
    121123        atomic_count_t tmp1 = 1;

  • 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

  • kernel/arch/sparc64/include/cycle.h

    re3ee9b9 r7a0359b  
    3636#define KERN_sparc64_CYCLE_H_
    3737
    38 #include <arch/asm.h>
     38#include <arch/asm.h>
     39#include <trace.h>
    3940
    40 static inline uint64_t get_cycle(void)
     41NO_TRACE static inline uint64_t get_cycle(void)
    4142{
    4243        return tick_read();

  • kernel/arch/sparc64/include/faddr.h

    re3ee9b9 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
    … …  
    3838#include <typedefs.h>
    3939
    40 #define FADDR(fptr)             ((uintptr_t) (fptr))
     40#define FADDR(fptr)  ((uintptr_t) (fptr))
    4141
    4242#endif

  • kernel/arch/sparc64/include/interrupt.h

    re3ee9b9 r7a0359b  
    3939#include <typedefs.h>
    4040#include <arch/regdef.h>
     41#include <trace.h>
    4142
    42 #define IVT_ITEMS       15
    43 #define IVT_FIRST       1
     43#define IVT_ITEMS  15
     44#define IVT_FIRST  1
    4445
    4546/* This needs to be defined for inter-architecture API portability. */
    46 #define VECTOR_TLB_SHOOTDOWN_IPI        0
     47#define VECTOR_TLB_SHOOTDOWN_IPI  0
    4748
    4849enum {
    4950        IPI_TLB_SHOOTDOWN = VECTOR_TLB_SHOOTDOWN_IPI
    50 };             
     51};
    5152
    5253typedef struct istate {
    53         uint64_t        tnpc;
    54         uint64_t        tpc;
    55         uint64_t        tstate;
     54        uint64_t tnpc;
     55        uint64_t tpc;
     56        uint64_t tstate;
    5657} istate_t;
    5758
    58 static inline void istate_set_retaddr(istate_t *istate, uintptr_t retaddr)
     59NO_TRACE static inline void istate_set_retaddr(istate_t *istate,
     60    uintptr_t retaddr)
    5961{
    6062        istate->tpc = retaddr;
    6163}
    6264
    63 static inline int istate_from_uspace(istate_t *istate)
     65NO_TRACE static inline int istate_from_uspace(istate_t *istate)
    6466{
    6567        return !(istate->tstate & TSTATE_PRIV_BIT);
    6668}
    6769
    68 static inline unative_t istate_get_pc(istate_t *istate)
     70NO_TRACE static inline unative_t istate_get_pc(istate_t *istate)
    6971{
    7072        return istate->tpc;
    7173}
    7274
    73 static inline unative_t istate_get_fp(istate_t *istate)
     75NO_TRACE static inline unative_t istate_get_fp(istate_t *istate)
    7476{
    75         return 0;       /* TODO */
     77        /* TODO */
     78       
     79        return 0;
    7680}
    7781

  • kernel/arch/sparc64/include/mm/as.h

    re3ee9b9 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64mm       
     29/** @addtogroup sparc64mm
    3030 * @{
    3131 */
    … …  
    3737
    3838#if defined (SUN4U)
     39
    3940#include <arch/mm/sun4u/as.h>
     41
    4042#elif defined (SUN4V)
     43
    4144#include <arch/mm/sun4v/as.h>
     45
    4246#endif
    4347

  • kernel/arch/sparc64/include/mm/frame.h

    re3ee9b9 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64mm       
     29/** @addtogroup sparc64mm
    3030 * @{
    3131 */
    … …  
    3737
    3838#if defined (SUN4U)
     39
    3940#include <arch/mm/sun4u/frame.h>
     41
    4042#elif defined (SUN4V)
     43
    4144#include <arch/mm/sun4v/frame.h>
     45
    4246#endif
    4347

  • kernel/arch/sparc64/include/mm/sun4u/tlb.h

    re3ee9b9 r7a0359b  
    100100#include <arch/barrier.h>
    101101#include <typedefs.h>
     102#include <trace.h>
    102103#include <arch/register.h>
    103104#include <arch/cpu.h>
    … …  
    242243 * Determine the number of entries in the DMMU's small TLB.
    243244 */
    244 static inline uint16_t tlb_dsmall_size(void)
     245NO_TRACE static inline uint16_t tlb_dsmall_size(void)
    245246{
    246247        return 16;
    … …  
    250251 * Determine the number of entries in each DMMU's big TLB.
    251252 */
    252 static inline uint16_t tlb_dbig_size(void)
     253NO_TRACE static inline uint16_t tlb_dbig_size(void)
    253254{
    254255        return 512;
    … …  
    258259 * Determine the number of entries in the IMMU's small TLB.
    259260 */
    260 static inline uint16_t tlb_ismall_size(void)
     261NO_TRACE static inline uint16_t tlb_ismall_size(void)
    261262{
    262263        return 16;
    … …  
    266267 * Determine the number of entries in the IMMU's big TLB.
    267268 */
    268 static inline uint16_t tlb_ibig_size(void)
     269NO_TRACE static inline uint16_t tlb_ibig_size(void)
    269270{
    270271        if (((ver_reg_t) ver_read()).impl == IMPL_ULTRASPARCIV_PLUS)
    … …  
    280281 * @return              Current value of Primary Context Register.
    281282 */
    282 static inline uint64_t mmu_primary_context_read(void)
     283NO_TRACE static inline uint64_t mmu_primary_context_read(void)
    283284{
    284285        return asi_u64_read(ASI_DMMU, VA_PRIMARY_CONTEXT_REG);
    … …  
    289290 * @param v             New value of Primary Context Register.
    290291 */
    291 static inline void mmu_primary_context_write(uint64_t v)
     292NO_TRACE static inline void mmu_primary_context_write(uint64_t v)
    292293{
    293294        asi_u64_write(ASI_DMMU, VA_PRIMARY_CONTEXT_REG, v);
    … …  
    299300 * @return              Current value of Secondary Context Register.
    300301 */
    301 static inline uint64_t mmu_secondary_context_read(void)
     302NO_TRACE static inline uint64_t mmu_secondary_context_read(void)
    302303{
    303304        return asi_u64_read(ASI_DMMU, VA_SECONDARY_CONTEXT_REG);
    … …  
    308309 * @param v             New value of Primary Context Register.
    309310 */
    310 static inline void mmu_secondary_context_write(uint64_t v)
     311NO_TRACE static inline void mmu_secondary_context_write(uint64_t v)
    311312{
    312313        asi_u64_write(ASI_DMMU, VA_SECONDARY_CONTEXT_REG, v);
    … …  
    323324 *                      Register.
    324325 */
    325 static inline uint64_t itlb_data_access_read(size_t entry)
     326NO_TRACE static inline uint64_t itlb_data_access_read(size_t entry)
    326327{
    327328        itlb_data_access_addr_t reg;
    … …  
    337338 * @param value         Value to be written.
    338339 */
    339 static inline void itlb_data_access_write(size_t entry, uint64_t value)
     340NO_TRACE static inline void itlb_data_access_write(size_t entry, uint64_t value)
    340341{
    341342        itlb_data_access_addr_t reg;
    … …  
    354355 *                      Register.
    355356 */
    356 static inline uint64_t dtlb_data_access_read(size_t entry)
     357NO_TRACE static inline uint64_t dtlb_data_access_read(size_t entry)
    357358{
    358359        dtlb_data_access_addr_t reg;
    … …  
    368369 * @param value         Value to be written.
    369370 */
    370 static inline void dtlb_data_access_write(size_t entry, uint64_t value)
     371NO_TRACE static inline void dtlb_data_access_write(size_t entry, uint64_t value)
    371372{
    372373        dtlb_data_access_addr_t reg;
    … …  
    384385 * @return              Current value of specified IMMU TLB Tag Read Register.
    385386 */
    386 static inline uint64_t itlb_tag_read_read(size_t entry)
     387NO_TRACE static inline uint64_t itlb_tag_read_read(size_t entry)
    387388{
    388389        itlb_tag_read_addr_t tag;
    … …  
    399400 * @return              Current value of specified DMMU TLB Tag Read Register.
    400401 */
    401 static inline uint64_t dtlb_tag_read_read(size_t entry)
     402NO_TRACE static inline uint64_t dtlb_tag_read_read(size_t entry)
    402403{
    403404        dtlb_tag_read_addr_t tag;
    … …  
    419420 *                      Register.
    420421 */
    421 static inline uint64_t itlb_data_access_read(int tlb, size_t entry)
     422NO_TRACE static inline uint64_t itlb_data_access_read(int tlb, size_t entry)
    422423{
    423424        itlb_data_access_addr_t reg;
    … …  
    434435 * @param value         Value to be written.
    435436 */
    436 static inline void itlb_data_access_write(int tlb, size_t entry,
     437NO_TRACE static inline void itlb_data_access_write(int tlb, size_t entry,
    437438        uint64_t value)
    438439{
    … …  
    454455 *                      Register.
    455456 */
    456 static inline uint64_t dtlb_data_access_read(int tlb, size_t entry)
     457NO_TRACE static inline uint64_t dtlb_data_access_read(int tlb, size_t entry)
    457458{
    458459        dtlb_data_access_addr_t reg;
    … …  
    470471 * @param value         Value to be written.
    471472 */
    472 static inline void dtlb_data_access_write(int tlb, size_t entry,
     473NO_TRACE static inline void dtlb_data_access_write(int tlb, size_t entry,
    473474        uint64_t value)
    474475{
    … …  
    489490 * @return              Current value of specified IMMU TLB Tag Read Register.
    490491 */
    491 static inline uint64_t itlb_tag_read_read(int tlb, size_t entry)
     492NO_TRACE static inline uint64_t itlb_tag_read_read(int tlb, size_t entry)
    492493{
    493494        itlb_tag_read_addr_t tag;
    … …  
    506507 * @return              Current value of specified DMMU TLB Tag Read Register.
    507508 */
    508 static inline uint64_t dtlb_tag_read_read(int tlb, size_t entry)
     509NO_TRACE static inline uint64_t dtlb_tag_read_read(int tlb, size_t entry)
    509510{
    510511        dtlb_tag_read_addr_t tag;
    … …  
    523524 * @param v             Value to be written.
    524525 */
    525 static inline void itlb_tag_access_write(uint64_t v)
     526NO_TRACE static inline void itlb_tag_access_write(uint64_t v)
    526527{
    527528        asi_u64_write(ASI_IMMU, VA_IMMU_TAG_ACCESS, v);
    … …  
    533534 * @return              Current value of IMMU TLB Tag Access Register.
    534535 */
    535 static inline uint64_t itlb_tag_access_read(void)
     536NO_TRACE static inline uint64_t itlb_tag_access_read(void)
    536537{
    537538        return asi_u64_read(ASI_IMMU, VA_IMMU_TAG_ACCESS);
    … …  
    542543 * @param v             Value to be written.
    543544 */
    544 static inline void dtlb_tag_access_write(uint64_t v)
     545NO_TRACE static inline void dtlb_tag_access_write(uint64_t v)
    545546{
    546547        asi_u64_write(ASI_DMMU, VA_DMMU_TAG_ACCESS, v);
    … …  
    552553 * @return              Current value of DMMU TLB Tag Access Register.
    553554 */
    554 static inline uint64_t dtlb_tag_access_read(void)
     555NO_TRACE static inline uint64_t dtlb_tag_access_read(void)
    555556{
    556557        return asi_u64_read(ASI_DMMU, VA_DMMU_TAG_ACCESS);
    … …  
    562563 * @param v             Value to be written.
    563564 */
    564 static inline void itlb_data_in_write(uint64_t v)
     565NO_TRACE static inline void itlb_data_in_write(uint64_t v)
    565566{
    566567        asi_u64_write(ASI_ITLB_DATA_IN_REG, 0, v);
    … …  
    572573 * @param v             Value to be written.
    573574 */
    574 static inline void dtlb_data_in_write(uint64_t v)
     575NO_TRACE static inline void dtlb_data_in_write(uint64_t v)
    575576{
    576577        asi_u64_write(ASI_DTLB_DATA_IN_REG, 0, v);
    … …  
    582583 * @return              Current content of I-SFSR register.
    583584 */
    584 static inline uint64_t itlb_sfsr_read(void)
     585NO_TRACE static inline uint64_t itlb_sfsr_read(void)
    585586{
    586587        return asi_u64_read(ASI_IMMU, VA_IMMU_SFSR);
    … …  
    591592 * @param v             New value of I-SFSR register.
    592593 */
    593 static inline void itlb_sfsr_write(uint64_t v)
     594NO_TRACE static inline void itlb_sfsr_write(uint64_t v)
    594595{
    595596        asi_u64_write(ASI_IMMU, VA_IMMU_SFSR, v);
    … …  
    601602 * @return              Current content of D-SFSR register.
    602603 */
    603 static inline uint64_t dtlb_sfsr_read(void)
     604NO_TRACE static inline uint64_t dtlb_sfsr_read(void)
    604605{
    605606        return asi_u64_read(ASI_DMMU, VA_DMMU_SFSR);
    … …  
    610611 * @param v             New value of D-SFSR register.
    611612 */
    612 static inline void dtlb_sfsr_write(uint64_t v)
     613NO_TRACE static inline void dtlb_sfsr_write(uint64_t v)
    613614{
    614615        asi_u64_write(ASI_DMMU, VA_DMMU_SFSR, v);
    … …  
    620621 * @return              Current content of D-SFAR register.
    621622 */
    622 static inline uint64_t dtlb_sfar_read(void)
     623NO_TRACE static inline uint64_t dtlb_sfar_read(void)
    623624{
    624625        return asi_u64_read(ASI_DMMU, VA_DMMU_SFAR);
    … …  
    633634 * @param page          Address which is on the page to be demapped.
    634635 */
    635 static inline void itlb_demap(int type, int context_encoding, uintptr_t page)
     636NO_TRACE static inline void itlb_demap(int type, int context_encoding, uintptr_t page)
    636637{
    637638        tlb_demap_addr_t da;
    … …  
    659660 * @param page          Address which is on the page to be demapped.
    660661 */
    661 static inline void dtlb_demap(int type, int context_encoding, uintptr_t page)
     662NO_TRACE static inline void dtlb_demap(int type, int context_encoding, uintptr_t page)
    662663{
    663664        tlb_demap_addr_t da;

  • kernel/arch/sparc64/include/mm/sun4v/tlb.h

    re3ee9b9 r7a0359b  
    4343
    4444#include <arch/mm/tte.h>
    45 #include <print.h>
     45#include <trace.h>
    4646#include <arch/mm/mmu.h>
    4747#include <arch/mm/page.h>
    … …  
    8888 * @return      Current value of Primary Context Register.
    8989 */
    90 static inline uint64_t mmu_primary_context_read(void)
     90NO_TRACE static inline uint64_t mmu_primary_context_read(void)
    9191{
    9292        return asi_u64_read(ASI_PRIMARY_CONTEXT_REG, VA_PRIMARY_CONTEXT_REG);
    9393}
    94  
     94
    9595/** Write MMU Primary Context Register.
    9696 *
    9797 * @param v     New value of Primary Context Register.
    9898 */
    99 static inline void mmu_primary_context_write(uint64_t v)
     99NO_TRACE static inline void mmu_primary_context_write(uint64_t v)
    100100{
    101101        asi_u64_write(ASI_PRIMARY_CONTEXT_REG, VA_PRIMARY_CONTEXT_REG, v);
    102102}
    103  
     103
    104104/** Read MMU Secondary Context Register.
    105105 *
    106106 * @return      Current value of Secondary Context Register.
    107107 */
    108 static inline uint64_t mmu_secondary_context_read(void)
     108NO_TRACE static inline uint64_t mmu_secondary_context_read(void)
    109109{
    110110        return asi_u64_read(ASI_SECONDARY_CONTEXT_REG, VA_SECONDARY_CONTEXT_REG);
    111111}
    112  
     112
    113113/** Write MMU Secondary Context Register.
    114114 *
    115115 * @param v     New value of Secondary Context Register.
    116116 */
    117 static inline void mmu_secondary_context_write(uint64_t v)
     117NO_TRACE static inline void mmu_secondary_context_write(uint64_t v)
    118118{
    119119        asi_u64_write(ASI_SECONDARY_CONTEXT_REG, VA_SECONDARY_CONTEXT_REG, v);
    … …  
    126126 * @param mmu_flag      MMU_FLAG_DTLB, MMU_FLAG_ITLB or a combination of both
    127127 */
    128 static inline void mmu_demap_ctx(int context, int mmu_flag) {
     128NO_TRACE static inline void mmu_demap_ctx(int context, int mmu_flag) {
    129129        __hypercall_fast4(MMU_DEMAP_CTX, 0, 0, context, mmu_flag);
    130130}
    … …  
    137137 * @param mmu_flag      MMU_FLAG_DTLB, MMU_FLAG_ITLB or a combination of both
    138138 */
    139 static inline void mmu_demap_page(uintptr_t vaddr, int context, int mmu_flag) {
     139NO_TRACE static inline void mmu_demap_page(uintptr_t vaddr, int context, int mmu_flag) {
    140140        __hypercall_fast5(MMU_DEMAP_PAGE, 0, 0, vaddr, context, mmu_flag);
    141141}

  • kernel/arch/sparc64/include/mm/tlb.h

    re3ee9b9 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64mm       
     29/** @addtogroup sparc64mm
    3030 * @{
    3131 */
    … …  
    3636#define KERN_sparc64_TLB_H_
    3737
     38#if defined (SUN4U)
    3839
    39 #if defined (SUN4U)
    4040#include <arch/mm/sun4u/tlb.h>
     41
    4142#elif defined (SUN4V)
     43
    4244#include <arch/mm/sun4v/tlb.h>
     45
    4346#endif
    4447

  • kernel/arch/sparc64/include/sun4u/asm.h

    re3ee9b9 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
    … …  
    3636#define KERN_sparc64_sun4u_ASM_H_
    3737
    38 extern uint64_t read_from_ag_g7(void);
    39 extern void write_to_ag_g6(uint64_t val);
    40 extern void write_to_ag_g7(uint64_t val);
    41 extern void write_to_ig_g6(uint64_t val);
    42 
     38#include <trace.h>
    4339
    4440/** Read Version Register.
    4541 *
    4642 * @return Value of VER register.
     43 *
    4744 */
    48 static inline uint64_t ver_read(void)
     45NO_TRACE static inline uint64_t ver_read(void)
    4946{
    5047        uint64_t v;
    5148       
    52         asm volatile ("rdpr %%ver, %0\n" : "=r" (v));
     49        asm volatile (
     50                "rdpr %%ver, %[v]\n"
     51                : [v] "=r" (v)
     52        );
    5353       
    5454        return v;
    5555}
     56
     57extern uint64_t read_from_ag_g7(void);
     58extern void write_to_ag_g6(uint64_t);
     59extern void write_to_ag_g7(uint64_t);
     60extern void write_to_ig_g6(uint64_t);
    5661
    5762#endif

  • kernel/arch/sparc64/include/sun4u/cpu.h

    re3ee9b9 r7a0359b  
    3636#define KERN_sparc64_sun4u_CPU_H_
    3737
    38 #define MANUF_FUJITSU           0x04
    39 #define MANUF_ULTRASPARC        0x17    /**< UltraSPARC I, UltraSPARC II */
    40 #define MANUF_SUN               0x3e
     38#define MANUF_FUJITSU     0x04
     39#define MANUF_ULTRASPARC  0x17  /**< UltraSPARC I, UltraSPARC II */
     40#define MANUF_SUN         0x3e
    4141
    42 #define IMPL_ULTRASPARCI        0x10
    43 #define IMPL_ULTRASPARCII       0x11
    44 #define IMPL_ULTRASPARCII_I     0x12
    45 #define IMPL_ULTRASPARCII_E     0x13
    46 #define IMPL_ULTRASPARCIII      0x14
    47 #define IMPL_ULTRASPARCIII_PLUS 0x15
    48 #define IMPL_ULTRASPARCIII_I    0x16
    49 #define IMPL_ULTRASPARCIV       0x18
    50 #define IMPL_ULTRASPARCIV_PLUS  0x19
     42#define IMPL_ULTRASPARCI         0x10
     43#define IMPL_ULTRASPARCII        0x11
     44#define IMPL_ULTRASPARCII_I      0x12
     45#define IMPL_ULTRASPARCII_E      0x13
     46#define IMPL_ULTRASPARCIII       0x14
     47#define IMPL_ULTRASPARCIII_PLUS  0x15
     48#define IMPL_ULTRASPARCIII_I     0x16
     49#define IMPL_ULTRASPARCIV        0x18
     50#define IMPL_ULTRASPARCIV_PLUS   0x19
    5151
    52 #define IMPL_SPARC64V           0x5
     52#define IMPL_SPARC64V  0x5
    5353
    5454#ifndef __ASM__
    … …  
    5858#include <arch/regdef.h>
    5959#include <arch/asm.h>
     60#include <trace.h>
    6061
    6162#ifdef CONFIG_SMP
    … …  
    6465
    6566typedef struct {
    66         uint32_t mid;                   /**< Processor ID as read from
    67                                              UPA_CONFIG/FIREPLANE_CONFIG. */
     67        uint32_t mid;              /**< Processor ID as read from
     68                                        UPA_CONFIG/FIREPLANE_CONFIG. */
    6869        ver_reg_t ver;
    69         uint32_t clock_frequency;       /**< Processor frequency in Hz. */
    70         uint64_t next_tick_cmpr;        /**< Next clock interrupt should be
    71                                              generated when the TICK register
    72                                              matches this value. */
     70        uint32_t clock_frequency;  /**< Processor frequency in Hz. */
     71        uint64_t next_tick_cmpr;   /**< Next clock interrupt should be
     72                                        generated when the TICK register
     73                                        matches this value. */
    7374} cpu_arch_t;
    7475
    75 
    76 /**
    77  * Reads the module ID (agent ID/CPUID) of the current CPU.
     76/** Read the module ID (agent ID/CPUID) of the current CPU.
     77 *
    7878 */
    79 static inline uint32_t read_mid(void)
     79NO_TRACE static inline uint32_t read_mid(void)
    8080{
    8181        uint64_t icbus_config = asi_u64_read(ASI_ICBUS_CONFIG, 0);
    8282        icbus_config = icbus_config >> ICBUS_CONFIG_MID_SHIFT;
     83       
    8384#if defined (US)
    8485        return icbus_config & 0x1f;
    … …  
    9192}
    9293
    93 #endif 
     94#endif
    9495
    9596#endif

  • kernel/arch/sparc64/include/sun4v/asm.h

    re3ee9b9 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */

  • kernel/arch/sparc64/include/sun4v/cpu.h

    re3ee9b9 r7a0359b  
    3737
    3838/** Maximum number of virtual processors. */
    39 #define MAX_NUM_STRANDS         64
     39#define MAX_NUM_STRANDS  64
    4040
    4141/** Maximum number of logical processors in a processor core */
    42 #define MAX_CORE_STRANDS        8
     42#define MAX_CORE_STRANDS  8
    4343
    4444#ifndef __ASM__
    … …  
    5959
    6060typedef struct cpu_arch {
    61         uint64_t id;                    /**< virtual processor ID */
    62         uint32_t clock_frequency;       /**< Processor frequency in Hz. */
    63         uint64_t next_tick_cmpr;        /**< Next clock interrupt should be
    64                                              generated when the TICK register
    65                                              matches this value. */
    66         exec_unit_t *exec_unit;         /**< Physical core. */
    67         unsigned long proposed_nrdy;    /**< Proposed No. of ready threads
    68                                              so that cores are equally balanced. */
     61        uint64_t id;                  /**< virtual processor ID */
     62        uint32_t clock_frequency;     /**< Processor frequency in Hz. */
     63        uint64_t next_tick_cmpr;      /**< Next clock interrupt should be
     64                                           generated when the TICK register
     65                                           matches this value. */
     66        exec_unit_t *exec_unit;       /**< Physical core. */
     67        unsigned long proposed_nrdy;  /**< Proposed No. of ready threads
     68                                           so that cores are equally balanced. */
    6969} cpu_arch_t;
    70 
    71 #endif 
    72 
    73 #ifdef __ASM__
    7470
    7571#endif
Note: See TracChangeset for help on using the changeset viewer.