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

Changeset 7da90cd in mainline


Ignore:
Timestamp:
2011-04-21T19:30:49Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
74c8f344
Parents:
c7bbf029 (diff), 010be476 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~jakub/helenos/mm.

Location:
kernel/generic/src/mm
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/mm/frame.c

    rc7bbf029 r7da90cd  
    481481       
    482482        frame_t *frame = &zone->frames[frame_idx];
    483         size_t size = 1 << frame->buddy_order;
     483        size_t size = 0;
    484484       
    485485        ASSERT(frame->refcount);
    486486       
    487487        if (!--frame->refcount) {
    488                 buddy_system_free(zone->buddy_system, &frame->buddy_link);
    489                
     488                size = 1 << frame->buddy_order;
     489                buddy_system_free(zone->buddy_system, &frame->buddy_link);             
    490490                /* Update zone information. */
    491491                zone->free_count += size;
     
    10071007         * If not told otherwise, we must first reserve the memory.
    10081008         */
    1009         if (!(flags & FRAME_NO_RESERVE)) {
    1010                 if (flags & FRAME_ATOMIC) {
    1011                         if (!reserve_try_alloc(size))
    1012                                 return NULL;
    1013                 } else {
    1014                         reserve_force_alloc(size);
    1015                 }
    1016         }
    1017        
     1009        if (!(flags & FRAME_NO_RESERVE))
     1010                reserve_force_alloc(size);
     1011
    10181012loop:
    10191013        irq_spinlock_lock(&zones.lock, true);
  • kernel/generic/src/mm/reserve.c

    rc7bbf029 r7da90cd  
    3838#include <mm/reserve.h>
    3939#include <mm/frame.h>
     40#include <mm/slab.h>
    4041#include <synch/spinlock.h>
    4142#include <typedefs.h>
     
    4546static ssize_t reserve = 0;
    4647
     48/** Try to reserve memory.
     49 *
     50 * This function may not be called from contexts that do not allow memory
     51 * reclaiming, such as some invocations of frame_alloc_generic().
     52 *
     53 * @param size          Number of frames to reserve.
     54 * @return              True on success or false otherwise.
     55 */
    4756bool reserve_try_alloc(size_t size)
    4857{
     
    5362                reserve -= size;
    5463                reserved = true;
     64        } else {
     65                /*
     66                 * Some reservable frames may be cached by the slab allocator.
     67                 * Try to reclaim some reservable memory. Try to be gentle for
     68                 * the first time. If it does not help, try to reclaim
     69                 * everything.
     70                 */
     71                irq_spinlock_unlock(&reserve_lock, true);
     72                slab_reclaim(0);
     73                irq_spinlock_lock(&reserve_lock, true);
     74                if (reserve >= 0 && (size_t) reserve >= size) {
     75                        reserve -= size;
     76                        reserved = true;
     77                } else {
     78                        irq_spinlock_unlock(&reserve_lock, true);
     79                        slab_reclaim(SLAB_RECLAIM_ALL);
     80                        irq_spinlock_lock(&reserve_lock, true);
     81                        if (reserve >= 0 && (size_t) reserve >= size) {
     82                                reserve -= size;
     83                                reserved = true;
     84                        }
     85                }
    5586        }
    5687        irq_spinlock_unlock(&reserve_lock, true);
     
    5990}
    6091
     92/** Reserve memory.
     93 *
     94 * This function simply marks the respective amount of memory frames reserved.
     95 * It does not implement any sort of blocking for the case there is not enough
     96 * reservable memory. It will simply take the reserve into negative numbers and
     97 * leave the blocking up to the allocation phase.
     98 *
     99 * @param size          Number of frames to reserve.
     100 */
    61101void reserve_force_alloc(size_t size)
    62102{
     
    66106}
    67107
     108/** Unreserve memory.
     109 *
     110 * @param size          Number of frames to unreserve.
     111 */
    68112void reserve_free(size_t size)
    69113{
Note: See TracChangeset for help on using the changeset viewer.