Changeset 22f7769 in mainline


Ignore:
Timestamp:
2005-10-17T23:31:41Z (19 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4b2c872d
Parents:
75eacab
Message:

Rename cpu_priority_{high|low|restore|read} functions to interrupts_{disable|enable|restore|read}.
Rename pri_t to ipl_t (Interrupt Priority Level).
Rename thread_t::pri to thread_t::priority.

Files:
48 edited

Legend:

Unmodified
Added
Removed

  • arch/amd64/include/asm.h

    r75eacab r22f7769  
    8383}
    8484
    85 /** Set priority level low
     85/** Enable interrupts.
    8686 *
    8787 * Enable interrupts and return previous
    8888 * value of EFLAGS.
    89  */
    90 static inline pri_t cpu_priority_low(void) {
    91         pri_t v;
     89 *
     90 * @return Old interrupt priority level.
     91 */
     92static inline ipl_t interrupts_enable(void) {
     93        ipl_t v;
    9294        __asm__ volatile (
    9395                "pushfq\n"
    … …  
    99101}
    100102
    101 /** Set priority level high
     103/** Disable interrupts.
    102104 *
    103105 * Disable interrupts and return previous
    104106 * value of EFLAGS.
    105  */
    106 static inline pri_t cpu_priority_high(void) {
    107         pri_t v;
     107 *
     108 * @return Old interrupt priority level.
     109 */
     110static inline ipl_t interrupts_disable(void) {
     111        ipl_t v;
    108112        __asm__ volatile (
    109113                "pushfq\n"
    … …  
    115119}
    116120
    117 /** Restore priority level
     121/** Restore interrupt priority level.
    118122 *
    119123 * Restore EFLAGS.
    120  */
    121 static inline void cpu_priority_restore(pri_t pri) {
     124 *
     125 * @param ipl Saved interrupt priority level.
     126 */
     127static inline void interrupts_restore(ipl_t ipl) {
    122128        __asm__ volatile (
    123129                "pushq %0\n"
    124130                "popfq\n"
    125                 : : "r" (pri)
    126                 );
    127 }
    128 
    129 /** Return raw priority level
     131                : : "r" (ipl)
     132                );
     133}
     134
     135/** Return interrupt priority level.
    130136 *
    131137 * Return EFLAFS.
    132  */
    133 static inline pri_t cpu_priority_read(void) {
    134         pri_t v;
     138 *
     139 * @return Current interrupt priority level.
     140 */
     141static inline ipl_t interrupts_read(void) {
     142        ipl_t v;
    135143        __asm__ volatile (
    136144                "pushfq\n"

  • arch/amd64/include/context.h

    r75eacab r22f7769  
    5656    __u64 r15;
    5757
    58     pri_t pri;
     58    ipl_t ipl;
    5959} __attribute__ ((packed));
    6060

  • arch/amd64/include/types.h

    r75eacab r22f7769  
    4141typedef __u64 __address;
    4242
    43 /* Flags of processor (return value of cpu_priority_high()) */
    44 typedef __u64 pri_t;
     43/* Flags of processor (return value of interrupts_disable()) */
     44typedef __u64 ipl_t;
    4545
    4646typedef __u64 __native;

  • arch/amd64/src/interrupt.c

    r75eacab r22f7769  
    109109/*
    110110 * Called directly from the assembler code.
    111  * CPU is cpu_priority_high().
     111 * CPU is interrupts_disable()'d.
    112112 */
    113113void trap_dispatcher(__u8 n, __native stack[])

  • arch/amd64/src/userspace.c

    r75eacab r22f7769  
    4242void userspace(void)
    4343{
    44         pri_t pri;
     44        ipl_t ipl;
    4545       
    46         pri = cpu_priority_high();
     46        ipl = interrupts_disable();
    4747
    4848        __asm__ volatile (""
    … …  
    5858                          "pushq %%rsi;"
    5959                          "iretq;"
    60                           : : "i" (gdtselector(UDATA_DES) | PL_USER), "i" (USTACK_ADDRESS+THREAD_STACK_SIZE), "r" (pri), "i" (gdtselector(UTEXT_DES) | PL_USER), "i" (UTEXT_ADDRESS));
     60                          : : "i" (gdtselector(UDATA_DES) | PL_USER), "i" (USTACK_ADDRESS+THREAD_STACK_SIZE), "r" (ipl), "i" (gdtselector(UTEXT_DES) | PL_USER), "i" (UTEXT_ADDRESS));
    6161       
    6262        /* Unreachable */

  • arch/ia32/include/asm.h

    r75eacab r22f7769  
    132132static inline __u32 inl(__u16 port) { __u32 val; __asm__ volatile ("inl %w1, %l0 \n" : "=a" (val) : "d" (port) ); return val; }
    133133
    134 /** Set priority level low
     134/** Enable interrupts.
    135135 *
    136136 * Enable interrupts and return previous
    137137 * value of EFLAGS.
    138  */
    139 static inline pri_t cpu_priority_low(void) {
    140         pri_t v;
     138 *
     139 * @return Old interrupt priority level.
     140 */
     141static inline ipl_t interrupts_enable(void) {
     142        ipl_t v;
    141143        __asm__ volatile (
    142144                "pushf\n\t"
    … …  
    148150}
    149151
    150 /** Set priority level high
     152/** Disable interrupts.
    151153 *
    152154 * Disable interrupts and return previous
    153155 * value of EFLAGS.
    154  */
    155 static inline pri_t cpu_priority_high(void) {
    156         pri_t v;
     156 *
     157 * @return Old interrupt priority level.
     158 */
     159static inline ipl_t interrupts_disable(void) {
     160        ipl_t v;
    157161        __asm__ volatile (
    158162                "pushf\n\t"
    … …  
    164168}
    165169
    166 /** Restore priority level
     170/** Restore interrupt priority level.
    167171 *
    168172 * Restore EFLAGS.
    169  */
    170 static inline void cpu_priority_restore(pri_t pri) {
     173 *
     174 * @param ipl Saved interrupt priority level.
     175 */
     176static inline void interrupts_restore(ipl_t ipl) {
    171177        __asm__ volatile (
    172178                "pushl %0\n\t"
    173179                "popf\n"
    174                 : : "r" (pri)
    175         );
    176 }
    177 
    178 /** Return raw priority level
    179  *
    180  * Return EFLAFS.
    181  */
    182 static inline pri_t cpu_priority_read(void) {
    183         pri_t v;
     180                : : "r" (ipl)
     181        );
     182}
     183
     184/** Return interrupt priority level.
     185 *
     186 * @return EFLAFS.
     187 */
     188static inline ipl_t interrupts_read(void) {
     189        ipl_t v;
    184190        __asm__ volatile (
    185191                "pushf\n\t"

  • arch/ia32/include/context.h

    r75eacab r22f7769  
    5353        __u32 edi;
    5454        __u32 ebp;
    55         __u32 pri;
     55        ipl_t ipl;
    5656} __attribute__ ((packed));
    5757

  • arch/ia32/include/types.h

    r75eacab r22f7769  
    4141typedef __u32 __address;
    4242
    43 typedef __u32 pri_t;
     43typedef __u32 ipl_t;
    4444
    4545typedef __u32 __native;

  • arch/ia32/src/drivers/ega.c

    r75eacab r22f7769  
    8181void ega_putchar(const char ch)
    8282{
    83         pri_t pri;
     83        ipl_t ipl;
    8484
    85         pri = cpu_priority_high();
     85        ipl = interrupts_disable();
    8686        spinlock_lock(&egalock);
    8787
    … …  
    102102
    103103        spinlock_unlock(&egalock);
    104         cpu_priority_restore(pri);
     104        interrupts_restore(ipl);
    105105}
    106106

  • arch/ia32/src/interrupt.c

    r75eacab r22f7769  
    8080/*
    8181 * Called directly from the assembler code.
    82  * CPU is cpu_priority_high().
     82 * CPU is interrupts_disable()'d.
    8383 */
    8484void trap_dispatcher(__u8 n, __native stack[])

  • arch/ia32/src/userspace.c

    r75eacab r22f7769  
    4242void userspace(void)
    4343{
    44         pri_t pri;
     44        ipl_t ipl;
    4545       
    46         pri = cpu_priority_high();
     46        ipl = interrupts_disable();
    4747
    4848        __asm__ volatile (
    … …  
    6161                "iret"
    6262                :
    63                 : "i" (selector(UDATA_DES) | PL_USER), "r" (USTACK_ADDRESS+(THREAD_STACK_SIZE)), "r" (pri), "i" (selector(UTEXT_DES) | PL_USER), "i" (UTEXT_ADDRESS)
     63                : "i" (selector(UDATA_DES) | PL_USER), "r" (USTACK_ADDRESS+(THREAD_STACK_SIZE)), "r" (ipl), "i" (selector(UTEXT_DES) | PL_USER), "i" (UTEXT_ADDRESS)
    6464                : "eax");
    6565       

  • arch/ia64/include/context.h

    r75eacab r22f7769  
    9696        __u64 pr;
    9797       
    98         pri_t pri;
     98        ipl_t ipl;
    9999} __attribute__ ((packed));
    100100

  • arch/ia64/include/types.h

    r75eacab r22f7769  
    4141typedef __u64 __address;
    4242
    43 typedef __u64 pri_t;
     43typedef __u64 ipl_t;
    4444
    4545typedef __u64 __native;

  • arch/ia64/src/context.S

    r75eacab r22f7769  
    135135         */
    136136
     137        /* TODO: ensure RSE lazy mode */
    137138        mov ar.bspstore = loc4
    138139        mov ar.rnat = loc5

  • arch/ia64/src/dummy.s

    r75eacab r22f7769  
    3636.global cpu_identify
    3737.global cpu_print_report
    38 .global cpu_priority_high
    39 .global cpu_priority_low
    40 .global cpu_priority_read
    41 .global cpu_priority_restore
     38.global interrupts_disable
     39.global interrupts_enable
     40.global interrupts_read
     41.global interrupts_restore
    4242.global cpu_sleep
    4343.global dummy
    … …  
    5353cpu_identify:
    5454cpu_print_report:
    55 cpu_priority_high:
    56 cpu_priority_low:
    57 cpu_priority_read:
    58 cpu_priority_restore:
     55interrupts_disable:
     56interrupts_enable:
     57interrupts_read:
     58interrupts_restore:
    5959cpu_sleep:
    6060fpu_init:

  • arch/mips32/include/context.h

    r75eacab r22f7769  
    6363        __u32 gp;
    6464
    65         __u32 pri;
     65        ipl_t ipl;
    6666};
    6767

  • arch/mips32/include/types.h

    r75eacab r22f7769  
    4646typedef __u32 __address;
    4747
    48 typedef __u32 pri_t;
     48typedef __u32 ipl_t;
    4949
    5050typedef __u32 __native;

  • arch/mips32/src/drivers/arc.c

    r75eacab r22f7769  
    176176{
    177177        __u32 cnt;
    178         pri_t pri;
     178        ipl_t ipl;
    179179
    180180        /* TODO: Should be spinlock? */
    181         pri = cpu_priority_high();
     181        ipl = interrupts_disable();
    182182        arc_entry->write(1, &ch, 1, &cnt);
    183         cpu_priority_restore(pri);
     183        interrupts_restore(ipl);
    184184       
    185185}

  • arch/mips32/src/exception.c

    r75eacab r22f7769  
    4747         * NOTE ON OPERATION ORDERING
    4848         *
    49          * On entry, cpu_priority_high() must be called before
     49         * On entry, interrupts_disable() must be called before
    5050         * exception bit is cleared.
    5151         */
    5252
    53         cpu_priority_high();
     53        interrupts_disable();
    5454        cp0_status_write(cp0_status_read() & ~ (cp0_status_exl_exception_bit |
    5555                                                cp0_status_um_bit));

  • arch/mips32/src/interrupt.c

    r75eacab r22f7769  
    5353}
    5454
    55 pri_t cpu_priority_high(void)
     55/** Disable interrupts.
     56 *
     57 * @return Old interrupt priority level.
     58 */
     59ipl_t interrupts_disable(void)
    5660{
    57         pri_t pri = (pri_t) cp0_status_read();
    58         cp0_status_write(pri & ~cp0_status_ie_enabled_bit);
    59         return pri;
     61        ipl_t ipl = (ipl_t) cp0_status_read();
     62        cp0_status_write(ipl & ~cp0_status_ie_enabled_bit);
     63        return ipl;
    6064}
    6165
    62 pri_t cpu_priority_low(void)
     66/** Enable interrupts.
     67 *
     68 * @return Old interrupt priority level.
     69 */
     70ipl_t interrupts_enable(void)
    6371{
    64         pri_t pri = (pri_t) cp0_status_read();
    65         cp0_status_write(pri | cp0_status_ie_enabled_bit);
    66         return pri;
     72        ipl_t ipl = (ipl_t) cp0_status_read();
     73        cp0_status_write(ipl | cp0_status_ie_enabled_bit);
     74        return ipl;
    6775}
    6876
    69 void cpu_priority_restore(pri_t pri)
     77/** Restore interrupt priority level.
     78 *
     79 * @param ipl Saved interrupt priority level.
     80 */
     81void interrupts_restore(ipl_t ipl)
    7082{
    71         cp0_status_write(cp0_status_read() | (pri & cp0_status_ie_enabled_bit));
     83        cp0_status_write(cp0_status_read() | (ipl & cp0_status_ie_enabled_bit));
    7284}
    7385
    74 pri_t cpu_priority_read(void)
     86/** Read interrupt priority level.
     87 *
     88 * @return Current interrupt priority level.
     89 */
     90ipl_t interrupts_read(void)
    7591{
    7692        return cp0_status_read();

  • arch/mips32/src/mips32.c

    r75eacab r22f7769  
    5353{
    5454        /* It is not assumed by default */
    55         cpu_priority_high();
     55        interrupts_disable();
    5656
    5757        init_arc();

  • arch/mips32/src/mm/asid.c

    r75eacab r22f7769  
    4545asid_t asid_get(void)
    4646{
    47         pri_t pri;
     47        ipl_t ipl;
    4848        int i, j;
    4949        count_t min;
    … …  
    5151        min = (unsigned) -1;
    5252       
    53         pri = cpu_priority_high();
     53        ipl = interrupts_disable();
    5454        spinlock_lock(&asid_usage_lock);
    5555       
    … …  
    6666
    6767        spinlock_unlock(&asid_usage_lock);
    68         cpu_priority_restore(pri);
     68        interrupts_restore(ipl);
    6969
    7070        return i;
    … …  
    7979void asid_put(asid_t asid)
    8080{
    81         pri_t pri;
     81        ipl_t ipl;
    8282
    83         pri = cpu_priority_high();
     83        ipl = interrupts_disable();
    8484        spinlock_lock(&asid_usage_lock);
    8585
    … …  
    9090
    9191        spinlock_unlock(&asid_usage_lock);
    92         cpu_priority_restore(pri);
     92        interrupts_restore(ipl);
    9393}
    9494
    … …  
    104104{
    105105        bool has_conflicts = false;
    106         pri_t pri;
     106        ipl_t ipl;
    107107
    108108        ASSERT(asid != ASID_INVALID);
    109109
    110         pri = cpu_priority_high();
     110        ipl = interrupts_disable();
    111111        spinlock_lock(&asid_usage_lock);
    112112
    … …  
    115115
    116116        spinlock_unlock(&asid_usage_lock);
    117         cpu_priority_restore(pri);
     117        interrupts_restore(ipl);
    118118
    119119        return has_conflicts;

  • arch/mips32/src/mm/tlb.c

    r75eacab r22f7769  
    316316{
    317317        entry_hi_t hi;
    318         pri_t pri;
     318        ipl_t ipl;
    319319        int i; 
    320320       
    321321        ASSERT(asid != ASID_INVALID);
    322322
    323         pri = cpu_priority_high();
     323        ipl = interrupts_disable();
    324324       
    325325        for (i = 0; i < TLB_SIZE; i++) {
    … …  
    337337        }
    338338       
    339         cpu_priority_restore(pri);
     339        interrupts_restore(ipl);
    340340}
    341341

  • arch/mips32/src/mm/vm.c

    r75eacab r22f7769  
    4242{
    4343        entry_hi_t hi;
    44         pri_t pri;
     44        ipl_t ipl;
    4545       
    4646        hi.value = cp0_entry_hi_read();
    4747
    48         pri = cpu_priority_high();
     48        ipl = interrupts_disable();
    4949        spinlock_lock(&vm->lock);
    5050        hi.asid = vm->asid;
    5151        cp0_entry_hi_write(hi.value);   
    5252        spinlock_lock(&vm->unlock);
    53         cpu_priority_restore(pri);
     53        interrupts_restore(ipl);
    5454}

  • arch/ppc32/include/asm.h

    r75eacab r22f7769  
    3333#include <config.h>
    3434
    35 /** Set priority level low
     35/** Enable interrupts.
    3636 *
    3737 * Enable interrupts and return previous
    3838 * value of EE.
     39 *
     40 * @return Old interrupt priority level.
    3941 */
    40 static inline pri_t cpu_priority_low(void) {
    41         pri_t v;
    42         pri_t tmp;
     42static inline ipl_t interrupts_enable(void) {
     43        ipl_t v;
     44        ipl_t tmp;
    4345       
    4446        __asm__ volatile (
    … …  
    5254}
    5355
    54 /** Set priority level high
     56/** Disable interrupts.
    5557 *
    5658 * Disable interrupts and return previous
    5759 * value of EE.
     60 *
     61 * @return Old interrupt priority level.
    5862 */
    59 static inline pri_t cpu_priority_high(void) {
    60         pri_t v;
    61         pri_t tmp;
     63static inline ipl_t interrupts_disable(void) {
     64        ipl_t v;
     65        ipl_t tmp;
    6266       
    6367        __asm__ volatile (
    … …  
    7175}
    7276
    73 /** Restore priority level
     77/** Restore interrupt priority level.
    7478 *
    7579 * Restore EE.
     80 *
     81 * @param ipl Saved interrupt priority level.
    7682 */
    77 static inline void cpu_priority_restore(pri_t pri) {
    78         pri_t tmp;
     83static inline void interrupts_restore(ipl_t ipl) {
     84        ipl_t tmp;
    7985       
    8086        __asm__ volatile (
    … …  
    8591                "mtmsr %0\n"
    8692                "0:\n"
    87                 : "=r" (pri), "=r" (tmp)
    88                 : "0" (pri)
     93                : "=r" (ipl), "=r" (tmp)
     94                : "0" (ipl)
    8995        );
    9096}
    9197
    92 /** Return raw priority level
     98/** Return interrupt priority level.
    9399 *
    94100 * Return EE.
     101 *
     102 * @return Current interrupt priority level.
    95103 */
    96 static inline pri_t cpu_priority_read(void) {
    97         pri_t v;
     104static inline ipl_t interrupts_read(void) {
     105        ipl_t v;
    98106        __asm__ volatile (
    99107                "mfmsr %0\n"

  • arch/ppc32/include/context.h

    r75eacab r22f7769  
    6868        __u32 r31;
    6969        __u32 pc;
    70         pri_t pri;
     70        ipl_t ipl;
    7171} __attribute__ ((packed));
    7272

  • arch/ppc32/include/types.h

    r75eacab r22f7769  
    4141typedef __u32 __address;
    4242
    43 typedef __u32 pri_t;
     43typedef __u32 ipl_t;
    4444
    4545typedef __u32 __native;

  • include/arch.h

    r75eacab r22f7769  
    4747#endif /* early_mapping */
    4848
    49 /*
     49/**
    5050 * For each possible kernel stack, structure
    5151 * of the following type will be placed at
    … …  
    5353 */
    5454struct the {
    55         int preemption_disabled;
    56         thread_t *thread;               /* current thread */
    57         task_t *task;                   /* current task */
    58         cpu_t *cpu;                     /* executing cpu */
    59         vm_t *vm;                       /* current vm */
     55        int preemption_disabled;        /**< Preemption disabled counter. */
     56        thread_t *thread;               /**< Current thread. */
     57        task_t *task;                   /**< Current task. */
     58        cpu_t *cpu;                     /**< Executing cpu. */
     59        vm_t *vm;                       /**< Current vm. */
    6060};
    6161
    … …  
    7070extern void calibrate_delay_loop(void);
    7171
    72 extern pri_t cpu_priority_high(void);
    73 extern pri_t cpu_priority_low(void);
    74 extern void cpu_priority_restore(pri_t pri);
    75 extern pri_t cpu_priority_read(void);
     72extern ipl_t interrupts_disable(void);
     73extern ipl_t interrupts_enable(void);
     74extern void interrupts_restore(ipl_t ipl);
     75extern ipl_t interrupts_read(void);
    7676
    7777#endif

  • include/proc/thread.h

    r75eacab r22f7769  
    101101        __u64 ticks;                            /**< Ticks before preemption. */
    102102
    103         int pri;                                /**< Thread's priority. Implemented as index of run queue. */
     103        int priority;                           /**< Thread's priority. Implemented as index to CPU->rq */
    104104        __u32 tid;                              /**< Thread ID. */
    105105       

  • src/debug/print.c

    r75eacab r22f7769  
    286286        va_start(ap, fmt);
    287287
    288         irqpri = cpu_priority_high();
     288        irqpri = interrupts_disable();
    289289        spinlock_lock(&printflock);
    290290
    … …  
    401401out:
    402402        spinlock_unlock(&printflock);
    403         cpu_priority_restore(irqpri);
     403        interrupts_restore(irqpri);
    404404       
    405405        va_end(ap);

  • src/lib/func.c

    r75eacab r22f7769  
    4444{
    4545        haltstate = 1;
    46         cpu_priority_high();
     46        interrupts_disable();
    4747        if (CPU)
    4848                printf("cpu%d: halted\n", CPU->id);

  • src/main/kinit.c

    r75eacab r22f7769  
    6565        int i;
    6666
    67         cpu_priority_high();
     67        interrupts_disable();
    6868
    6969#ifdef __SMP__                 
    … …  
    116116#endif /* __SMP__ */
    117117
    118         cpu_priority_low();
     118        interrupts_enable();
    119119
    120120#ifdef __USERSPACE__

  • src/main/main.c

    r75eacab r22f7769  
    110110 * Initializes the kernel by bootstrap CPU.
    111111 *
    112  * Assuming cpu_priority_high().
     112 * Assuming interrupts_disable().
    113113 *
    114114 */
    … …  
    209209 * is at ctx.sp which was set during BP boot.
    210210 *
    211  * Assuming  cpu_priority_high().
     211 * Assuming interrupts_disable()'d.
    212212 *
    213213 */

  • src/mm/frame.c

    r75eacab r22f7769  
    6969__address frame_alloc(int flags)
    7070{
    71         pri_t pri;
     71        ipl_t ipl;
    7272        link_t *cur, *tmp;
    7373        zone_t *z;
    … …  
    7777       
    7878loop:
    79         pri = cpu_priority_high();
     79        ipl = interrupts_disable();
    8080        spinlock_lock(&zone_head_lock);
    8181       
    … …  
    105105                 */
    106106                spinlock_unlock(&zone_head_lock);
    107                 cpu_priority_restore(pri);
     107                interrupts_restore(ipl);
    108108
    109109                panic("Sleep not implemented.\n");
    … …  
    127127       
    128128        spinlock_unlock(&zone_head_lock);
    129         cpu_priority_restore(pri);
     129        interrupts_restore(ipl);
    130130       
    131131        return v;
    … …  
    142142void frame_free(__address addr)
    143143{
    144         pri_t pri;
     144        ipl_t ipl;
    145145        link_t *cur;
    146146        zone_t *z;
    … …  
    150150        ASSERT(addr % FRAME_SIZE == 0);
    151151       
    152         pri = cpu_priority_high();
     152        ipl = interrupts_disable();
    153153        spinlock_lock(&zone_head_lock);
    154154       
    … …  
    188188       
    189189        spinlock_unlock(&zone_head_lock);
    190         cpu_priority_restore(pri);
     190        interrupts_restore(ipl);
    191191}
    192192
    … …  
    200200void frame_not_free(__address addr)
    201201{
    202         pri_t pri;
     202        ipl_t ipl;
    203203        link_t *cur;
    204204        zone_t *z;
    … …  
    208208        ASSERT(addr % FRAME_SIZE == 0);
    209209       
    210         pri = cpu_priority_high();
     210        ipl = interrupts_disable();
    211211        spinlock_lock(&zone_head_lock);
    212212       
    … …  
    247247       
    248248        spinlock_unlock(&zone_head_lock);
    249         cpu_priority_restore(pri);
     249        interrupts_restore(ipl);
    250250}
    251251
    … …  
    336336void zone_attach(zone_t *zone)
    337337{
    338         pri_t pri;
    339        
    340         pri = cpu_priority_high();
     338        ipl_t ipl;
     339       
     340        ipl = interrupts_disable();
    341341        spinlock_lock(&zone_head_lock);
    342342       
    … …  
    344344       
    345345        spinlock_unlock(&zone_head_lock);
    346         cpu_priority_restore(pri);
     346        interrupts_restore(ipl);
    347347}
    348348

  • src/mm/heap.c

    r75eacab r22f7769  
    6161void *early_malloc(size_t size)
    6262{
    63         pri_t pri;
     63        ipl_t ipl;
    6464        chunk_t *x, *y, *z;
    6565
    … …  
    6868               
    6969        x = chunk0;
    70         pri = cpu_priority_high();
     70        ipl = interrupts_disable();
    7171        spinlock_lock(&heaplock);               
    7272        while (x) {
    … …  
    8585                if (x->size < size + sizeof(chunk_t) + 1) {
    8686                        spinlock_unlock(&heaplock);
    87                         cpu_priority_restore(pri);
     87                        interrupts_restore(ipl);
    8888                        return &x->data[0];
    8989                }
    … …  
    106106                x->next = y;
    107107                spinlock_unlock(&heaplock);
    108                 cpu_priority_restore(pri);
     108                interrupts_restore(ipl);
    109109
    110110                return &x->data[0];
    111111        }
    112112        spinlock_unlock(&heaplock);
    113         cpu_priority_restore(pri);
     113        interrupts_restore(ipl);
    114114        return NULL;
    115115}
    … …  
    117117void early_free(void *ptr)
    118118{
    119         pri_t pri;
     119        ipl_t ipl;
    120120        chunk_t *x, *y, *z;
    121121
    … …  
    128128                panic("freeing unused/damaged chunk");
    129129
    130         pri = cpu_priority_high();
     130        ipl = interrupts_disable();
    131131        spinlock_lock(&heaplock);
    132132        x = y->prev;
    … …  
    151151        y->used = 0;
    152152        spinlock_unlock(&heaplock);
    153         cpu_priority_restore(pri);
     153        interrupts_restore(ipl);
    154154}

  • src/mm/vm.c

    r75eacab r22f7769  
    9090vm_area_t *vm_area_create(vm_t *m, vm_type_t type, size_t size, __address addr)
    9191{
    92         pri_t pri;
     92        ipl_t ipl;
    9393        vm_area_t *a;
    9494       
    … …  
    9696                panic("addr not aligned to a page boundary");
    9797       
    98         pri = cpu_priority_high();
     98        ipl = interrupts_disable();
    9999        spinlock_lock(&m->lock);
    100100       
    … …  
    111111                        free(a);
    112112                        spinlock_unlock(&m->lock);
    113                         cpu_priority_restore(pri);
     113                        interrupts_restore(ipl);
    114114                        return NULL;
    115115                }
    … …  
    130130
    131131        spinlock_unlock(&m->lock);
    132         cpu_priority_restore(pri);
     132        interrupts_restore(ipl);
    133133       
    134134        return a;
    … …  
    142142{
    143143        int i, flags;
    144         pri_t pri;
    145        
    146         pri = cpu_priority_high();
     144        ipl_t ipl;
     145       
     146        ipl = interrupts_disable();
    147147        spinlock_lock(&m->lock);
    148148        spinlock_lock(&a->lock);
    … …  
    166166        spinlock_unlock(&a->lock);
    167167        spinlock_unlock(&m->lock);
    168         cpu_priority_restore(pri);
     168        interrupts_restore(ipl);
    169169}
    170170
    … …  
    172172{
    173173        int i;
    174         pri_t pri;
    175        
    176         pri = cpu_priority_high();
     174        ipl_t ipl;
     175       
     176        ipl = interrupts_disable();
    177177        spinlock_lock(&m->lock);
    178178        spinlock_lock(&a->lock);
    … …  
    184184        spinlock_unlock(&a->lock);
    185185        spinlock_unlock(&m->lock);
    186         cpu_priority_restore(pri);
     186        interrupts_restore(ipl);
    187187}
    188188
    … …  
    190190{
    191191        link_t *l;
    192         pri_t pri;
    193        
    194         pri = cpu_priority_high();
     192        ipl_t ipl;
     193       
     194        ipl = interrupts_disable();
    195195
    196196        tlb_shootdown_start();
    … …  
    203203        tlb_shootdown_finalize();
    204204
    205         cpu_priority_restore(pri);
     205        interrupts_restore(ipl);
    206206
    207207        vm_install_arch(m);

  • src/proc/scheduler.c

    r75eacab r22f7769  
    126126
    127127loop:
    128         cpu_priority_high();
     128        interrupts_disable();
    129129
    130130        spinlock_lock(&CPU->lock);
    … …  
    132132        spinlock_unlock(&CPU->lock);
    133133
    134         cpu_priority_low();
     134        interrupts_enable();
    135135       
    136136        if (n == 0) {
    … …  
    156156        }
    157157
    158         cpu_priority_high();
     158        interrupts_disable();
    159159       
    160160        i = 0;
    … …  
    197197
    198198                t->ticks = us2ticks((i+1)*10000);
    199                 t->pri = i;     /* eventually correct rq index */
     199                t->priority = i;        /* eventually correct rq index */
    200200
    201201                /*
    … …  
    262262void scheduler(void)
    263263{
    264         volatile pri_t pri;
     264        volatile ipl_t ipl;
    265265
    266266        ASSERT(CPU != NULL);
    267267
    268         pri = cpu_priority_high();
     268        ipl = interrupts_disable();
    269269
    270270        if (haltstate)
    … …  
    282282                        before_thread_runs();
    283283                        spinlock_unlock(&THREAD->lock);
    284                         cpu_priority_restore(THREAD->saved_context.pri);
     284                        interrupts_restore(THREAD->saved_context.ipl);
    285285                        return;
    286286                }
    287287
    288288                /*
    289                  * CPU priority of preempted thread is recorded here
    290                  * to facilitate scheduler() invocations from
    291                  * cpu_priority_high()'ed code (e.g. waitq_sleep_timeout()).
    292                  */
    293                 THREAD->saved_context.pri = pri;
     289                 * Interrupt priority level of preempted thread is recorded here
     290                 * to facilitate scheduler() invocations from interrupts_disable()'d
     291                 * code (e.g. waitq_sleep_timeout()).
     292                 */
     293                THREAD->saved_context.ipl = ipl;
    294294        }
    295295
    … …  
    372372                         * Prefer the thread after it's woken up.
    373373                         */
    374                         THREAD->pri = -1;
     374                        THREAD->priority = -1;
    375375
    376376                        /*
    … …  
    407407       
    408408        spinlock_lock(&THREAD->lock);
    409         priority = THREAD->pri;
     409        priority = THREAD->priority;
    410410        spinlock_unlock(&THREAD->lock);
    411411
    … …  
    447447
    448448        #ifdef SCHEDULER_VERBOSE
    449         printf("cpu%d: tid %d (pri=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->pri, THREAD->ticks, CPU->nrdy);
     449        printf("cpu%d: tid %d (priority=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks, CPU->nrdy);
    450450        #endif 
    451451
    … …  
    473473        thread_t *t;
    474474        int count, i, j, k = 0;
    475         pri_t pri;
     475        ipl_t ipl;
    476476
    477477loop:
    … …  
    487487         * passes. Each time get the most up to date counts.
    488488         */
    489         pri = cpu_priority_high();
     489        ipl = interrupts_disable();
    490490        spinlock_lock(&CPU->lock);
    491491        count = nrdy / config.cpu_active;
    492492        count -= CPU->nrdy;
    493493        spinlock_unlock(&CPU->lock);
    494         cpu_priority_restore(pri);
     494        interrupts_restore(ipl);
    495495
    496496        if (count <= 0)
    … …  
    515515                                continue;                               
    516516
    517 restart:                pri = cpu_priority_high();
     517restart:                ipl = interrupts_disable();
    518518                        r = &cpu->rq[j];
    519519                        spinlock_lock(&r->lock);
    520520                        if (r->n == 0) {
    521521                                spinlock_unlock(&r->lock);
    522                                 cpu_priority_restore(pri);
     522                                interrupts_restore(ipl);
    523523                                continue;
    524524                        }
    … …  
    549549                                                /* Release all locks and try again. */
    550550                                                spinlock_unlock(&r->lock);
    551                                                 cpu_priority_restore(pri);
     551                                                interrupts_restore(ipl);
    552552                                                goto restart;
    553553                                        }
    … …  
    581581                                thread_ready(t);
    582582
    583                                 cpu_priority_restore(pri);
     583                                interrupts_restore(ipl);
    584584       
    585585                                if (--count == 0)
    … …  
    593593                                continue;
    594594                        }
    595                         cpu_priority_restore(pri);
     595                        interrupts_restore(ipl);
    596596                }
    597597        }

  • src/proc/task.c

    r75eacab r22f7769  
    6565task_t *task_create(vm_t *m)
    6666{
    67         pri_t pri;
     67        ipl_t ipl;
    6868        task_t *ta;
    6969       
    … …  
    7575                ta->vm = m;
    7676               
    77                 pri = cpu_priority_high();
     77                ipl = interrupts_disable();
    7878                spinlock_lock(&tasks_lock);
    7979                list_append(&ta->tasks_link, &tasks_head);
    8080                spinlock_unlock(&tasks_lock);
    81                 cpu_priority_restore(pri);
     81                interrupts_restore(ipl);
    8282        }
    8383        return ta;

  • src/proc/thread.c

    r75eacab r22f7769  
    6868 * function returns.
    6969 *
    70  * cpu_priority_high() is assumed.
     70 * interrupts_disable() is assumed.
    7171 *
    7272 */
    … …  
    8080
    8181        spinlock_unlock(&THREAD->lock);
    82         cpu_priority_low();
     82        interrupts_enable();
    8383
    8484        f(arg);
    … …  
    113113        cpu_t *cpu;
    114114        runq_t *r;
    115         pri_t pri;
     115        ipl_t ipl;
    116116        int i, avg, send_ipi = 0;
    117117
    118         pri = cpu_priority_high();
     118        ipl = interrupts_disable();
    119119
    120120        spinlock_lock(&t->lock);
    121121
    122         i = (t->pri < RQ_COUNT -1) ? ++t->pri : t->pri;
     122        i = (t->priority < RQ_COUNT -1) ? ++t->priority : t->priority;
    123123       
    124124        cpu = CPU;
    … …  
    149149        spinlock_unlock(&cpu->lock);
    150150
    151         cpu_priority_restore(pri);
     151        interrupts_restore(ipl);
    152152}
    153153
    … …  
    172172        t = (thread_t *) malloc(sizeof(thread_t));
    173173        if (t) {
    174                 pri_t pri;
     174                ipl_t ipl;
    175175       
    176176                spinlock_initialize(&t->lock);
    … …  
    181181                }
    182182
    183                 pri = cpu_priority_high();
     183                ipl = interrupts_disable();
    184184                spinlock_lock(&tidlock);
    185185                t->tid = ++last_tid;
    186186                spinlock_unlock(&tidlock);
    187                 cpu_priority_restore(pri);
     187                interrupts_restore(ipl);
    188188               
    189189                memsetb(frame_ks, THREAD_STACK_SIZE, 0);
    … …  
    200200                the_initialize((the_t *) t->kstack);
    201201
    202                 pri = cpu_priority_high();
    203                 t->saved_context.pri = cpu_priority_read();
    204                 cpu_priority_restore(pri);
     202                ipl = interrupts_disable();
     203                t->saved_context.ipl = interrupts_read();
     204                interrupts_restore(ipl);
    205205               
    206206                t->thread_code = func;
    207207                t->thread_arg = arg;
    208208                t->ticks = -1;
    209                 t->pri = -1;            /* start in rq[0] */
     209                t->priority = -1;               /* start in rq[0] */
    210210                t->cpu = NULL;
    211211                t->flags = 0;
    … …  
    228228                 * Register this thread in the system-wide list.
    229229                 */
    230                 pri = cpu_priority_high();             
     230                ipl = interrupts_disable();             
    231231                spinlock_lock(&threads_lock);
    232232                list_append(&t->threads_link, &threads_head);
    … …  
    240240                spinlock_unlock(&task->lock);
    241241
    242                 cpu_priority_restore(pri);
     242                interrupts_restore(ipl);
    243243        }
    244244
    … …  
    255255void thread_exit(void)
    256256{
    257         pri_t pri;
     257        ipl_t ipl;
    258258
    259259restart:
    260         pri = cpu_priority_high();
     260        ipl = interrupts_disable();
    261261        spinlock_lock(&THREAD->lock);
    262262        if (THREAD->timeout_pending) { /* busy waiting for timeouts in progress */
    263263                spinlock_unlock(&THREAD->lock);
    264                 cpu_priority_restore(pri);
     264                interrupts_restore(ipl);
    265265                goto restart;
    266266        }
    … …  
    312312void thread_register_call_me(void (* call_me)(void *), void *call_me_with)
    313313{
    314         pri_t pri;
    315        
    316         pri = cpu_priority_high();
     314        ipl_t ipl;
     315       
     316        ipl = interrupts_disable();
    317317        spinlock_lock(&THREAD->lock);
    318318        THREAD->call_me = call_me;
    319319        THREAD->call_me_with = call_me_with;
    320320        spinlock_unlock(&THREAD->lock);
    321         cpu_priority_restore(pri);
    322 }
     321        interrupts_restore(ipl);
     322}

  • src/synch/rwlock.c

    r75eacab r22f7769  
    9797int _rwlock_write_lock_timeout(rwlock_t *rwl, __u32 usec, int trylock)
    9898{
    99         pri_t pri;
     99        ipl_t ipl;
    100100        int rc;
    101101       
    102         pri = cpu_priority_high();
     102        ipl = interrupts_disable();
    103103        spinlock_lock(&THREAD->lock);
    104104        THREAD->rwlock_holder_type = RWLOCK_WRITER;
    105105        spinlock_unlock(&THREAD->lock);
    106         cpu_priority_restore(pri);
     106        interrupts_restore(ipl);
    107107
    108108        /*
    … …  
    119119                 */
    120120                 
    121                 pri = cpu_priority_high();
     121                ipl = interrupts_disable();
    122122                spinlock_lock(&rwl->lock);
    123123                /*
    … …  
    129129                        let_others_in(rwl, ALLOW_READERS_ONLY);
    130130                spinlock_unlock(&rwl->lock);
    131                 cpu_priority_restore(pri);
     131                interrupts_restore(ipl);
    132132        }
    133133       
    … …  
    152152{
    153153        int rc;
    154         pri_t pri;
    155        
    156         pri = cpu_priority_high();
     154        ipl_t ipl;
     155       
     156        ipl = interrupts_disable();
    157157        spinlock_lock(&THREAD->lock);
    158158        THREAD->rwlock_holder_type = RWLOCK_READER;
    … …  
    205205                                /*
    206206                                 * The sleep timeouted.
    207                                  * We just restore the cpu priority.
     207                                 * We just restore interrupt priority level.
    208208                                 */
    209209                        case ESYNCH_OK_BLOCKED:         
    … …  
    216216                                 * rwl->lock is held.)
    217217                                 */
    218                                 cpu_priority_restore(pri);
     218                                interrupts_restore(ipl);
    219219                                break;
    220220                        case ESYNCH_OK_ATOMIC:
    … …  
    237237       
    238238        spinlock_unlock(&rwl->lock);
    239         cpu_priority_restore(pri);
     239        interrupts_restore(ipl);
    240240
    241241        return ESYNCH_OK_ATOMIC;
    … …  
    252252void rwlock_write_unlock(rwlock_t *rwl)
    253253{
    254         pri_t pri;
    255        
    256         pri = cpu_priority_high();
     254        ipl_t ipl;
     255       
     256        ipl = interrupts_disable();
    257257        spinlock_lock(&rwl->lock);
    258258        let_others_in(rwl, ALLOW_ALL);
    259259        spinlock_unlock(&rwl->lock);
    260         cpu_priority_restore(pri);
     260        interrupts_restore(ipl);
    261261       
    262262}
    … …  
    273273void rwlock_read_unlock(rwlock_t *rwl)
    274274{
    275         pri_t pri;
    276 
    277         pri = cpu_priority_high();
     275        ipl_t ipl;
     276
     277        ipl = interrupts_disable();
    278278        spinlock_lock(&rwl->lock);
    279279        if (!--rwl->readers_in)
    280280                let_others_in(rwl, ALLOW_ALL);
    281281        spinlock_unlock(&rwl->lock);
    282         cpu_priority_restore(pri);
     282        interrupts_restore(ipl);
    283283}
    284284
    … …  
    290290 *
    291291 * Must be called with rwl->lock locked.
    292  * Must be called with cpu_priority_high'ed.
     292 * Must be called with interrupts_disable()'d.
    293293 *
    294294 * @param rwl Reader/Writer lock.

  • src/synch/semaphore.c

    r75eacab r22f7769  
    4343void semaphore_initialize(semaphore_t *s, int val)
    4444{
    45         pri_t pri;
     45        ipl_t ipl;
    4646       
    4747        waitq_initialize(&s->wq);
    4848       
    49         pri = cpu_priority_high();
     49        ipl = interrupts_disable();
    5050
    5151        spinlock_lock(&s->wq.lock);
    … …  
    5353        spinlock_unlock(&s->wq.lock);
    5454
    55         cpu_priority_restore(pri);
     55        interrupts_restore(ipl);
    5656}
    5757

  • src/synch/waitq.c

    r75eacab r22f7769  
    138138int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int nonblocking)
    139139{
    140         volatile pri_t pri; /* must be live after context_restore() */
     140        volatile ipl_t ipl; /* must be live after context_restore() */
    141141       
    142142       
    143143restart:
    144         pri = cpu_priority_high();
     144        ipl = interrupts_disable();
    145145       
    146146        /*
    … …  
    154154        if (THREAD->timeout_pending) {
    155155                spinlock_unlock(&THREAD->lock);
    156                 cpu_priority_restore(pri);             
     156                interrupts_restore(ipl);               
    157157                goto restart;
    158158        }
    … …  
    165165                wq->missed_wakeups--;
    166166                spinlock_unlock(&wq->lock);
    167                 cpu_priority_restore(pri);
     167                interrupts_restore(ipl);
    168168                return ESYNCH_OK_ATOMIC;
    169169        }
    … …  
    172172                        /* return immediatelly instead of going to sleep */
    173173                        spinlock_unlock(&wq->lock);
    174                         cpu_priority_restore(pri);
     174                        interrupts_restore(ipl);
    175175                        return ESYNCH_WOULD_BLOCK;
    176176                }
    … …  
    190190                        before_thread_runs();
    191191                        spinlock_unlock(&THREAD->lock);
    192                         cpu_priority_restore(pri);
     192                        interrupts_restore(ipl);
    193193                        return ESYNCH_TIMEOUT;
    194194                }
    … …  
    208208
    209209        scheduler();    /* wq->lock is released in scheduler_separated_stack() */
    210         cpu_priority_restore(pri);
     210        interrupts_restore(ipl);
    211211       
    212212        return ESYNCH_OK_BLOCKED;
    … …  
    229229void waitq_wakeup(waitq_t *wq, int all)
    230230{
    231         pri_t pri;
    232 
    233         pri = cpu_priority_high();
     231        ipl_t ipl;
     232
     233        ipl = interrupts_disable();
    234234        spinlock_lock(&wq->lock);
    235235
    … …  
    237237
    238238        spinlock_unlock(&wq->lock);     
    239         cpu_priority_restore(pri);     
     239        interrupts_restore(ipl);       
    240240}
    241241

  • src/time/clock.c

    r75eacab r22f7769  
    4545 *
    4646 * Clock routine executed from clock interrupt handler
    47  * (assuming cpu_priority_high()). Runs expired timeouts
     47 * (assuming interrupts_disable()'d). Runs expired timeouts
    4848 * and preemptive scheduling.
    4949 *

  • src/time/delay.c

    r75eacab r22f7769  
    4343void delay(__u32 usec)
    4444{
    45         pri_t pri;
     45        ipl_t ipl;
    4646       
    47         /* The delay loop is calibrated for each and every
    48            CPU in the system. Therefore it is necessary to
    49            cpu_priority_high() before calling the asm_delay_loop(). */
    50         pri = cpu_priority_high();
     47        /*
     48         * The delay loop is calibrated for each and every
     49         * CPU in the system. Therefore it is necessary to
     50         * call interrupts_disable() before calling the
     51         * asm_delay_loop().
     52         */
     53        ipl = interrupts_disable();
    5154        asm_delay_loop(usec * CPU->delay_loop_const);
    52         cpu_priority_restore(pri);
     55        interrupts_restore(ipl);
    5356}

  • src/time/timeout.c

    r75eacab r22f7769  
    101101        timeout_t *hlp;
    102102        link_t *l, *m;
    103         pri_t pri;
     103        ipl_t ipl;
    104104        __u64 sum;
    105105
    106         pri = cpu_priority_high();
     106        ipl = interrupts_disable();
    107107        spinlock_lock(&CPU->timeoutlock);
    108108        spinlock_lock(&t->lock);
    … …  
    153153        spinlock_unlock(&t->lock);
    154154        spinlock_unlock(&CPU->timeoutlock);
    155         cpu_priority_restore(pri);
     155        interrupts_restore(ipl);
    156156}
    157157
    … …  
    169169        timeout_t *hlp;
    170170        link_t *l;
    171         pri_t pri;
     171        ipl_t ipl;
    172172
    173173grab_locks:
    174         pri = cpu_priority_high();
     174        ipl = interrupts_disable();
    175175        spinlock_lock(&t->lock);
    176176        if (!t->cpu) {
    177177                spinlock_unlock(&t->lock);
    178                 cpu_priority_restore(pri);
     178                interrupts_restore(ipl);
    179179                return false;
    180180        }
    181181        if (!spinlock_trylock(&t->cpu->timeoutlock)) {
    182182                spinlock_unlock(&t->lock);
    183                 cpu_priority_restore(pri);             
     183                interrupts_restore(ipl);               
    184184                goto grab_locks;
    185185        }
    … …  
    204204        spinlock_unlock(&t->lock);
    205205
    206         cpu_priority_restore(pri);
     206        interrupts_restore(ipl);
    207207        return true;
    208208}

  • test/synch/rwlock4/test.c

    r75eacab r22f7769  
    6161{
    6262        __u32 rc;
    63         pri_t pri;
     63        ipl_t ipl;
    6464
    6565        spinlock_lock(&lock);   

  • tools/amd64/gencontext.c

    r75eacab r22f7769  
    33
    44typedef long long __u64;
    5 typedef __u64 pri_t;
     5typedef __u64 ipl_t;
    66
    77#define __amd64_TYPES_H__
    … …  
    3232        fprintf(f,"#define OFFSET_R14 0x%x\n",((int)&pctx->r14) - (int )pctx);
    3333        fprintf(f,"#define OFFSET_R15 0x%x\n",((int)&pctx->r15) - (int )pctx);
    34         fprintf(f,"#define OFFSET_PRI 0x%x\n",((int)&pctx->pri) - (int )pctx);
     34        fprintf(f,"#define OFFSET_IPL 0x%x\n",((int)&pctx->ipl) - (int )pctx);
    3535        fclose(f);
    3636

  • tools/mips32/gencontext.c

    r75eacab r22f7769  
    33
    44typedef unsigned int __u32;
    5 typedef __u32 pri_t;
     5typedef __u32 ipl_t;
    66
    77#define __mips32_TYPES_H__
Note: See TracChangeset for help on using the changeset viewer.