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

Changeset fdaad75d in mainline


Ignore:
Timestamp:
2010-06-22T02:18:35Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
master
Children:
ee42e43
Parents:
4ca26c9b
Message:

Do not disable interrupts unnecessarily.

Location:
kernel
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • kernel/genarch/src/mm/as_pt.c

    r4ca26c9b rfdaad75d  
    8484                 */
    8585               
    86                 ipl_t ipl = interrupts_disable();
    8786                mutex_lock(&AS_KERNEL->lock);
    8887               
     
    10099               
    101100                mutex_unlock(&AS_KERNEL->lock);
    102                 interrupts_restore(ipl);
    103101        }
    104102       
  • kernel/genarch/src/mm/page_ht.c

    r4ca26c9b rfdaad75d  
    185185        };
    186186
    187         ASSERT(interrupts_disabled());
    188187        ASSERT(page_table_locked(as));
    189188       
     
    226225        };
    227226
    228         ASSERT(interrupts_disabled());
    229227        ASSERT(page_table_locked(as));
    230228       
     
    254252        };
    255253
    256         ASSERT(interrupts_disabled());
    257254        ASSERT(page_table_locked(as));
    258255       
  • kernel/genarch/src/mm/page_pt.c

    r4ca26c9b rfdaad75d  
    7272        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
    7373
    74         ASSERT(interrupts_disabled());
    7574        ASSERT(page_table_locked(as));
    7675       
     
    120119void pt_mapping_remove(as_t *as, uintptr_t page)
    121120{
    122         ASSERT(interrupts_disabled());
    123121        ASSERT(page_table_locked(as));
    124122
     
    251249pte_t *pt_mapping_find(as_t *as, uintptr_t page)
    252250{
    253         ASSERT(interrupts_disabled());
    254251        ASSERT(page_table_locked(as));
    255252
  • kernel/generic/src/mm/as.c

    r4ca26c9b rfdaad75d  
    239239       
    240240        spinlock_unlock(&asidlock);
     241        interrupts_restore(ipl);
     242
    241243       
    242244        /*
     
    265267        page_table_destroy(NULL);
    266268#endif
    267        
    268         interrupts_restore(ipl);
    269269       
    270270        slab_free(as_slab, as);
     
    327327                return NULL;
    328328       
    329         ipl_t ipl = interrupts_disable();
    330329        mutex_lock(&as->lock);
    331330       
    332331        if (!check_area_conflicts(as, base, size, NULL)) {
    333332                mutex_unlock(&as->lock);
    334                 interrupts_restore(ipl);
    335333                return NULL;
    336334        }
     
    357355       
    358356        mutex_unlock(&as->lock);
    359         interrupts_restore(ipl);
    360357       
    361358        return area;
     
    376373int as_area_resize(as_t *as, uintptr_t address, size_t size, unsigned int flags)
    377374{
    378         ipl_t ipl = interrupts_disable();
    379375        mutex_lock(&as->lock);
    380376       
     
    386382        if (!area) {
    387383                mutex_unlock(&as->lock);
    388                 interrupts_restore(ipl);
    389384                return ENOENT;
    390385        }
     
    398393                mutex_unlock(&area->lock);
    399394                mutex_unlock(&as->lock);
    400                 interrupts_restore(ipl);
    401395                return ENOTSUP;
    402396        }
     
    410404                mutex_unlock(&area->lock);
    411405                mutex_unlock(&as->lock);
    412                 interrupts_restore(ipl);
    413406                return ENOTSUP;
    414407        }
     
    422415                mutex_unlock(&area->lock);
    423416                mutex_unlock(&as->lock);
    424                 interrupts_restore(ipl);
    425417                return EPERM;
    426418        }
     
    549541                        mutex_unlock(&area->lock);
    550542                        mutex_unlock(&as->lock);
    551                         interrupts_restore(ipl);
    552543                        return EADDRNOTAVAIL;
    553544                }
     
    558549        mutex_unlock(&area->lock);
    559550        mutex_unlock(&as->lock);
    560         interrupts_restore(ipl);
    561551       
    562552        return 0;
     
    573563int as_area_destroy(as_t *as, uintptr_t address)
    574564{
    575         ipl_t ipl = interrupts_disable();
    576565        mutex_lock(&as->lock);
    577566       
     
    579568        if (!area) {
    580569                mutex_unlock(&as->lock);
    581                 interrupts_restore(ipl);
    582570                return ENOENT;
    583571        }
     
    659647       
    660648        mutex_unlock(&as->lock);
    661         interrupts_restore(ipl);
    662649        return 0;
    663650}
     
    690677    as_t *dst_as, uintptr_t dst_base, unsigned int dst_flags_mask)
    691678{
    692         ipl_t ipl = interrupts_disable();
    693679        mutex_lock(&src_as->lock);
    694680        as_area_t *src_area = find_area_and_lock(src_as, src_base);
     
    699685                 */
    700686                mutex_unlock(&src_as->lock);
    701                 interrupts_restore(ipl);
    702687                return ENOENT;
    703688        }
     
    711696                mutex_unlock(&src_area->lock);
    712697                mutex_unlock(&src_as->lock);
    713                 interrupts_restore(ipl);
    714698                return ENOTSUP;
    715699        }
     
    728712                mutex_unlock(&src_area->lock);
    729713                mutex_unlock(&src_as->lock);
    730                 interrupts_restore(ipl);
    731714                return EPERM;
    732715        }
     
    777760                sh_info_remove_reference(sh_info);
    778761               
    779                 interrupts_restore(ipl);
    780762                return ENOMEM;
    781763        }
     
    794776        mutex_unlock(&dst_as->lock);
    795777       
    796         interrupts_restore(ipl);
    797        
    798778        return 0;
    799779}
     
    816796        };
    817797
    818         ASSERT(interrupts_disabled());
    819798        ASSERT(mutex_locked(&area->lock));
    820799       
     
    844823        unsigned int page_flags = area_flags_to_page_flags(flags);
    845824       
    846         ipl_t ipl = interrupts_disable();
    847825        mutex_lock(&as->lock);
    848826       
     
    850828        if (!area) {
    851829                mutex_unlock(&as->lock);
    852                 interrupts_restore(ipl);
    853830                return ENOENT;
    854831        }
     
    859836                mutex_unlock(&area->lock);
    860837                mutex_unlock(&as->lock);
    861                 interrupts_restore(ipl);
    862838                return ENOTSUP;
    863839        }
     
    978954        mutex_unlock(&area->lock);
    979955        mutex_unlock(&as->lock);
    980         interrupts_restore(ipl);
    981956       
    982957        return 0;
     
    12191194unsigned int as_area_get_flags(as_area_t *area)
    12201195{
    1221         ASSERT(interrupts_disabled());
    12221196        ASSERT(mutex_locked(&area->lock));
    12231197
     
    13211295as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
    13221296{
    1323         ASSERT(interrupts_disabled());
    13241297        ASSERT(mutex_locked(&as->lock));
    13251298
     
    13861359    as_area_t *avoid_area)
    13871360{
    1388         ASSERT(interrupts_disabled());
    13891361        ASSERT(mutex_locked(&as->lock));
    13901362
     
    14861458        size_t size;
    14871459       
    1488         ipl_t ipl = interrupts_disable();
    14891460        page_table_lock(AS, true);
    14901461        as_area_t *src_area = find_area_and_lock(AS, base);
     
    14971468       
    14981469        page_table_unlock(AS, true);
    1499         interrupts_restore(ipl);
    15001470        return size;
    15011471}
     
    20702040void as_get_area_info(as_t *as, as_area_info_t **obuf, size_t *osize)
    20712041{
    2072         ipl_t ipl = interrupts_disable();
    20732042        mutex_lock(&as->lock);
    20742043       
     
    21142083       
    21152084        mutex_unlock(&as->lock);
    2116         interrupts_restore(ipl);
    21172085       
    21182086        *obuf = info;
     
    21272095void as_print(as_t *as)
    21282096{
    2129         ipl_t ipl = interrupts_disable();
    21302097        mutex_lock(&as->lock);
    21312098       
     
    21502117       
    21512118        mutex_unlock(&as->lock);
    2152         interrupts_restore(ipl);
    21532119}
    21542120
  • kernel/generic/src/mm/page.c

    r4ca26c9b rfdaad75d  
    118118    unsigned int flags)
    119119{
    120         ASSERT(interrupts_disabled());
    121120        ASSERT(page_table_locked(as));
    122121       
     
    142141void page_mapping_remove(as_t *as, uintptr_t page)
    143142{
    144         ASSERT(interrupts_disabled());
    145143        ASSERT(page_table_locked(as));
    146144       
     
    167165pte_t *page_mapping_find(as_t *as, uintptr_t page)
    168166{
    169         ASSERT(interrupts_disabled());
    170167        ASSERT(page_table_locked(as));
    171168       
  • kernel/generic/src/mm/tlb.c

    r4ca26c9b rfdaad75d  
    7373 * to all other processors.
    7474 *
    75  * This function must be called with interrupts disabled.
    76  *
    7775 * @param type Type describing scope of shootdown.
    7876 * @param asid Address space, if required by type.
     
    8583{
    8684        CPU->tlb_active = false;
    87         irq_spinlock_lock(&tlblock, false);
     85        irq_spinlock_lock(&tlblock, true);
    8886       
    8987        size_t i;
     
    132130void tlb_shootdown_finalize(void)
    133131{
    134         irq_spinlock_unlock(&tlblock, false);
     132        irq_spinlock_unlock(&tlblock, true);
    135133        CPU->tlb_active = true;
    136134}
  • kernel/generic/src/synch/futex.c

    r4ca26c9b rfdaad75d  
    113113        uintptr_t paddr;
    114114        pte_t *t;
    115         ipl_t ipl;
    116115        int rc;
    117116       
    118         ipl = interrupts_disable();
    119 
    120117        /*
    121118         * Find physical address of futex counter.
     
    125122        if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
    126123                page_table_unlock(AS, true);
    127                 interrupts_restore(ipl);
    128124                return (unative_t) ENOENT;
    129125        }
     
    131127        page_table_unlock(AS, true);
    132128       
    133         interrupts_restore(ipl);       
    134 
    135129        futex = futex_find(paddr);
    136130
Note: See TracChangeset for help on using the changeset viewer.