Changeset 5df1963 in mainline


Ignore:
Timestamp:
2013-09-10T21:47:25Z (11 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0511549
Parents:
a501e22c
Message:

bitmap frame allocator does not keep track of the size of the allocated frame blocks
to avoid memory leaks the number of allocated frames needs to be passed explicitly during deallocation

Location:
kernel
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • kernel/genarch/src/mm/as_pt.c

    ra501e22c r5df1963  
    113113void ptl0_destroy(pte_t *page_table)
    114114{
    115         frame_free((uintptr_t) page_table);
     115        frame_free((uintptr_t) page_table, PTL0_FRAMES);
    116116}
    117117

  • kernel/genarch/src/mm/page_pt.c

    ra501e22c r5df1963  
    219219                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
    220220#endif
    221                 frame_free(KA2PA((uintptr_t) ptl3));
     221                frame_free(KA2PA((uintptr_t) ptl3), PTL3_FRAMES);
    222222        } else {
    223223                /*
    … …  
    253253                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
    254254#endif
    255                 frame_free(KA2PA((uintptr_t) ptl2));
     255                frame_free(KA2PA((uintptr_t) ptl2), PTL2_FRAMES);
    256256        } else {
    257257                /*
    … …  
    284284
    285285                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
    286                 frame_free(KA2PA((uintptr_t) ptl1));
     286                frame_free(KA2PA((uintptr_t) ptl1), PTL1_FRAMES);
    287287        }
    288288#endif /* PTL1_ENTRIES != 0 */

  • kernel/generic/include/mm/frame.h

    ra501e22c r5df1963  
    134134extern uintptr_t frame_alloc(size_t, frame_flags_t, uintptr_t);
    135135extern uintptr_t frame_alloc_noreserve(size_t, frame_flags_t, uintptr_t);
    136 extern void frame_free_generic(uintptr_t, frame_flags_t);
    137 extern void frame_free(uintptr_t);
    138 extern void frame_free_noreserve(uintptr_t);
     136extern void frame_free_generic(uintptr_t, size_t, frame_flags_t);
     137extern void frame_free(uintptr_t, size_t);
     138extern void frame_free_noreserve(uintptr_t, size_t);
    139139extern void frame_reference_add(pfn_t);
    140140extern size_t frame_total_free_get(void);

  • kernel/generic/src/ddi/ddi.c

    ra501e22c r5df1963  
    339339        if (!as_area_create(TASK->as, map_flags, size,
    340340            AS_AREA_ATTR_NONE, &phys_backend, &backend_data, virt, bound)) {
    341                 frame_free_noreserve(*phys);
     341                frame_free_noreserve(*phys, frames);
    342342                return ENOMEM;
    343343        }

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

    ra501e22c r5df1963  
    907907                       
    908908                        for (i = 0; i < node->keys; i++)
    909                                 frame_free((uintptr_t) node->value[i]);
     909                                frame_free((uintptr_t) node->value[i], 1);
    910910                }
    911911               

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

    ra501e22c r5df1963  
    294294                 * the normal unreserving frame_free().
    295295                 */
    296                 frame_free(frame);
     296                frame_free(frame, 1);
    297297        } else {
    298298                /*
    … …  
    301301                 * manipulate the reserve or it would be given back twice.
    302302                 */
    303                 frame_free_noreserve(frame);
     303                frame_free_noreserve(frame, 1);
    304304        }
    305305}

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

    ra501e22c r5df1963  
    429429                         * data.
    430430                         */
    431                         frame_free_noreserve(frame);
     431                        frame_free_noreserve(frame, 1);
    432432                }
    433433        } else {
    … …  
    437437                 * anonymous). In any case, a frame needs to be freed.
    438438                 */
    439                 frame_free_noreserve(frame);
     439                frame_free_noreserve(frame, 1);
    440440        }
    441441}

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

    ra501e22c r5df1963  
    348348       
    349349        frame_t *frame = zone_get_frame(zone, index);
    350         size_t size = 0;
    351350       
    352351        ASSERT(frame->refcount > 0);
    … …  
    359358                zone->busy_count--;
    360359               
    361                 size = FRAME_SIZE;
    362         }
    363        
    364         return size;
     360                return 1;
     361        }
     362       
     363        return 0;
    365364}
    366365
    … …  
    891890}
    892891
    893 /** Free a frame.
    894  *
    895  * Find respective frame structure for supplied physical frame address.
    896  * Decrement frame reference count. If it drops to zero, move the frame
    897  * structure to free list.
    898  *
    899  * @param frame Physical Address of of the frame to be freed.
     892/** Free frames of physical memory.
     893 *
     894 * Find respective frame structures for supplied physical frames.
     895 * Decrement each frame reference count. If it drops to zero, mark
     896 * the frames as available.
     897 *
     898 * @param start Physical Address of the first frame to be freed.
     899 * @param count Number of frames to free.
    900900 * @param flags Flags to control memory reservation.
    901901 *
    902902 */
    903 void frame_free_generic(uintptr_t frame, frame_flags_t flags)
    904 {
     903void frame_free_generic(uintptr_t start, size_t count, frame_flags_t flags)
     904{
     905        size_t freed = 0;
     906       
    905907        irq_spinlock_lock(&zones.lock, true);
    906908       
    907         /*
    908          * First, find host frame zone for addr.
    909          */
    910         pfn_t pfn = ADDR2PFN(frame);
    911         size_t znum = find_zone(pfn, 1, 0);
    912        
    913         ASSERT(znum != (size_t) -1);
    914        
    915         size_t size =
    916             zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
     909        for (size_t i = 0; i < count; i++) {
     910                /*
     911                 * First, find host frame zone for addr.
     912                 */
     913                pfn_t pfn = ADDR2PFN(start) + i;
     914                size_t znum = find_zone(pfn, 1, 0);
     915               
     916                ASSERT(znum != (size_t) -1);
     917               
     918                freed += zone_frame_free(&zones.info[znum],
     919                    pfn - zones.info[znum].base);
     920        }
    917921       
    918922        irq_spinlock_unlock(&zones.lock, true);
    … …  
    920924        /*
    921925         * Signal that some memory has been freed.
    922          */
    923        
    924        
    925         /*
    926          * Since the mem_avail_mtx is an active mutex, we need to disable interrupts
    927          * to prevent deadlock with TLB shootdown.
     926         * Since the mem_avail_mtx is an active mutex,
     927         * we need to disable interruptsto prevent deadlock
     928         * with TLB shootdown.
    928929         */
    929930       
    … …  
    932933       
    933934        if (mem_avail_req > 0)
    934                 mem_avail_req -= min(mem_avail_req, size);
     935                mem_avail_req -= min(mem_avail_req, freed);
    935936       
    936937        if (mem_avail_req == 0) {
    … …  
    943944       
    944945        if (!(flags & FRAME_NO_RESERVE))
    945                 reserve_free(size);
    946 }
    947 
    948 void frame_free(uintptr_t frame)
    949 {
    950         frame_free_generic(frame, 0);
    951 }
    952 
    953 void frame_free_noreserve(uintptr_t frame)
    954 {
    955         frame_free_generic(frame, FRAME_NO_RESERVE);
     946                reserve_free(freed);
     947}
     948
     949void frame_free(uintptr_t frame, size_t count)
     950{
     951        frame_free_generic(frame, count, 0);
     952}
     953
     954void frame_free_noreserve(uintptr_t frame, size_t count)
     955{
     956        frame_free_generic(frame, count, FRAME_NO_RESERVE);
    956957}
    957958

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

    ra501e22c r5df1963  
    193193                slab = slab_alloc(slab_extern_cache, flags);
    194194                if (!slab) {
    195                         frame_free(KA2PA(data));
     195                        frame_free(KA2PA(data), cache->frames);
    196196                        return NULL;
    197197                }
    … …  
    225225NO_TRACE static size_t slab_space_free(slab_cache_t *cache, slab_t *slab)
    226226{
    227         frame_free(KA2PA(slab->start));
     227        frame_free(KA2PA(slab->start), slab->cache->frames);
    228228        if (!(cache->flags & SLAB_CACHE_SLINSIDE))
    229229                slab_free(slab_extern_cache, slab);

  • kernel/generic/src/proc/thread.c

    ra501e22c r5df1963  
    217217        thr_destructor_arch(thread);
    218218       
    219         frame_free(KA2PA(thread->kstack));
     219        frame_free(KA2PA(thread->kstack), STACK_FRAMES);
    220220       
    221221#ifdef CONFIG_FPU

  • kernel/test/mm/falloc1.c

    ra501e22c r5df1963  
    8484                       
    8585                        for (unsigned int i = 0; i < allocated; i++)
    86                                 frame_free(KA2PA(frames[i]));
     86                                frame_free(KA2PA(frames[i]), count);
    8787                       
    8888                        TPRINTF("done.\n");

  • kernel/test/mm/falloc2.c

    ra501e22c r5df1963  
    100100                                        }
    101101                                }
    102                                 frame_free(KA2PA(frames[i]));
     102                                frame_free(KA2PA(frames[i]), count);
    103103                        }
    104104                       

  • kernel/test/mm/mapping1.c

    ra501e22c r5df1963  
    6565                        km_unmap(page0, PAGE_SIZE);
    6666                        km_unmap(page1, PAGE_SIZE);
    67                         frame_free(frame);
     67                        frame_free(frame, 1);
    6868                        return "Criss-cross read does not match the value written.";
    6969                }
    … …  
    8080                        km_unmap(page0, PAGE_SIZE);
    8181                        km_unmap(page1, PAGE_SIZE);
    82                         frame_free(frame);
     82                        frame_free(frame, 1);
    8383                        return "Criss-cross read does not match the value written.";
    8484                }
    … …  
    8787        km_unmap(page0, PAGE_SIZE);
    8888        km_unmap(page1, PAGE_SIZE);
    89         frame_free(frame);
     89        frame_free(frame, 1);
    9090       
    9191        return NULL;
Note: See TracChangeset for help on using the changeset viewer.