Changeset 1068f6a in mainline for generic/src/mm/as.c


Ignore:
Timestamp:
2006-05-20T19:32:06Z (19 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c1982e45
Parents:
9ea6cc5
Message:

Turn address space lock, address space area lock and
page_ht_lock into mutexes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • generic/src/mm/as.c

    r9ea6cc5 r1068f6a  
    5555#include <arch/mm/asid.h>
    5656#include <synch/spinlock.h>
     57#include <synch/mutex.h>
    5758#include <adt/list.h>
    5859#include <adt/btree.h>
    … …  
    7576as_operations_t *as_operations = NULL;
    7677
    77 /** Address space lock. It protects inactive_as_with_asid_head. */
     78/** Address space lock. It protects inactive_as_with_asid_head. Must be acquired before as_t mutex. */
    7879SPINLOCK_INITIALIZE(as_lock);
    7980
    … …  
    111112        as = (as_t *) malloc(sizeof(as_t), 0);
    112113        link_initialize(&as->inactive_as_with_asid_link);
    113         spinlock_initialize(&as->lock, "as_lock");
     114        mutex_initialize(&as->lock);
    114115        btree_create(&as->as_area_btree);
    115116       
    … …  
    163164       
    164165        ipl = interrupts_disable();
    165         spinlock_lock(&as->lock);
     166        mutex_lock(&as->lock);
    166167       
    167168        if (!check_area_conflicts(as, base, size, NULL)) {
    168                 spinlock_unlock(&as->lock);
     169                mutex_unlock(&as->lock);
    169170                interrupts_restore(ipl);
    170171                return NULL;
    … …  
    173174        a = (as_area_t *) malloc(sizeof(as_area_t), 0);
    174175
    175         spinlock_initialize(&a->lock, "as_area_lock");
     176        mutex_initialize(&a->lock);
    176177       
    177178        a->flags = flags;
    … …  
    182183        btree_insert(&as->as_area_btree, base, (void *) a, NULL);
    183184
    184         spinlock_unlock(&as->lock);
     185        mutex_unlock(&as->lock);
    185186        interrupts_restore(ipl);
    186187
    … …  
    204205       
    205206        ipl = interrupts_disable();
    206         spinlock_lock(&as->lock);
     207        mutex_lock(&as->lock);
    207208       
    208209        /*
    … …  
    211212        area = find_area_and_lock(as, address);
    212213        if (!area) {
    213                 spinlock_unlock(&as->lock);
     214                mutex_unlock(&as->lock);
    214215                interrupts_restore(ipl);
    215216                return ENOENT;
    … …  
    221222                 * with memory mapped devices is not supported.
    222223                 */
    223                 spinlock_unlock(&area->lock);
    224                 spinlock_unlock(&as->lock);
     224                mutex_unlock(&area->lock);
     225                mutex_unlock(&as->lock);
    225226                interrupts_restore(ipl);
    226227                return ENOTSUP;
    … …  
    232233                 * Zero size address space areas are not allowed.
    233234                 */
    234                 spinlock_unlock(&area->lock);
    235                 spinlock_unlock(&as->lock);
     235                mutex_unlock(&area->lock);
     236                mutex_unlock(&as->lock);
    236237                interrupts_restore(ipl);
    237238                return EPERM;
    … …  
    279280                 */
    280281                if (!check_area_conflicts(as, address, pages * PAGE_SIZE, area)) {
    281                         spinlock_unlock(&area->lock);
    282                         spinlock_unlock(&as->lock);             
     282                        mutex_unlock(&area->lock);
     283                        mutex_unlock(&as->lock);               
    283284                        interrupts_restore(ipl);
    284285                        return EADDRNOTAVAIL;
    … …  
    288289        area->pages = pages;
    289290       
    290         spinlock_unlock(&area->lock);
    291         spinlock_unlock(&as->lock);
     291        mutex_unlock(&area->lock);
     292        mutex_unlock(&as->lock);
    292293        interrupts_restore(ipl);
    293294
    … …  
    310311
    311312        ipl = interrupts_disable();
    312         spinlock_lock(&as->lock);
     313        mutex_lock(&as->lock);
    313314
    314315        area = find_area_and_lock(as, address);
    315316        if (!area) {
    316                 spinlock_unlock(&as->lock);
     317                mutex_unlock(&as->lock);
    317318                interrupts_restore(ipl);
    318319                return ENOENT;
    … …  
    351352
    352353        area->attributes |= AS_AREA_ATTR_PARTIAL;
    353         spinlock_unlock(&area->lock);
     354        mutex_unlock(&area->lock);
    354355
    355356        /*
    … …  
    360361        free(area);
    361362       
    362         spinlock_unlock(&AS->lock);
     363        mutex_unlock(&AS->lock);
    363364        interrupts_restore(ipl);
    364365        return 0;
    … …  
    398399        src_as = src_task->as;
    399400       
    400         spinlock_lock(&src_as->lock);
     401        mutex_lock(&src_as->lock);
    401402        src_area = find_area_and_lock(src_as, src_base);
    402403        if (!src_area) {
    … …  
    405406                 */
    406407                spinlock_unlock(&src_task->lock);
    407                 spinlock_unlock(&src_as->lock);
     408                mutex_unlock(&src_as->lock);
    408409                interrupts_restore(ipl);
    409410                return ENOENT;
    … …  
    411412        src_size = src_area->pages * PAGE_SIZE;
    412413        src_flags = src_area->flags;
    413         spinlock_unlock(&src_area->lock);
    414         spinlock_unlock(&src_as->lock);
     414        mutex_unlock(&src_area->lock);
     415        mutex_unlock(&src_as->lock);
    415416
    416417
    … …  
    442443         */
    443444        if (AS < src_as) {
    444                 spinlock_lock(&AS->lock);
    445                 spinlock_lock(&src_as->lock);
     445                mutex_lock(&AS->lock);
     446                mutex_lock(&src_as->lock);
    446447        } else {
    447                 spinlock_lock(&AS->lock);
    448                 spinlock_lock(&src_as->lock);
     448                mutex_lock(&AS->lock);
     449                mutex_lock(&src_as->lock);
    449450        }
    450451       
    … …  
    476477         * attribute.
    477478         */     
    478         spinlock_lock(&dst_area->lock);
     479        mutex_lock(&dst_area->lock);
    479480        dst_area->attributes &= ~AS_AREA_ATTR_PARTIAL;
    480         spinlock_unlock(&dst_area->lock);
    481        
    482         spinlock_unlock(&AS->lock);
    483         spinlock_unlock(&src_as->lock);
     481        mutex_unlock(&dst_area->lock);
     482       
     483        mutex_unlock(&AS->lock);
     484        mutex_unlock(&src_as->lock);
    484485        interrupts_restore(ipl);
    485486       
    … …  
    512513        page_mapping_insert(as, page, frame, get_area_flags(area));
    513514       
    514         spinlock_unlock(&area->lock);
     515        mutex_unlock(&area->lock);
    515516        page_table_unlock(as, true);
    516517        interrupts_restore(ipl);
    … …  
    533534        __address frame;
    534535       
     536        if (!THREAD)
     537                return 0;
     538               
    535539        ASSERT(AS);
    536540
    537         spinlock_lock(&AS->lock);
     541        mutex_lock(&AS->lock);
    538542        area = find_area_and_lock(AS, page);   
    539543        if (!area) {
    … …  
    542546                 * Signal page fault to low-level handler.
    543547                 */
    544                 spinlock_unlock(&AS->lock);
     548                mutex_unlock(&AS->lock);
    545549                goto page_fault;
    546550        }
    … …  
    551555                 * Avoid possible race by returning error.
    552556                 */
    553                 spinlock_unlock(&area->lock);
    554                 spinlock_unlock(&AS->lock);
     557                mutex_unlock(&area->lock);
     558                mutex_unlock(&AS->lock);
    555559                goto page_fault;               
    556560        }
    … …  
    568572                if (PTE_PRESENT(pte)) {
    569573                        page_table_unlock(AS, false);
    570                         spinlock_unlock(&area->lock);
    571                         spinlock_unlock(&AS->lock);
     574                        mutex_unlock(&area->lock);
     575                        mutex_unlock(&AS->lock);
    572576                        return 1;
    573577                }
    … …  
    599603        page_table_unlock(AS, false);
    600604       
    601         spinlock_unlock(&area->lock);
    602         spinlock_unlock(&AS->lock);
     605        mutex_unlock(&area->lock);
     606        mutex_unlock(&AS->lock);
    603607        return AS_PF_OK;
    604608
    … …  
    622626/** Switch address spaces.
    623627 *
     628 * Note that this function cannot sleep as it is essentially a part of
     629 * the scheduling. Sleeping here would lead to deadlock on wakeup.
     630 *
    624631 * @param old Old address space or NULL.
    625632 * @param new New address space.
    … …  
    637644         */     
    638645        if (old) {
    639                 spinlock_lock(&old->lock);
     646                mutex_lock_active(&old->lock);
    640647                ASSERT(old->refcount);
    641648                if((--old->refcount == 0) && (old != AS_KERNEL)) {
    … …  
    649656                         list_append(&old->inactive_as_with_asid_link, &inactive_as_with_asid_head);
    650657                }
    651                 spinlock_unlock(&old->lock);
     658                mutex_unlock(&old->lock);
    652659        }
    653660
    … …  
    655662         * Second, prepare the new address space.
    656663         */
    657         spinlock_lock(&new->lock);
     664        mutex_lock_active(&new->lock);
    658665        if ((new->refcount++ == 0) && (new != AS_KERNEL)) {
    659666                if (new->asid != ASID_INVALID)
    … …  
    663670        }
    664671        SET_PTL0_ADDRESS(new->page_table);
    665         spinlock_unlock(&new->lock);
     672        mutex_unlock(&new->lock);
    666673
    667674        if (needs_asid) {
    … …  
    673680               
    674681                asid = asid_get();
    675                 spinlock_lock(&new->lock);
     682                mutex_lock_active(&new->lock);
    676683                new->asid = asid;
    677                 spinlock_unlock(&new->lock);
     684                mutex_unlock(&new->lock);
    678685        }
    679686        spinlock_unlock(&as_lock);
    … …  
    799806        if (a) {
    800807                /* va is the base address of an address space area */
    801                 spinlock_lock(&a->lock);
     808                mutex_lock(&a->lock);
    802809                return a;
    803810        }
    … …  
    812819        for (i = 0; i < leaf->keys; i++) {
    813820                a = (as_area_t *) leaf->value[i];
    814                 spinlock_lock(&a->lock);
     821                mutex_lock(&a->lock);
    815822                if ((a->base <= va) && (va < a->base + a->pages * PAGE_SIZE)) {
    816823                        return a;
    817824                }
    818                 spinlock_unlock(&a->lock);
     825                mutex_unlock(&a->lock);
    819826        }
    820827
    … …  
    825832        if ((lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf))) {
    826833                a = (as_area_t *) lnode->value[lnode->keys - 1];
    827                 spinlock_lock(&a->lock);
     834                mutex_lock(&a->lock);
    828835                if (va < a->base + a->pages * PAGE_SIZE) {
    829836                        return a;
    830837                }
    831                 spinlock_unlock(&a->lock);
     838                mutex_unlock(&a->lock);
    832839        }
    833840
    … …  
    874881        if ((node = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf))) {
    875882                a = (as_area_t *) node->value[node->keys - 1];
    876                 spinlock_lock(&a->lock);
     883                mutex_lock(&a->lock);
    877884                if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
    878                         spinlock_unlock(&a->lock);
     885                        mutex_unlock(&a->lock);
    879886                        return false;
    880887                }
    881                 spinlock_unlock(&a->lock);
     888                mutex_unlock(&a->lock);
    882889        }
    883890        if ((node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf))) {
    884891                a = (as_area_t *) node->value[0];
    885                 spinlock_lock(&a->lock);
     892                mutex_lock(&a->lock);
    886893                if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
    887                         spinlock_unlock(&a->lock);
     894                        mutex_unlock(&a->lock);
    888895                        return false;
    889896                }
    890                 spinlock_unlock(&a->lock);
     897                mutex_unlock(&a->lock);
    891898        }
    892899       
    … …  
    898905                        continue;
    899906       
    900                 spinlock_lock(&a->lock);
     907                mutex_lock(&a->lock);
    901908                if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
    902                         spinlock_unlock(&a->lock);
     909                        mutex_unlock(&a->lock);
    903910                        return false;
    904911                }
    905                 spinlock_unlock(&a->lock);
     912                mutex_unlock(&a->lock);
    906913        }
    907914
    … …  
    918925}
    919926
    920 /** Return size of address space of current task pointed to by base */
     927/** Return size of the address space area with given base. */
    921928size_t as_get_size(__address base)
    922929{
    … …  
    929936        if (src_area){
    930937                size = src_area->pages * PAGE_SIZE;
    931                 spinlock_unlock(&src_area->lock);
     938                mutex_unlock(&src_area->lock);
    932939        } else {
    933940                size = 0;
Note: See TracChangeset for help on using the changeset viewer.