Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/mm/frame.c

    r05411e8 rda1bafb  
    6666 * available.
    6767 */
    68 mutex_t mem_avail_mtx;
    69 condvar_t mem_avail_cv;
    70 size_t mem_avail_req = 0;  /**< Number of frames requested. */
    71 size_t mem_avail_gen = 0;  /**< Generation counter. */
     68static mutex_t mem_avail_mtx;
     69static condvar_t mem_avail_cv;
     70static size_t mem_avail_req = 0;  /**< Number of frames requested. */
     71static size_t mem_avail_gen = 0;  /**< Generation counter. */
    7272
    7373/********************/
    … …  
    171171        return total;
    172172}
    173 #endif
     173#endif /* CONFIG_DEBUG */
    174174
    175175/** Find a zone with a given frames.
    … …  
    199199                if (i >= zones.count)
    200200                        i = 0;
     201               
    201202        } while (i != hint);
    202203       
    … …  
    242243                if (i >= zones.count)
    243244                        i = 0;
     245               
    244246        } while (i != hint);
    245247       
    … …  
    296298                index = (frame_index(zone, frame)) +
    297299                    (1 << frame->buddy_order);
    298         } else {        /* is_right */
     300        } else {  /* is_right */
    299301                index = (frame_index(zone, frame)) -
    300302                    (1 << frame->buddy_order);
    … …  
    673675bool zone_merge(size_t z1, size_t z2)
    674676{
    675         ipl_t ipl = interrupts_disable();
    676         spinlock_lock(&zones.lock);
     677        irq_spinlock_lock(&zones.lock, true);
    677678       
    678679        bool ret = true;
    … …  
    744745       
    745746errout:
    746         spinlock_unlock(&zones.lock);
    747         interrupts_restore(ipl);
     747        irq_spinlock_unlock(&zones.lock, true);
    748748       
    749749        return ret;
    … …  
    777777 *
    778778 */
    779 static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, size_t count, zone_flags_t flags)
     779static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start,
     780    size_t count, zone_flags_t flags)
    780781{
    781782        zone->base = start;
    … …  
    841842 *
    842843 */
    843 size_t zone_create(pfn_t start, size_t count, pfn_t confframe, zone_flags_t flags)
    844 {
    845         ipl_t ipl = interrupts_disable();
    846         spinlock_lock(&zones.lock);
     844size_t zone_create(pfn_t start, size_t count, pfn_t confframe,
     845    zone_flags_t flags)
     846{
     847        irq_spinlock_lock(&zones.lock, true);
    847848       
    848849        if (zone_flags_available(flags)) {  /* Create available zone */
    … …  
    889890                size_t znum = zones_insert_zone(start, count);
    890891                if (znum == (size_t) -1) {
    891                         spinlock_unlock(&zones.lock);
    892                         interrupts_restore(ipl);
     892                        irq_spinlock_unlock(&zones.lock, true);
    893893                        return (size_t) -1;
    894894                }
    … …  
    905905                }
    906906               
    907                 spinlock_unlock(&zones.lock);
    908                 interrupts_restore(ipl);
     907                irq_spinlock_unlock(&zones.lock, true);
    909908               
    910909                return znum;
    … …  
    914913        size_t znum = zones_insert_zone(start, count);
    915914        if (znum == (size_t) -1) {
    916                 spinlock_unlock(&zones.lock);
    917                 interrupts_restore(ipl);
     915                irq_spinlock_unlock(&zones.lock, true);
    918916                return (size_t) -1;
    919917        }
    920918        zone_construct(&zones.info[znum], NULL, start, count, flags);
    921919       
    922         spinlock_unlock(&zones.lock);
    923         interrupts_restore(ipl);
     920        irq_spinlock_unlock(&zones.lock, true);
    924921       
    925922        return znum;
    … …  
    933930void frame_set_parent(pfn_t pfn, void *data, size_t hint)
    934931{
    935         ipl_t ipl = interrupts_disable();
    936         spinlock_lock(&zones.lock);
     932        irq_spinlock_lock(&zones.lock, true);
    937933       
    938934        size_t znum = find_zone(pfn, 1, hint);
    … …  
    943939            pfn - zones.info[znum].base)->parent = data;
    944940       
    945         spinlock_unlock(&zones.lock);
    946         interrupts_restore(ipl);
     941        irq_spinlock_unlock(&zones.lock, true);
    947942}
    948943
    949944void *frame_get_parent(pfn_t pfn, size_t hint)
    950945{
    951         ipl_t ipl = interrupts_disable();
    952         spinlock_lock(&zones.lock);
     946        irq_spinlock_lock(&zones.lock, true);
    953947       
    954948        size_t znum = find_zone(pfn, 1, hint);
    … …  
    959953            pfn - zones.info[znum].base)->parent;
    960954       
    961         spinlock_unlock(&zones.lock);
    962         interrupts_restore(ipl);
     955        irq_spinlock_unlock(&zones.lock, true);
    963956       
    964957        return res;
    … …  
    977970{
    978971        size_t size = ((size_t) 1) << order;
    979         ipl_t ipl;
    980972        size_t hint = pzone ? (*pzone) : 0;
    981973       
    982974loop:
    983         ipl = interrupts_disable();
    984         spinlock_lock(&zones.lock);
     975        irq_spinlock_lock(&zones.lock, true);
    985976       
    986977        /*
    … …  
    993984           if it does not help, reclaim all */
    994985        if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
    995                 spinlock_unlock(&zones.lock);
    996                 interrupts_restore(ipl);
    997                
     986                irq_spinlock_unlock(&zones.lock, true);
    998987                size_t freed = slab_reclaim(0);
    999                
    1000                 ipl = interrupts_disable();
    1001                 spinlock_lock(&zones.lock);
     988                irq_spinlock_lock(&zones.lock, true);
    1002989               
    1003990                if (freed > 0)
    … …  
    1006993               
    1007994                if (znum == (size_t) -1) {
    1008                         spinlock_unlock(&zones.lock);
    1009                         interrupts_restore(ipl);
    1010                        
     995                        irq_spinlock_unlock(&zones.lock, true);
    1011996                        freed = slab_reclaim(SLAB_RECLAIM_ALL);
    1012                        
    1013                         ipl = interrupts_disable();
    1014                         spinlock_lock(&zones.lock);
     997                        irq_spinlock_lock(&zones.lock, true);
    1015998                       
    1016999                        if (freed > 0)
    … …  
    10221005        if (znum == (size_t) -1) {
    10231006                if (flags & FRAME_ATOMIC) {
    1024                         spinlock_unlock(&zones.lock);
    1025                         interrupts_restore(ipl);
     1007                        irq_spinlock_unlock(&zones.lock, true);
    10261008                        return NULL;
    10271009                }
    … …  
    10311013#endif
    10321014               
    1033                 spinlock_unlock(&zones.lock);
    1034                 interrupts_restore(ipl);
    1035 
     1015                irq_spinlock_unlock(&zones.lock, true);
     1016               
    10361017                if (!THREAD)
    10371018                        panic("Cannot wait for memory to become available.");
    … …  
    10691050            + zones.info[znum].base;
    10701051       
    1071         spinlock_unlock(&zones.lock);
    1072         interrupts_restore(ipl);
     1052        irq_spinlock_unlock(&zones.lock, true);
    10731053       
    10741054        if (pzone)
    … …  
    10921072void frame_free(uintptr_t frame)
    10931073{
    1094         ipl_t ipl = interrupts_disable();
    1095         spinlock_lock(&zones.lock);
     1074        irq_spinlock_lock(&zones.lock, true);
    10961075       
    10971076        /*
    … …  
    11051084        zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
    11061085       
    1107         spinlock_unlock(&zones.lock);
    1108         interrupts_restore(ipl);
     1086        irq_spinlock_unlock(&zones.lock, true);
    11091087       
    11101088        /*
    … …  
    11321110void frame_reference_add(pfn_t pfn)
    11331111{
    1134         ipl_t ipl = interrupts_disable();
    1135         spinlock_lock(&zones.lock);
     1112        irq_spinlock_lock(&zones.lock, true);
    11361113       
    11371114        /*
    … …  
    11441121        zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
    11451122       
    1146         spinlock_unlock(&zones.lock);
    1147         interrupts_restore(ipl);
    1148 }
    1149 
    1150 /** Mark given range unavailable in frame zones. */
     1123        irq_spinlock_unlock(&zones.lock, true);
     1124}
     1125
     1126/** Mark given range unavailable in frame zones.
     1127 *
     1128 */
    11511129void frame_mark_unavailable(pfn_t start, size_t count)
    11521130{
    1153         ipl_t ipl = interrupts_disable();
    1154         spinlock_lock(&zones.lock);
     1131        irq_spinlock_lock(&zones.lock, true);
    11551132       
    11561133        size_t i;
    … …  
    11641141        }
    11651142       
    1166         spinlock_unlock(&zones.lock);
    1167         interrupts_restore(ipl);
    1168 }
    1169 
    1170 /** Initialize physical memory management. */
     1143        irq_spinlock_unlock(&zones.lock, true);
     1144}
     1145
     1146/** Initialize physical memory management.
     1147 *
     1148 */
    11711149void frame_init(void)
    11721150{
    11731151        if (config.cpu_active == 1) {
    11741152                zones.count = 0;
    1175                 spinlock_initialize(&zones.lock, "zones.lock");
     1153                irq_spinlock_initialize(&zones.lock, "frame.zones.lock");
    11761154                mutex_initialize(&mem_avail_mtx, MUTEX_ACTIVE);
    11771155                condvar_initialize(&mem_avail_cv);
    … …  
    12041182}
    12051183
    1206 /** Return total size of all zones. */
     1184/** Return total size of all zones.
     1185 *
     1186 */
    12071187uint64_t zones_total_size(void)
    12081188{
    1209         ipl_t ipl = interrupts_disable();
    1210         spinlock_lock(&zones.lock);
     1189        irq_spinlock_lock(&zones.lock, true);
    12111190       
    12121191        uint64_t total = 0;
    … …  
    12151194                total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
    12161195       
    1217         spinlock_unlock(&zones.lock);
    1218         interrupts_restore(ipl);
     1196        irq_spinlock_unlock(&zones.lock, true);
    12191197       
    12201198        return total;
    … …  
    12291207        ASSERT(free != NULL);
    12301208       
    1231         ipl_t ipl = interrupts_disable();
    1232         spinlock_lock(&zones.lock);
     1209        irq_spinlock_lock(&zones.lock, true);
    12331210       
    12341211        *total = 0;
    … …  
    12481225        }
    12491226       
    1250         spinlock_unlock(&zones.lock);
    1251         interrupts_restore(ipl);
    1252 }
    1253 
    1254 /** Prints list of zones. */
     1227        irq_spinlock_unlock(&zones.lock, true);
     1228}
     1229
     1230/** Prints list of zones.
     1231 *
     1232 */
    12551233void zones_print_list(void)
    12561234{
    … …  
    12781256        size_t i;
    12791257        for (i = 0;; i++) {
    1280                 ipl_t ipl = interrupts_disable();
    1281                 spinlock_lock(&zones.lock);
     1258                irq_spinlock_lock(&zones.lock, true);
    12821259               
    12831260                if (i >= zones.count) {
    1284                         spinlock_unlock(&zones.lock);
    1285                         interrupts_restore(ipl);
     1261                        irq_spinlock_unlock(&zones.lock, true);
    12861262                        break;
    12871263                }
    … …  
    12931269                size_t busy_count = zones.info[i].busy_count;
    12941270               
    1295                 spinlock_unlock(&zones.lock);
    1296                 interrupts_restore(ipl);
     1271                irq_spinlock_unlock(&zones.lock, true);
    12971272               
    12981273                bool available = zone_flags_available(flags);
    … …  
    13281303void zone_print_one(size_t num)
    13291304{
    1330         ipl_t ipl = interrupts_disable();
    1331         spinlock_lock(&zones.lock);
     1305        irq_spinlock_lock(&zones.lock, true);
    13321306        size_t znum = (size_t) -1;
    13331307       
    … …  
    13411315       
    13421316        if (znum == (size_t) -1) {
    1343                 spinlock_unlock(&zones.lock);
    1344                 interrupts_restore(ipl);
     1317                irq_spinlock_unlock(&zones.lock, true);
    13451318                printf("Zone not found.\n");
    13461319                return;
    … …  
    13531326        size_t busy_count = zones.info[i].busy_count;
    13541327       
    1355         spinlock_unlock(&zones.lock);
    1356         interrupts_restore(ipl);
     1328        irq_spinlock_unlock(&zones.lock, true);
    13571329       
    13581330        bool available = zone_flags_available(flags);
Note: See TracChangeset for help on using the changeset viewer.