Mem_map (page API)

Mem_map (page API)




 * This function returns the order of a free page in the buddy system. In
 * general, page_zone(page)->lock must be held by the caller to prevent the
 * page from being allocated in parallel and returning garbage as the order.
 * If a caller does not hold page_zone(page)->lock, it must guarantee that the
 * page cannot be allocated or merged in parallel. Alternatively, it must
 * handle invalid values gracefully, and use page_order_unsafe() below.
static inline unsigned long page_order(struct page *page)
        /* PageBuddy() must be checked by the caller */
        return page_private(page);


#define page_private(page)              ((page)->private)

페이지에 대한 order 값을 반환한다.

  • private 필드는 버디 시스템에서 관리할 때에는 order 값을 가진다.




#define for_each_migratetype_order(order, type) \
        for (order = 0; order < MAX_ORDER; order++) \
                for (type = 0; type < MIGRATE_TYPES; type++)
  • buddy 메모리 할당자가 사용하는 MAX_ORDER(11)  수 만큼 루프를 돈다.
  • 메모리 hotplug에 대한 이주 플래그 관리를 담당하는 MIGRATE_TYPES 만큼 루프를 돈다.


존 및 노드 관련



static inline int is_highmem_idx(enum zone_type idx)
        return (idx == ZONE_HIGHMEM ||
                (idx == ZONE_MOVABLE && zone_movable_is_highmem())); 
        return 0;




static inline int zone_movable_is_highmem(void)
        return movable_zone == ZONE_HIGHMEM;
#elif defined(CONFIG_HIGHMEM)
        return (ZONE_MOVABLE - 1) == ZONE_HIGHMEM;
        return 0;




 * zone_idx() returns 0 for the ZONE_DMA zone, 1 for the ZONE_NORMAL zone, etc.
#define zone_idx(zone)          ((zone) - (zone)->zone_pgdat->node_zones)
  • zone 인덱스 번호를 리턴한다.
    • 예) ZONE_DMA, ZONE_NORMAL을 사용하는 경우 0과 1이 리턴된다.
    • 예) ZONE_NORMAL만 사용하는 경우 0이 리턴된다.




static inline void set_page_links(struct page *page, enum zone_type zone,
        unsigned long node, unsigned long pfn) 
        set_page_zone(page, zone);
        set_page_node(page, node);
        set_page_section(page, pfn_to_section_nr(pfn));
  • page->flags에 zone, node 및 section 정보를 설정한다.
 * No sparsemem or sparsemem vmemmap: |       NODE     | ZONE |             ... | FLAGS |
 *      " plus space for last_cpupid: |       NODE     | ZONE | LAST_CPUPID ... | FLAGS |
 * classic sparse with space for node:| SECTION | NODE | ZONE |             ... | FLAGS |
 *      " plus space for last_cpupid: | SECTION | NODE | ZONE | LAST_CPUPID ... | FLAGS |
 * classic sparse no space for node:  | SECTION |     ZONE    | ... | FLAGS |




static inline void set_page_zone(struct page *page, enum zone_type zone)
        page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT);
        page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT;
  • page->flags에 zone 정보를 설정한다.




static inline void set_page_node(struct page *page, unsigned long node)
        page->flags &= ~(NODES_MASK << NODES_PGSHIFT);
        page->flags |= (node & NODES_MASK) << NODES_PGSHIFT;
  • page->flags에 노드 정보를 설정한다.




 * The identification function is mainly used by the buddy allocator for
 * determining if two pages could be buddies. We are not really identifying
 * the zone since we could be using the section number id if we do not have
 * node id available in page flags.
 * We only guarantee that it will return the same value for two combinable
 * pages in a zone.
static inline int page_zone_id(struct page *page)
        return (page->flags >> ZONEID_PGSHIFT) & ZONEID_MASK;

페이지에서 zone id를 추출하여 반환한다.


Sprsemem 섹션 관련



static inline void set_page_section(struct page *page, unsigned long section)
        page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
        page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
  • page->flags에 섹션 정보를 설정한다.




static inline struct mem_section *__pfn_to_section(unsigned long pfn) 
        return __nr_to_section(pfn_to_section_nr(pfn));

pfn 값에 대응하는 mem_section 구조체 정보를 리턴한다.

  •  pfn_to_section_nr()
    • pfn 값으로 섹션 번호를 알아온다.
  • __nr_to_section()
    • 섹션 번호로 mem_section 구조체 정보를 리턴한다.




#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
  • pfn의 섹션(Sparse) 인덱스를 리턴한다.
    • 예) Realview-PBX
      • 섹션 사이즈가 256M 단위(PFN_SECTION_SHIFT=16)이므로 섹션 번호는 0~15까지의 결과




static inline struct mem_section *__nr_to_section(unsigned long nr)
        if (!mem_section[SECTION_NR_TO_ROOT(nr)])
                return NULL;
        return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
  • 섹션 번호로 mem_section 구조체 정보를 리턴한다.




  • 섹션 번호로 ROOT 번호를 리턴한다.


#define SECTIONS_PER_ROOT       (PAGE_SIZE / sizeof (struct mem_section))
#define SECTIONS_PER_ROOT       1
  • ROOT 하나 당 섹션 수
    • PAGE_SIZE(4K)에 mem_section 구조체가 들어갈 수 있는 수




static inline int present_section_nr(unsigned long nr)
        return present_section(__nr_to_section(nr));

섹션 번호에 해당하는 mem_section이 준비되어 있는지 확인한다. 준비되어 있지 않은 경우 해당 섹션은 hole을 의미한다.

  • __nr_to_section()
    • 섹션 번호로 mem_section 구조체 정보를 알아온다.
  • present_section()
    • mem_section 구조체 정보에 섹션이 존재하는지 확인한다.




static inline int present_section(struct mem_section *section)
        return (section && (section->section_mem_map & SECTION_MARKED_PRESENT));

mem_section 구조체 정보에 섹션이 존재하는지 확인한다.

  • SECTION_MARKED_PRESENT 식별 비트가 설정되어 있는지 확인한다.




static inline struct page *__section_mem_map_addr(struct mem_section *section)
        unsigned long map = section->section_mem_map;
        map &= SECTION_MAP_MASK;
        return (struct page *)map;

헤당 Sparse memory 섹션에 대한 mem_map 주소를 반환한다.


 * We use the lower bits of the mem_map pointer to store
 * a little bit of information.  There should be at least
 * 3 bits here due to 32-bit alignment.
#define SECTION_HAS_MEM_MAP     (1UL<<1)
#define SECTION_MAP_LAST_BIT    (1UL<<2)
#define SECTION_NID_SHIFT       2


페이지의 참조 사용 및 사용 해제



static inline void get_page(struct page *page)
        page = compound_head(page);
         * Getting a normal page or the head of a compound page
         * requires to already have an elevated page->_refcount.
        VM_BUG_ON_PAGE(page_ref_count(page) <= 0, page);

참조 카운터를 1 증가시킨다.




 * Try to grab a ref unless the page has a refcount of zero, return false if
 * that is the case.
 * This can be called when MMU is off so it must not access
 * any of the virtual mappings.
static inline int get_page_unless_zero(struct page *page)
        return page_ref_add_unless(page, 1, 0);

참조 카운터(p->_refcount)를 읽은 후 0 값과 다른 경우에 한해 증가시킨다. 결과 값이 0이 아니면 true를 반환한다.




static inline void put_page(struct page *page)
        page = compound_head(page);

         * For devmap managed pages we need to catch refcount transition from
         * 2 to 1, when refcount reach one it means the page is free and we
         * need to inform the device driver through callback. See
         * include/linux/memremap.h and HMM for details.
        if (put_devmap_managed_page(page))

        if (put_page_testzero(page))

참조 카운터를 1 감소 시킨다. 만일 0이되면 페이지의 회수를 진행한다.




 * Methods to modify the page usage count.
 * What counts for a page usage:
 * - cache mapping   (page->mapping)
 * - private data    (page->private)
 * - page mapped in a task's page tables, each mapping
 *   is counted separately
 * Also, many kernel routines increase the page count before a critical
 * routine so they can be sure the page doesn't go away from under them.

 * Drop a ref, return true if the refcount fell to zero (the page has no users)
static inline int put_page_testzero(struct page *page)
        VM_BUG_ON_PAGE(page_ref_count(page) == 0, page);
        return page_ref_dec_and_test(page);

페이지의 참조카운터를 감소시키고 0(사용완료)인지 확인하여 사용완료 여부를 반환한다.

  • 0=사용중, 1=사용완료(참조 _count가 0이된 경우)


page vs pfn 변환


#define page_to_pfn __page_to_pfn

다음 4가지 커널 옵션 설정에 따라 함수가 선택된다.

#define __pfn_to_page(pfn)      (mem_map + ((pfn) - ARCH_PFN_OFFSET))
#define __page_to_pfn(page)     ((unsigned long)((page) - mem_map) + \
#define __pfn_to_page(pfn)                      \
({      unsigned long __pfn = (pfn);            \       
        unsigned long __nid = arch_pfn_to_nid(__pfn);  \
        NODE_DATA(__nid)->node_mem_map + arch_local_page_offset(__pfn, __nid);\

#define __page_to_pfn(pg)                                               \
({      const struct page *__pg = (pg);                                 \
        struct pglist_data *__pgdat = NODE_DATA(page_to_nid(__pg));     \
        (unsigned long)(__pg - __pgdat->node_mem_map) +                 \
         __pgdat->node_start_pfn;                                       \
 * Note: section's mem_map is encoded to reflect its start_pfn.
 * section[i].section_mem_map == mem_map's address - start_pfn;
#define __page_to_pfn(pg)                                       \
({      const struct page *__pg = (pg);                         \
        int __sec = page_to_section(__pg);                      \
        (unsigned long)(__pg - __section_mem_map_addr(__nr_to_section(__sec))); \

#define __pfn_to_page(pfn)                              \
({      unsigned long __pfn = (pfn);                    \
        struct mem_section *__sec = __pfn_to_section(__pfn);    \
        __section_mem_map_addr(__sec) + __pfn;          \
/* memmap is virtually contiguous.  */
#define __pfn_to_page(pfn)      (vmemmap + (pfn))
#define __page_to_pfn(page)     (unsigned long)((page) - vmemmap)


페이지 플래그


 * Various page->flags bits:
 * PG_reserved is set for special pages, which can never be swapped out. Some
 * of them might not even exist (eg empty_bad_page)...
 * The PG_private bitflag is set on pagecache pages if they contain filesystem
 * specific data (which is normally at page->private). It can be used by
 * private allocations for its own usage.
 * During initiation of disk I/O, PG_locked is set. This bit is set before I/O
 * and cleared when writeback _starts_ or when read _completes_. PG_writeback
 * is set before writeback starts and cleared when it finishes.
 * PG_locked also pins a page in pagecache, and blocks truncation of the file
 * while it is held.
 * page_waitqueue(page) is a wait queue of all tasks waiting for the page
 * to become unlocked.
 * PG_uptodate tells whether the page's contents is valid.  When a read
 * completes, the page becomes uptodate, unless a disk I/O error happened.
 * PG_referenced, PG_reclaim are used for page reclaim for anonymous and
 * file-backed pagecache (see mm/vmscan.c).
 * PG_error is set to indicate that an I/O error occurred on this page.
 * PG_arch_1 is an architecture specific page state bit.  The generic code
 * guarantees that this bit is cleared for a page when it first is entered into
 * the page cache.
 * PG_highmem pages are not permanently mapped into the kernel virtual address
 * space, they need to be kmapped separately for doing IO on the pages.  The
 * struct page (these bits with information) are always mapped into kernel
 * address space...
 * PG_hwpoison indicates that a page got corrupted in hardware and contains
 * data with incorrect ECC bits that triggered a machine check. Accessing is
 * not safe since it may cause another machine check. Don't touch!

 * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break
 * locked- and dirty-page accounting.
 * The page flags field is split into two parts, the main flags area
 * which extends from the low bits upwards, and the fields area which
 * extends from the high bits downwards.
 *  | FIELD | ... | FLAGS |
 *  N-1           ^       0
 *               (NR_PAGEFLAGS)
 * The fields area is reserved for fields mapping zone, node (for NUMA) and
 * SPARSEMEM section (for variants of SPARSEMEM that require section ids like


enum pageflags {
        PG_locked,              /* Page is locked. Don't touch. */
        PG_owner_priv_1,        /* Owner use. If pagecache, fs may use*/
        PG_private,             /* If pagecache, has fs-private data */
        PG_private_2,           /* If pagecache, has fs aux data */
        PG_writeback,           /* Page is under writeback */
        PG_head,                /* A head page */
        PG_tail,                /* A tail page */
        PG_compound,            /* A compound page */
        PG_swapcache,           /* Swap page: swp_entry_t in private */
        PG_mappedtodisk,        /* Has blocks allocated on-disk */
        PG_reclaim,             /* To be reclaimed asap */
        PG_swapbacked,          /* Page is backed by RAM/swap */
        PG_unevictable,         /* Page is "unevictable"  */
        PG_mlocked,             /* Page is vma mlocked */
        PG_uncached,            /* Page has been mapped as uncached */
        PG_hwpoison,            /* hardware poisoned page. Don't touch */

        /* Filesystems */
        PG_checked = PG_owner_priv_1,

        /* Two page bits are conscripted by FS-Cache to maintain local caching
         * state.  These bits are set on pages belonging to the netfs's inodes
         * when those inodes are being locally cached.
        PG_fscache = PG_private_2,      /* page backed by cache */

        /* XEN */
        /* Pinned in Xen as a read-only pagetable page. */
        PG_pinned = PG_owner_priv_1,
        /* Pinned as part of domain save (see xen_mm_pin_all()). */
        PG_savepinned = PG_dirty,
        /* Has a grant mapping of another (foreign) domain's page. */
        PG_foreign = PG_owner_priv_1,

        /* SLOB */
        PG_slob_free = PG_private,


Reserved 플래그(예)

PageReserved(), SetPageReserved(), ClearPageReserved(), __ClearPageReserved()


PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
  • PageReserved(), SetPageReserved(), ClearPageReserved() 및 __ClearPageReserved() static inline 함수가 만들어진다.


#define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)               \
        SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)
  • 아래 매크로를 사용하여 PageXXX(), SetPageXXX() 및 ClearPageXXX() static inline 함수가 만들어진다.


 * Macros to create function definitions for page flags
#define TESTPAGEFLAG(uname, lname)                                      \
static inline int Page##uname(const struct page *page)                  \
                        { return test_bit(PG_##lname, &page->flags); }

#define SETPAGEFLAG(uname, lname)                                       \
static inline void SetPage##uname(struct page *page)                    \
                        { set_bit(PG_##lname, &page->flags); }

#define CLEARPAGEFLAG(uname, lname)                                     \
static inline void ClearPage##uname(struct page *page)                  \
                        { clear_bit(PG_##lname, &page->flags); }


#define __CLEARPAGEFLAG(uname, lname)                                   \
static inline void __ClearPage##uname(struct page *page)                \
                        { __clear_bit(PG_##lname, &page->flags); }
  • test_bit()
    • &page->flags의 PG_xxxxx 번호 비트가 set되었는지 여부를 알아온다.
  • set_bit()
    • &page->flags의 PG_xxxxx 번호 비트를 atomic하게 set 한다.
  • clear_bit()
    • &page->flags의 PG_xxxxx 번호 비트를 atomic하게 clear 한다.
  • __clear_bit()
    • &page->flags의 PG_xxxxx 번호 비트를 clear 한다. (non-atomic)


일부 플래그의 재편성

아래 4개의 PG_buddy, PG_ballon, PG_kmemcg, PG_table 플래그는 p->_mapcount와 같이 사용하는 것으로 바뀌었고, 다시 유니언 선언하여 공유된 p->page_type을 사용한다.

  • 최초 p->flags에서 관리되던 플래그들이 p->_mapcount로 분리되었었다.
  •  후 새 커널에서는 p->_mapcount 대신 유니온으로 공유된 p->page_type를 사용한다. 단  p->_mapcount의 초기 값이 -1(0xffff_ffff)이므로 비트의 설정과 해제는 반대로 사용한다.
    • 예) Set Buddy
      • old 커널: p->_mapcount = PAGE_BUDDY_MAPCOUNT_VALUE(-128)
      • new 커널: p->page_type &= ~0x80
    • 예) Clear Buddy
      • p->_mapcount = PAGE_BUDDY_MAPCOUNT_VALUE(-1)
      • new 커널: p->page_type |= 0x80
    • 참고: mm: split page_type out from _mapcount



 * PageBuddy() indicates that the page is free and in the buddy system
 * (see mm/page_alloc.c).
PAGE_TYPE_OPS(Buddy, buddy)

 * PageBalloon() is true for pages that are on the balloon page list
 * (see mm/balloon_compaction.c).
PAGE_TYPE_OPS(Balloon, balloon)

 * If kmemcg is enabled, the buddy allocator will set PageKmemcg() on
 * pages allocated with __GFP_ACCOUNT. It gets cleared on page free.
PAGE_TYPE_OPS(Kmemcg, kmemcg)

 * Marks pages in use as page tables.
PAGE_TYPE_OPS(Table, table)


 * For pages that are never mapped to userspace (and aren't PageSlab),
 * page_type may be used.  Because it is initialised to -1, we invert the
 * sense of the bit, so __SetPageFoo *clears* the bit used for PageFoo, and
 * __ClearPageFoo *sets* the bit used for PageFoo.  We reserve a few high and
 * low bits so that an underflow or overflow of page_mapcount() won't be
 * mistaken for a page type value.
#define PAGE_TYPE_BASE  0xf0000000
/* Reserve              0x0000007f to catch underflows of page_mapcount */
#define PG_buddy        0x00000080
#define PG_balloon      0x00000100
#define PG_kmemcg       0x00000200
#define PG_table        0x00000400

#define PageType(page, flag)                                            \
        ((page->page_type & (PAGE_TYPE_BASE | flag)) == PAGE_TYPE_BASE)

static inline int page_has_type(struct page *page)
        return (int)page->page_type < PAGE_MAPCOUNT_RESERVE;

#define PAGE_TYPE_OPS(uname, lname)                                     \
static __always_inline int Page##uname(struct page *page)               \
{                                                                       \
        return PageType(page, PG_##lname);                              \
}                                                                       \
static __always_inline void __SetPage##uname(struct page *page)         \
{                                                                       \
        VM_BUG_ON_PAGE(!PageType(page, 0), page);                       \
        page->page_type &= ~PG_##lname;                                 \
}                                                                       \
static __always_inline void __ClearPage##uname(struct page *page)       \
{                                                                       \
        VM_BUG_ON_PAGE(!Page##uname(page), page);                       \
        page->page_type |= PG_##lname;                                  \

위의 매크로를 통해 PageBuddy(), __SetPageBuddy(), __ClearPageBuddy() 등의 인라인 함수가 생성된다.



페이지 블럭 관련



#define set_pageblock_flags_group(page, flags, start_bitidx, end_bitidx) \
        set_pfnblock_flags_mask(page, flags, page_to_pfn(page),         \
                        end_bitidx,                                     \
                        (1 << (end_bitidx - start_bitidx + 1)) - 1)




 * set_pfnblock_flags_mask - Set the requested group of flags for a pageblock_nr_pages block of pages
 * @page: The page within the block of interest
 * @flags: The flags to set
 * @pfn: The target page frame number
 * @end_bitidx: The last bit of interest
 * @mask: mask of bits that the caller is interested in
void set_pfnblock_flags_mask(struct page *page, unsigned long flags,
                                        unsigned long pfn,
                                        unsigned long end_bitidx,
                                        unsigned long mask)
        struct zone *zone;      
        unsigned long *bitmap;
        unsigned long bitidx, word_bitidx;
        unsigned long old_word, word;


        zone = page_zone(page);
        bitmap = get_pageblock_bitmap(zone, pfn);
        bitidx = pfn_to_bitidx(zone, pfn);
        word_bitidx = bitidx / BITS_PER_LONG;
        bitidx &= (BITS_PER_LONG-1);

        VM_BUG_ON_PAGE(!zone_spans_pfn(zone, pfn), page);

        bitidx += end_bitidx;
        mask <<= (BITS_PER_LONG - bitidx - 1);
        flags <<= (BITS_PER_LONG - bitidx - 1); 

        word = ACCESS_ONCE(bitmap[word_bitidx]);
        for (;;) {
                old_word = cmpxchg(&bitmap[word_bitidx], word, (word & ~mask) | flags);
                if (word == old_word)
                word = old_word;




 * get_pfnblock_flags_mask - Return the requested group of flags for the pageblock_nr_pages block of pages              
 * @page: The page within the block of interest
 * @pfn: The target page frame number
 * @end_bitidx: The last bit of interest to retrieve
 * @mask: mask of bits that the caller is interested in
 * Return: pageblock_bits flags
unsigned long get_pfnblock_flags_mask(struct page *page, unsigned long pfn,
                                        unsigned long end_bitidx,
                                        unsigned long mask)
        struct zone *zone;
        unsigned long *bitmap;
        unsigned long bitidx, word_bitidx;
        unsigned long word;

        zone = page_zone(page);
        bitmap = get_pageblock_bitmap(zone, pfn);
        bitidx = pfn_to_bitidx(zone, pfn);
        word_bitidx = bitidx / BITS_PER_LONG;
        bitidx &= (BITS_PER_LONG-1);

        word = bitmap[word_bitidx];
        bitidx += end_bitidx;
        return (word >> (BITS_PER_LONG - bitidx - 1)) & mask;




/* Return a pointer to the bitmap storing bits affecting a block of pages */
static inline unsigned long *get_pageblock_bitmap(struct zone *zone,
                                                        unsigned long pfn)
        return __pfn_to_section(pfn)->pageblock_flags;
        return zone->pageblock_flags;

@pfn이 포함된 페이지 블럭 비트맵을 반환한다. (usemap)

  • usemap에는 4비트로 표현된 mobility 플래그들이 저장된다.




static inline int pfn_to_bitidx(struct zone *zone, unsigned long pfn)
        pfn &= (PAGES_PER_SECTION-1);
        return (pfn >> pageblock_order) * NR_PAGEBLOCK_BITS;
        pfn = pfn - round_down(zone->zone_start_pfn, pageblock_nr_pages);
        return (pfn >> pageblock_order) * NR_PAGEBLOCK_BITS;

pfn에 대한 pageblock에서 비트 인덱스를 반환한다.




        ((1UL << (PFN_SECTION_SHIFT - pageblock_order)) * NR_PAGEBLOCK_BITS)

섹션 당 pageblock 비트 수

    • pageblock에 대해 필요한 비트 수=4
    • 섹션 길이 표현에 필요한 비트 수 – 페이지 길이 표현에 필요한 비트 수를 뺀 값
      • arm64: 섹션 길이=30(1GB 표현) bits – 12(4KB 표현) bits = 18
  • 예) arm64에서 섹션 크기=1G, pageblock_order=10인 경우
    • 2^(18-10) * 4 = 1024개



Sparse Memory

<kernel v5.0>

Sparse memory 모델은 섹션 메모리 단위로 mem_section 구조체를 통해 다음과 같은 자료를 관리한다.

  • mem_map
  • usemap (페이지블럭)



Sparse memory 모델에서 섹션은 메모리의 online/offlline(hotplug memory)을 관리하는 최소 메모리 크기 단위이다. 전체 메모리를 섹션들로 나누어 사용하는데 적절한 섹션 사이즈로 나누어 사용하는데 아키텍처 마다 다르다.

  • 보통 섹션 크기는 수십MB~수GB를 사용한다.
    • arm64: default 값으로 1G
  • 매핑 테이블에서 사용하는 섹션(1M, 16M(수퍼섹션)이 아니므로 유의한다.


섹션 배열 2 가지 관리 방법

섹션에서 mem_map을 관리하는 다음 두 가지 방법을 알아본다.

  • static
    • 컴파일 타임에 1단계 mem_section[] 배열을 결정하여 사용하는 방법이다.
    • 주로 32bit 시스템에서 섹션 수가 적을 때 사용한다.
  • extream
    • 런타임에 1단계 **mem_section[] 포인터 배열을 할당하고, 2 단계는 필요 시마다 mem_section[] 배열을 할당하여 사용하는 방법으로 메모리 낭비를 막는 방법이다.
    • 주로 64bit 시스템에서 섹션 수가 많을 때 사용한다.



32bit ARM에서 Sparse Memory를 사용하는 Realview-PBX 보드가 섹션당 256MB 크기로 구성된 사례를 사용한다.

  • Realview-PBX
    • 3개의 메모리
      • 256MB @ 0x00000000 -> PAGE_OFFSET
      • 512MB @ 0x20000000 -> PAGE_OFFSET + 0x10000000
      • 256MB @ 0x80000000 -> PAGE_OFFSET + 0x30000000
    • MAX_PHYSMEM_BITS=32 (4G 메모리 크기)
    • SECTION_SIZE_BITS=28 (256MB 섹션 크기)
    • PAGE_SECTION_MASK=(~(PAGES_PER_SECTION-1))=0xffff_0000



64bit ARM에서 Sparse Memory를 사용하는 경우의 사례로 1GB 크기로 구성된 사례를 사용한다.

  • arm64
    • 2개의 메모리
      • 2GB @ 0x0_8000_0000
      • 2GB @ 0x8_0000_0000
  • MAX_PHYSMEM_BITS=48 (256 TB 메모리 크기)
  • SECTION_SIZE_BITS=30 (1GB 섹션 크기)
  • SECTIONS_PER_ROOT=(PAGE_SIZE / sizeof (struct mem_section))=256
  • PAGE_SECTION_MASK=(~(PAGES_PER_SECTION-1))=0xffff_ffff_fffc_0000



usemap은 메모리 회수 매커니즘 중 하나인 compaction에서 전체 메모리를 스캔할 때 사용되는 페이지 블럭 당 4비트로 구성된다.

  • compaction에서 빠른 스캔을 위해 블럭 단위(arm64 디폴트=2M)로 묶어 사용한다.
  • 페이지 블럭 당 사용되는 4비트는 3비트의 mobility(migratype) 속성과 1 비트의 skip 비트로 구성된다.



32bit arm 에서는 사용하지 않는다. CONFIG_SPARSEMEM_VMEMMAP 커널 옵션을 사용할 수 있는 arm64를 포함하는 일부 64비트 아키텍처에서 Flat Memory 모델처럼 빠르게 운용할 수 있다.

  • 64비트 시스템에서 vmemmap 매핑 공간이 별도로 구성되어 있어 그 영역에 section_mem_map으로 구성된 mem_map들을 매핑한다.
  • vmemmap을 사용하는 경우 노드별 메모리에 분산되어 있는 페이지 descriptor로 serial하게 접근할 수 있어 page_to_pfn() 또는 pfn_to_page() 함수의 성능을 빠르게 얻을 수 있다.


다음 그림은 4K 페이지 x 3 레벨의 페이지 변환을 사용하는 arm64 시스템에서 vmemmap이 구성되는 사례를 보여준다.



메모리 활성화

arm_memory_present() – ARM32


static void __init arm_memory_present(void)
        struct memblock_region *reg;

        for_each_memblock(memory, reg)
                memory_present(0, memblock_region_memory_base_pfn(reg),

memory memblock 들에 대해 memory_present() 함수를 호출하여 mem_section[] 매핑 배열을 초기화한다.


arm64_memory_present() – ARM64


static void __init arm64_memory_present(void)
        struct memblock_region *reg;

        for_each_memblock(memory, reg) {
                int nid = memblock_get_region_node(reg);

                memory_present(nid, memblock_region_memory_base_pfn(reg),

sparse 메모리 모델에서 memory memblock 들에 대해 memory_present() 함수를 호출하여 mem_section[] 배열을 초기화한다.




/* Record a memory area against a node. */
void __init memory_present(int nid, unsigned long start, unsigned long end)
        unsigned long pfn;

        if (unlikely(!mem_section)) {
                unsigned long size, align;

                size = sizeof(struct mem_section*) * NR_SECTION_ROOTS;
                align = 1 << (INTERNODE_CACHE_SHIFT);
                mem_section = memblock_alloc(size, align);

        start &= PAGE_SECTION_MASK;
        mminit_validate_memmodel_limits(&start, &end);
        for (pfn = start; pfn < end; pfn += PAGES_PER_SECTION) {
                unsigned long section = pfn_to_section_nr(pfn);
                struct mem_section *ms;

                sparse_index_init(section, nid);
                set_section_nid(section, nid);

                ms = __nr_to_section(section);
                if (!ms->section_mem_map) {
                        ms->section_mem_map = sparse_encode_early_nid(nid) |

memory_present() 함수는 CONFIG_HAVE_MEMORY_PRESENT 커널 옵션을 사용하는 경우에만 동작하며 각 섹션에 노드 id를 기록하는데, 자세한 내용은 코드를 보고 알아보기로 한다.

  • 코드 라인 6~14에서 CONFIG_SPARSEMEM_EXTREME 커널 옵션을 사용하는 경우 처음 mem_section이 초기화되지 않은 경우 mem_section[] 배열을 생성한다.
    • arm64 예) 4K 페이지, sizeof(struct mem_section)=16
      • NR_SECTION_ROOTS=1024
  • 코드 라인 16~17에서 요청한 범위의 시작 pfn을 섹션 단위로 내림 정렬한 주소로 변환한 후 해당 범위의 pfn이 실제로 지정할 수 있는 물리 메모리 범위에 포함되는지 검증하고 초과 시 그 주소를 강제로 제한한다.
  • 코드 라인 18~19에서 시작 pfn부터 섹션 단위로 증가시키며 이 값으로 section 번호를 구한다.
  • 코드 라인 22에서 CONFIG_SPARSEMEM_EXTREME 커널 옵션을 사용하는 경우에만 동작하며, 이 함수에서 해당 섹션에 대한 mem_section[]을 동적으로(dynamic) 할당받는다. CONFIG_SPARSEMEM_STATIC 커널 옵션을 사용하는 경우에는 이미 정적(static) 배열이 준비되어 있으므로 아무런 동작도 요구되지 않는다.
  • 코드 라인 23에서 NODE_NOT_IN_PAGE_FLAGS가 정의된 경우 별도의 전역 section_to_node_table[] 배열에 해당 섹션을 인덱스로 해당 노드 id를 가리키게 한다.
    • NODE_NOT_IN_PAGE_FLAGS 커널 옵션은 page 구조체의 flags 필드에 노드 번호를 저장할 비트가 부족한 32비트 아키텍처에서 사용되는 옵션이다.
  • 코드 라인 25~30에서 해당 섹션의 mem_section 구조체내의 section_mem_map에 노드 id와 online 및 present 플래그를 설정한다.


아래 그림은 memory_present() 함수가 호출되는 과정에서 mem_section[] 배열이 할당되는 것을 나타낸다.

  • 붉은 색 박스는 sparse_index_alloc() 함수에 의해 dynamic 하게 메모리 할당을 받는 것을 의미한다.
  • 푸른 색 박스는 컴파일 타임에 static하게 배열이 할당됨을 의미한다.





void __meminit mminit_validate_memmodel_limits(unsigned long *start_pfn,
                                                unsigned long *end_pfn)
        unsigned long max_sparsemem_pfn = 1UL << (MAX_PHYSMEM_BITS-PAGE_SHIFT);

         * Sanity checks - do not allow an architecture to pass
         * in larger pfns than the maximum scope of sparsemem:
        if (*start_pfn > max_sparsemem_pfn) {
                mminit_dprintk(MMINIT_WARNING, "pfnvalidation",
                        "Start of range %lu -> %lu exceeds SPARSEMEM max %lu\n",
                        *start_pfn, *end_pfn, max_sparsemem_pfn);
                *start_pfn = max_sparsemem_pfn;
                *end_pfn = max_sparsemem_pfn;
        } else if (*end_pfn > max_sparsemem_pfn) {
                mminit_dprintk(MMINIT_WARNING, "pfnvalidation",
                        "End of range %lu -> %lu exceeds SPARSEMEM max %lu\n",
                        *start_pfn, *end_pfn, max_sparsemem_pfn);
                *end_pfn = max_sparsemem_pfn;

인자로 사용된 시작 pfn, 끝 pfn 값이 물리 메모리 주소 최대 pfn 값을 초과하지 않도록 제한한다.

  • 코드 라인 10~16에서 시작 pfn이 max_sparsemem_pfn보다 크면 경고를 출력하고, start_pfn과 end_pfn에 max_sparsemem_pfn을 설정한다.
  • 코드 라인 17~23에서 끝 pfn이 max_sparsemem_pfn보다 크면 경고를 출력하고, end_pfn에 max_sparsemem_pfn을 설정한다.


섹션 인덱스 초기화



static int __meminit sparse_index_init(unsigned long section_nr, int nid)
        unsigned long root = SECTION_NR_TO_ROOT(section_nr);
        struct mem_section *section;

        if (mem_section[root])
                return -EEXIST;

        section = sparse_index_alloc(nid);
        if (!section)
                return -ENOMEM;

        mem_section[root] = section;

        return 0;

CONFIG_SPARSEMEM_EXTREME 커널 옵션을 사용하는 경우 dynamic하게 mem_section 테이블을 할당 받아 구성한다.

  • 코드 라인 4에서 섹션 번호로 루트 번호를 구한다.
  • 코드 라인 7~8에서 해당 루트 인덱스의 루트 섹션에 값이 존재하는 경우 이미 mem_section[] 테이블이 구성되었으므로 함수를 빠져나간다.
  • 코드 라인 10~12에서 해당 노드에서 2 단계용 섹션 테이블을 할당받아 구성한다. 핫플러그 메모리를 위해 각 mem_section[] 테이블은 해당 노드에 위치해야 한다.
  • 코드 라인 14에서 루트 번호에 해당하는 1단계 mem_section[] 포인터 배열에 새로 할당받은 2 단계 mem_section[] 테이블의 시작 주소를 설정한다.




static struct mem_section noinline __init_refok *sparse_index_alloc(int nid)
        struct mem_section *section = NULL;
        unsigned long array_size = SECTIONS_PER_ROOT *
                                   sizeof(struct mem_section);

        if (slab_is_available()) {
                if (node_state(nid, N_HIGH_MEMORY))
                        section = kzalloc_node(array_size, GFP_KERNEL, nid);
                        section = kzalloc(array_size, GFP_KERNEL);
        } else {
                section = memblock_virt_alloc_node(array_size, nid);

        return section;

CONFIG_SPARSEMEM_EXTREME 커널 옵션을 사용하는 경우 mem_section[] 테이블용 메모리를 할당 받는다.

  • 코드 라인 5~6에서 루트 엔트리는 1개의 페이지로 구성되며, 가득 구성될 mem_section 구조체 배열의 크기를 구한다. SECTIONS_PER_ROOT는 루트 엔트리당 mem_section 수를 의미한다. 이 상수는 다음과 같이 정의되어 있다.
    • #define SECTIONS_PER_ROOT (PAGE_SIZE / sizeof(struct mem_section))
        • 루트 엔트리 당 mem_section[] 배열의 크기
        • 예) arm64: 256개
      • sizeof(struct mem_section)
        • 예) arm64: 페이지 확장 정보(CONFIG_PAGE_EXTENSION)없이 16 bytes
  • 코드 라인 8~12에서 슬랩 메모리 할당자가 동작하는 경우 노드가 highmem인 경우에는 kzalloc_node( ) 함수를 통해 메모리를 할당한다. 그렇지 않다면 kzalloc( ) 함수를 통해 lowmem에서 메모리를 할당한다.
  • 코드 라인 13~15에서 슬랩 메모리 할당자가 동작하지 않는 경우 해당 노드의 memblock에 할당한다




static void set_section_nid(unsigned long section_nr, int nid)
        section_to_node_table[section_nr] = nid;
static inline void set_section_nid(unsigned long section_nr, int nid)

NODE_NOT_IN_PAGE_FLAGS  옵션을 사용하는 경우 section_to_node_table[]에 섹션 번호에 1:1로 대응하는 노드 번호를 저장한다.

  • page 구조체 멤버 변수 flags에 노드 번호를 저장할 비트가 부족한 32비트 아키텍처에서 사용되는 옵션이다.


아래 그림은 set_section_nid() 함수를 통해 주어진 섹션 번호에 노드 번호를 저장한다.





static inline struct mem_section *__nr_to_section(unsigned long nr)
        if (!mem_section)
                return NULL;
        if (!mem_section[SECTION_NR_TO_ROOT(nr)])
                return NULL;
        return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];

섹션 번호에 해당하는 mem_section 구조체 정보를 알아온다.


아래 그림은 __nr_to_section() 함수를 사용하여 섹션 번호로 mem_section 구조체 정보를 알아오는 단계를 2 가지 예로 나타내었다.





 * During early boot, before section_mem_map is used for an actual
 * mem_map, we use section_mem_map to store the section's NUMA
 * node.  This keeps us from having to use another data structure.  The
 * node information is cleared just before we store the real mem_map.
static inline unsigned long sparse_encode_early_nid(int nid)
        return (nid << SECTION_NID_SHIFT);

노드 번호로 SECTION_NID_SHIFT(2) 만큼 좌측으로 쉬프트한다.


Sparse 메모리 모델 초기화


다음 순서도는 Sparse 메모리 초기화에 대한 로직으로 다음과 같은 일들을 한다.

  • 노드별 usemap을 할당하고 임시로 사용되는 usemap_map에 연결한다.
  • CONFIG_SPARSEMEM_VMEMMAP 커널 옵션을 사용하면 mem_map을 vmemmap에 매핑하여 사용한다.
  • CONFIG_SPARSEMEM_VMEMMAP 커널 옵션을 사용하지 않는 경우 노드마다 활성화된 섹션들의 mem_map을 가능하면 한꺼번에 할당하다. (이전 버전의 x86 커널에 적용했었던 CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER 커널 옵션과 유사)


다음 그림은 sparse_init() 에서 만들어지는 mem_map, usemap, mem_section[] 들을 보여준다.



 * Allocate the accumulated non-linear sections, allocate a mem_map
 * for each and record the physical to section mapping.
void __init sparse_init(void)
        unsigned long pnum_begin = first_present_section_nr();
        int nid_begin = sparse_early_nid(__nr_to_section(pnum_begin));
        unsigned long pnum_end, map_count = 1;

        /* Setup pageblock_order for HUGETLB_PAGE_SIZE_VARIABLE */

        for_each_present_section_nr(pnum_begin + 1, pnum_end) {
                int nid = sparse_early_nid(__nr_to_section(pnum_end));

                if (nid == nid_begin) {
                /* Init node with sections in range [pnum_begin, pnum_end) */
                sparse_init_nid(nid_begin, pnum_begin, pnum_end, map_count);
                nid_begin = nid;
                pnum_begin = pnum_end;
                map_count = 1;
        /* cover the last node */
        sparse_init_nid(nid_begin, pnum_begin, pnum_end, map_count);

sparse 메모리 모델을 사용하기 위해 페이지 디스크립터들이 집합되어 있는 mem_map들을 섹션 단위로 할당하고 관리하기 위해 초기화하는 과정을 알아본다.
분산된 메모리를 섹션 단위로 관리하기 위해 각 섹션이 mem_map과 usemap을 할당하여 관리할 수 있도록 한다. usemap은 페이지 블록 단위를 결정한 후 페이지 블록당 4비트의 비트맵으로 mobility 특성을 관리한다.

  • 코드 라인 8에서 전체 메모리에 대해 페이지 블록 크기 단위로 4비트의 mobility 특성을 기록하고 관리하기 위해 먼저 전역 변수 pageblock_order를 설정한다.
    • ARM64 시스템의 디폴트 설정은 pageblock_order 값에 9을 사용한다.
  • 코드 라인 10~16에서 present 섹션을 순회하며 동일 노드인 경우 map_count를 증가시켜 한꺼번에 할당 받을 개수를 정한다.
    • present 섹션을 순회 중일 때 pnum_end에는 순회중인 present 섹션 번호가 담긴다.
  • 코드 라인 18~21에서 바뀐 노드인 경우 해당 present  범위의 섹션들을 초기화한다.
  • 코드 라인 24에서 마지막 노드의 경우 해당 present 범위의 섹션들을 초기화한다.
  • 코드 라인 25에서 arm과 arm64에서는 구현되지 않아 출력하는 메시지가 없다.






/* Huge page sizes are variable */
extern unsigned int pageblock_order;


/* Huge pages are a constant size */
#define pageblock_order         HUGETLB_PAGE_ORDER



/* If huge pages are not used, group by MAX_ORDER_NR_PAGES */
#define pageblock_order         (MAX_ORDER-1)


페이지 블럭 오더 크기는 CONFIG_HUGETLB_PAGE 및 CONFIG_HUGETLB_PAGE_SIZE_VARIABLE 커널 옵션에 사용 유무에 따라 결정된다.

      • pageblock_order를 런타임에 set_pageblock_order() 함수에서 결정한다.
      • 컴파일 타임에 HUGETLB_PAGE_ORDER 값으로 결정된다.
        • =HPAGE_SHIFT(21) – PAGE_SHIFT(12)=9 (arm64 디폴트 설정 사용 시)
  • CONFIG_HUGETLB_PAGE 커널 옵션을 사용하지 않을 경우
    • 컴파일 타임에 MAX_ORDER-1 값으로 결정된다.




#define for_each_present_section_nr(start, section_nr)          \
        for (section_nr = next_present_section_nr(start-1);     \
             ((section_nr >= 0) &&                              \
              (section_nr <= __highest_present_section_nr));    \
             section_nr = next_present_section_nr(section_nr))

@start 섹션을 포함하여 마지막 present 섹션까지 present 섹션마다 순회한다. @section_nr는 출력 인자로 present 섹션 번호이다.




static inline int next_present_section_nr(int section_nr)
        do {
                if (present_section_nr(section_nr))
                        return section_nr;
        } while ((section_nr <= __highest_present_section_nr));

        return -1;

요청한 @section_nr 다음 섹션번호부터 마지막 섹션까지 순회하며 present 섹션을 발견하면 해당 섹션 번호를 반환한다.


노드별 sparse 초기화



 * Initialize sparse on a specific node. The node spans [pnum_begin, pnum_end)
 * And number of present sections in this node is map_count.
static void __init sparse_init_nid(int nid, unsigned long pnum_begin,
                                   unsigned long pnum_end,
                                   unsigned long map_count)
        unsigned long pnum, usemap_longs, *usemap;
        struct page *map;

        usemap = sparse_early_usemaps_alloc_pgdat_section(NODE_DATA(nid),
                                                          usemap_size() *
        if (!usemap) {
                pr_err("%s: node[%d] usemap allocation failed", __func__, nid);
                goto failed;
        sparse_buffer_init(map_count * section_map_size(), nid);
        for_each_present_section_nr(pnum_begin, pnum) {
                if (pnum >= pnum_end)

                map = sparse_mem_map_populate(pnum, nid, NULL);
                if (!map) {
                        pr_err("%s: node[%d] memory map backing failed. Some memory will not be avaii
                               __func__, nid);
                        pnum_begin = pnum;
                        goto failed;
                check_usemap_section_nr(nid, usemap);
                sparse_init_one_section(__nr_to_section(pnum), pnum, map, usemap);
                usemap += usemap_longs;
        /* We failed to allocate, mark all the following pnums as not present */
        for_each_present_section_nr(pnum_begin, pnum) {
                struct mem_section *ms;

                if (pnum >= pnum_end)
                ms = __nr_to_section(pnum);
                ms->section_mem_map = 0;

@nid 노드에 해당하는 @pnum_begin ~ @pnum_end 미만 까지의 섹션 범위들에 대해 @map_count 만큼의 present 섹션과 관련된 mem_map 및 usemap을 할당하고 초기화한다.

  • 코드 라인 8~15에서 @map_count 섹션 수 만큼의 usemap[] 배열을 노드 @nid에서 한꺼번에 할당한다.
  • 코드 라인 16에서 @map_count 섹션 수 만큼의 sparse 버퍼를 노드 @nid에서 한꺼번에 할당한다.
  • 코드 라인 17~28에서 @pnum_begin 섹션 부터 끝 present 섹션까지 순회하며 해당 섹션의 mem_map을 할당받는다.
    • 가능하면 sparse 버퍼에서 할당받는다.
  • 코드 라인 29에서 할당받은 usemap과 노드 정보(pgdat)가 기록된 섹션과 같지 않으면 경고 메시지를 출력한다. usemap 정보가 같은 노드 공간에 구성되지 않으면 메모리 핫리무브(hot remove) 동작 시 노드별로 메모리를 제거해야 할 때 circular dependancy 문제가 발생할 수 있다.
  • 코드 라인 30에서 해당 섹션 하나를 초기화한다.
  • 코드 라인 33에서 할당하고 남은 sparse 버퍼를 할당 해제한다.


브라켓 표현법

begin이 1이고 end가 5라고 할 때

  • [begin, end]
    • begin 이상 ~ end 이하
    • 1~5
  • (begin, end)
    • bigin 초과 ~ end 미만
    • 2~4
  • [begin, end)
    • begin 이상 ~ end 미만
    • 1~4
  • (begin, end]
    • begin 초과, end 이하
    • 2~5


usemap 할당



static unsigned long * __init
sparse_early_usemaps_alloc_pgdat_section(struct pglist_data *pgdat,
                                         unsigned long size)
        unsigned long goal, limit;
        unsigned long *p;
        int nid;
         * A page may contain usemaps for other sections preventing the
         * page being freed and making a section unremovable while
         * other sections referencing the usemap remain active. Similarly,
         * a pgdat can prevent a section being removed. If section A
         * contains a pgdat and section B contains the usemap, both
         * sections become inter-dependent. This allocates usemaps
         * from the same section as the pgdat where possible to avoid
         * this problem.
        goal = __pa(pgdat) & (PAGE_SECTION_MASK << PAGE_SHIFT);
        limit = goal + (1UL << PA_SECTION_SHIFT);
        nid = early_pfn_to_nid(goal >> PAGE_SHIFT);
        p = memblock_alloc_try_nid_nopanic(size,
                                                SMP_CACHE_BYTES, goal, limit,
        if (!p && limit) {
                limit = 0;
                goto again;
        return p;

CONFIG_MEMORY_HOTREMOVE 커널 옵션을 사용하는 경우 use_map을 할당한다. 가능하면 노드 정보(pgdat)가 담겨 있는 섹션에 usemap이 들어갈 수 있도록 메모리 할당을 시도한다. 실패한 경우 위치에 상관없이 다시 한번 할당을 시도한다.

  • 코드 라인 16~17에서 goal에는 노드에서의 섹션 시작 물리 주소를 구하고 limit를 1개의 섹션 크기로 제한한다.
  • 코드 라인 18에서 기존에 mem_map에 저장해놓은 섹션별 노드 정보를 가져온다.
  • 코드 라인 20~22에서 지정된 노드의 goal~limit 범위, 즉 노드 정보가 담겨 있는 섹션 영역 내에서 SMP_CACHE_BYTES align으로 size만큼의 memblock 공간 할당을 요청한다.
  • 코드 라인 23~29에서 한 번 시도해서 할당이 안 되면 limit를 0으로 만들어 다시 한번 시도한다.


mem_map용 Sparse 버퍼 할당/해제

노드에 해당하는 전체 present 섹션 메모리에 대한 mem_map[] 배열을 한꺼번에 할당을 시도한다. 이렇게 시도하여 할당이 된 경우 이 sparse 버퍼 메모리를 mem_map[] 배열로 사용한다. 만일 할당이 실패하는 경우 fallback되어 그냥 섹션별로 할당한다.




static void __init sparse_buffer_init(unsigned long size, int nid)
        WARN_ON(sparsemap_buf); /* forgot to call sparse_buffer_fini()? */
        sparsemap_buf =
                memblock_alloc_try_nid_raw(size, PAGE_SIZE,
                                                MEMBLOCK_ALLOC_ACCESSIBLE, nid);
        sparsemap_buf_end = sparsemap_buf + size;

요청한 @size만큼 노드 @nid에서 페이지 단위로 sparse 버퍼를 할당한다.




void * __meminit sparse_buffer_alloc(unsigned long size)
        void *ptr = NULL;

        if (sparsemap_buf) {
                ptr = PTR_ALIGN(sparsemap_buf, size);
                if (ptr + size > sparsemap_buf_end)
                        ptr = NULL;
                        sparsemap_buf = ptr + size;
        return ptr;

Sparse 버퍼에서 @size 만큼의 메모리를 할당한다. (for mem_map)




static void __init sparse_buffer_fini(void)
        unsigned long size = sparsemap_buf_end - sparsemap_buf;

        if (sparsemap_buf && size > 0)
                memblock_free_early(__pa(sparsemap_buf), size);
        sparsemap_buf = NULL;

사용하고 남은 sparse 버퍼를 할당 해제한다.


usemap 할당 섹션 또는 노드 체크



static void __init check_usemap_section_nr(int nid, unsigned long *usemap)
        unsigned long usemap_snr, pgdat_snr;
        static unsigned long old_usemap_snr;
        static unsigned long old_pgdat_snr;
        struct pglist_data *pgdat = NODE_DATA(nid);
        int usemap_nid;

        /* First call */
        if (!old_usemap_snr) {
                old_usemap_snr = NR_MEM_SECTIONS;
                old_pgdat_snr = NR_MEM_SECTIONS;

        usemap_snr = pfn_to_section_nr(__pa(usemap) >> PAGE_SHIFT);
        pgdat_snr = pfn_to_section_nr(__pa(pgdat) >> PAGE_SHIFT);
        if (usemap_snr == pgdat_snr)

        if (old_usemap_snr == usemap_snr && old_pgdat_snr == pgdat_snr)
                /* skip redundant message */

        old_usemap_snr = usemap_snr;
        old_pgdat_snr = pgdat_snr;

        usemap_nid = sparse_early_nid(__nr_to_section(usemap_snr));
        if (usemap_nid != nid) {
                pr_info("node %d must be removed before remove section %ld\n",
                        nid, usemap_snr);
         * There is a circular dependency.
         * Some platforms allow un-removable section because they will just
         * gather other removable sections for dynamic partitioning.
         * Just notify un-removable section's number here.
        pr_info("Section %ld and %ld (node %d) have a circular dependency on usemap and pgdat allocaa
                usemap_snr, pgdat_snr, nid);

CONFIG_MEMORY_HOTREMOVE 커널 옵션을 사용하는 경우 usemap 섹션은 pgdat가 위치한 섹션에 있거나 그렇지 않다면 다른 섹션이 모두 삭제될 때까지 usemap이 위치한 섹션은 삭제되면 안 된다. 따라서 이에 대한 관계를 메시지로 알아보기 위한 루틴이다. 할당받은 usemap과 노드 정보(pgdat)가 기록된 섹션과 같지 않으면 정보를 출력한다. usemap 정보가 같은 노드 공간에 구성되지 않으면 메모리 핫리무브(hot remove) 동작 시 노드별로 메모리를 제거해야 할 때 circular dependancy 문제가 발생할 수 있다. 참고: memory hotplug: allocate usemap on the section with pgdat

  • 코드 라인 11~14에서 처음 호출 시 초깃값으로 진행 중인 섹션 번호를 담는다.
  • 코드 라인 16~19에서 usemap이 할당된 섹션과 노드 정보가 기록된 섹션이 같은 경우 정상이므로 함수를 빠져나간다.
  • 코드 라인 21~23에서 이미 한 번 진행하였던 섹션인 경우 skip 하기 위해 함수를 빠져나간다.
  • 코드 라인 25~26에서 같은 섹션 번호로 다시 한 번 진행하는 경우 skip 하기 위해 섹션 번호들을 기억해둔다.
  • 코드 라인 28~33에서 요청한 @nid에 usemap 노드가 없는 경우 use_map이 있는 섹션 정보를 먼저 hot remove 하여야 한다는 정보를 출력한다.
  • 코드 라인 40~41에서 요청한 @nid에 usemap이 있는 경우 메모리 핫리무브(hot remove) 동작 시 노드별로 메모리를 제거해야 할 때 circular dependancy 문제가 발생할 수 있다는 정보를 출력한다.




static inline int sparse_early_nid(struct mem_section *section)
        return (section->section_mem_map >> SECTION_NID_SHIFT);

mem_section 구조체 멤버 변수인 section_mem_map에서 노드 정보를 추출하여 리턴한다.




unsigned long usemap_size(void)
        return BITS_TO_LONGS(SECTION_BLOCKFLAGS_BITS) * sizeof(unsigned long);

usemap 사이즈를 리턴한다.

    • 섹션당 pageblock 비트 수 (pageblock_order=9일 때)
      • arm64=2048
  • 예) arm64
    • 2048 / 8=256(byte)



vmemmap을 사용하지 않을 때의 함수이다. arm64 디폴트 설정에서는 vmemmap을 사용하므로 이 함수를 사용하지 않는다.


struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid,
                struct vmem_altmap *altmap)
        unsigned long size = section_map_size();
        struct page *map = sparse_buffer_alloc(size);

        if (map)
                return map;

        map = memblock_alloc_try_nid(size,
                                          PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
                                          MEMBLOCK_ALLOC_ACCESSIBLE, nid);
        return map;

CONFIG_SPARSEMEM_VMEMMAP 커널 옵션을 사용하지 않는 시스템에서 미리 할당한 sparse 버퍼를 사용하여 mem_map[]을 할당해준다. 만일 실패하는 경우 별도로 섹션마다 mem_map[] 배열을 memblock 할당 요청한다.




static void __meminit sparse_init_one_section(struct mem_section *ms,
                unsigned long pnum, struct page *mem_map,
                unsigned long *pageblock_bitmap)
        ms->section_mem_map &= ~SECTION_MAP_MASK;
        ms->section_mem_map |= sparse_encode_mem_map(mem_map, pnum) |
        ms->pageblock_flags = pageblock_bitmap;

mem_map 영역을 엔코딩하여 mem_section에 연결하고 usemap 영역도 연결한다.


mem_map 주소의 엔코딩/디코딩

섹션별로 mem_map 주소를 지정할 때 하위 비트에는 몇 개의 플래그를 추가하는 것 이외에도, 해당 섹션의 mem_map에 대한 base 주소의 pfn 값을 뺀(-) 값으로 엔코딩하여 저장한다.이렇게 엔코딩하여 저장하는 경우 vmemmap을 사용하지 않는 시스템에서 pfn_to_page() 함수를 사용할 때 한 번의 산술연산이 절감되는 효과가 있다.

  • 예) 0x8000_0000 ~ 0xC000_0000 (1G)을 관리하는 섹션에 대한 mem_map 주소 – 0x80000(base pfn) + 플래그 값으로 엔코딩한다.




 * Subtle, we encode the real pfn into the mem_map such that
 * the identity pfn - section_mem_map will return the actual
 * physical page frame number.
static unsigned long sparse_encode_mem_map(struct page *mem_map, unsigned long pnum)
        unsigned long coded_mem_map =
                (unsigned long)(mem_map - (section_nr_to_pfn(pnum)));
        BUG_ON(coded_mem_map & ~SECTION_MAP_MASK);
        return coded_mem_map;

할당 받은 mem_map의 주소 – 섹션에 해당하는 base pfn 값을 엔코딩 값으로 반환한다.

  • vmemmap을 사용하지 않는 경우 pfn_to_page() 함수에서 산술 연산을 한 번 제거하는 효과가 있다.




 * Decode mem_map from the coded memmap
struct page *sparse_decode_mem_map(unsigned long coded_mem_map, unsigned long pnum)
        /* mask off the extra low bits of information */
        coded_mem_map &= SECTION_MAP_MASK;
        return ((struct page *)coded_mem_map) + section_nr_to_pfn(pnum);

엔코딩된 mem_map 주소에서 하위 3비트를 제거한 후 디코딩하여 mem_map 주소만 반환한다.



  • arm64에서는 CONFIG_SPARSEMEM_VMEMMAP을 기본적으로 사용한다.
  • 시스템 리소스가 충분하여 vmemmap을 사용하는 경우 pfn_to_page() 및 page_to_pfn() 함수의 동작이 가장 효과적으로 빨라진다.




struct page * __meminit sparse_mem_map_populate(unsigned long pnum, int nid)
        unsigned long start;
        unsigned long end;
        struct page *map;

        map = pfn_to_page(pnum * PAGES_PER_SECTION);
        start = (unsigned long)map;
        end = (unsigned long)(map + PAGES_PER_SECTION);

        if (vmemmap_populate(start, end, nid))
                return NULL;

        return map;

CONFIG_SPARSEMEM_VMEMMAP 커널 옵션을 사용하는 경우 mem_map 영역을 vmemmap 영역에 매핑한다.요청한 섹션으로 주소 범위를 구한 후 해당 주소 범위와 관련한 pgd, pud 및 pmd 테이블들에 구성되지 않은 테이블이 있는 경우 노드에서 페이지를 할당하여 구성하고 매핑한다.

  • sparse 버퍼에 할당된 mem_map 용 공간들을 pte 엔트리에 연결하여 매핑한다.




int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
                struct vmem_altmap *altmap)
        return vmemmap_populate_basepages(start, end, node);
int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
                struct vmem_altmap *altmap)
        unsigned long addr = start;
        unsigned long next;
        pgd_t *pgdp;
        pud_t *pudp;
        pmd_t *pmdp;

        do {
                next = pmd_addr_end(addr, end);

                pgdp = vmemmap_pgd_populate(addr, node);
                if (!pgdp)
                        return -ENOMEM;

                pudp = vmemmap_pud_populate(pgdp, addr, node);
                if (!pudp)
                        return -ENOMEM;

                pmdp = pmd_offset(pudp, addr);
                if (pmd_none(READ_ONCE(*pmdp))) {
                        void *p = NULL;

                        p = vmemmap_alloc_block_buf(PMD_SIZE, node);
                        if (!p)
                                return -ENOMEM;

                        pmd_set_huge(pmdp, __pa(p), __pgprot(PROT_SECT_NORMAL));
                } else
                        vmemmap_verify((pte_t *)pmdp, node, addr, next);
        } while (addr = next, addr != end);

        return 0;
#endif  /* CONFIG_ARM64_64K_PAGES */

요청 주소 범위와 관련한 pgd, pud 및 pmd 테이블들에 구성되지 않은 테이블이 있는 경우 노드에서 페이지를 할당하여 구성하고 매핑한다.

  • 4K 페이지를 사용하는 경우 ARM64_SWAPPER_USES_SECTION_MAPS 값은 1이다.


구조체 및 주요 변수



 * Permanent SPARSEMEM data:
 * 1) mem_section       - memory sections, mem_map's for valid memory
struct mem_section *mem_section[NR_SECTION_ROOTS]
struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT]

mem_section은 섹션 별로 mem_map[] 배열과 usemap[] 배열 정보와 연결된다.


mem_section 구조체


struct mem_section {
         * This is, logically, a pointer to an array of struct
         * pages.  However, it is stored with some other magic.
         * (see sparse.c::sparse_init_one_section())
         * Additionally during early boot we encode node id of
         * the location of the section here to guide allocation.
         * (see sparse.c::memory_present())
         * Making it a UL at least makes someone do a cast
         * before using it wrong.
        unsigned long section_mem_map;

        /* See declaration of similar field in struct zone */
        unsigned long *pageblock_flags;
         * If !SPARSEMEM, pgdat doesn't have page_ext pointer. We use
         * section. (see page_ext.h about this.)
        struct page_ext *page_ext;
        unsigned long pad;
         * WARNING: mem_section must be a power-of-2 in size for the
         * calculation and use of SECTION_ROOT_MASK to make sense.
  • section_mem_map
    • mem_map을 가리키는 주소로 엔코딩하여 사용된다.
      • page 단위로 정렬되어있다.
    • 다음의 하위 비트들을 추가 정보로 사용한다.
        • 섹션에 메모리가 있는지 여부를 표현한다.
      • bit1: SECTION_HAS_MEM_MAP
        • 섹션에 mem_map이 연결되었는지 여부를 표현한다.
        • 연결된 mem_map은 섹션 base pfn 값을 빼고 저장된다(엔코딩)
      • bit2: SECTION_IS_ONLINE
        • online 섹션 여부를 표현한다.
      • bits[3~]: 노드 번호
        • 노드 번호는 부트업 중에만 잠깐 사용된다.
  • pageblock_flags
    • usemap을 가리키는 주소



    • arm
      • 28,  32 (256M, 4G, Realview-PBX)
      • 26,  29 (64M, 512M, RPC)
      • 27, 32 (128M, 4G, SA1100)
    • 32bit arm with LPAE
      • 34, 36 (16G, 64G, Keystone)
    • arm64
      • 30, 48 (1G, 256T)
    • x86
      • 26, 32 (64M, 4G)
    • x86_32 with PAE
      • 29, 36 (512M, 64G)
    • x86_64
      • 27, 46 (128M, 64T)




<kernel v5.0>

노드 초기화

다음 그림은 미리 산출된 존 구획 정보를 넘겨받아 각 노드를 초기화하는 흐름을 보여준다.

  • NUMA 시스템의 경우 커널 파라미터등을 사용하여 movable 존을 추가할 수 있는데 이 때에는 각 노드의 last 존을 커널 파라미터에서 요청한 사이즈만큼 movable 존으로 분리하여 구획한다.
    • 각 노드의 last 존은 normal 존이다. 그러나 arm32에 NUMA 패치를 적용하여 동작시킨 경우 last 존은 highmem 이다.
  • arm64 아키텍처 커널 v4.7-rc1 부터 NUMA 설정을 지원한다. arm 아키텍처의 경우 별도의 NUMA 패치를 적용해야 한다.


다음 그림은 지정된 노드 정보와 사용 가능한 존 정보들을 초기화하는 흐름을 보여준다.


NUMA 시스템의 노드들 초기화


NUMA 아키텍처에서는 곧장 free_area_init_node() 함수를 호출하지 않고 먼저 이 함수를 호출한다.


 * free_area_init_nodes - Initialise all pg_data_t and zone data
 * @max_zone_pfn: an array of max PFNs for each zone
 * This will call free_area_init_node() for each active node in the system.
 * Using the page ranges provided by memblock_set_node(), the size of each
 * zone in each node and their holes is calculated. If the maximum PFN
 * between two adjacent zones match, it is assumed that the zone is empty.
 * For example, if arch_max_dma_pfn == arch_max_dma32_pfn, it is assumed
 * that arch_max_dma32_pfn has no pages. It is also assumed that a zone
 * starts where the previous one ended. For example, ZONE_DMA32 starts
 * at arch_max_dma_pfn.
void __init free_area_init_nodes(unsigned long *max_zone_pfn)
        unsigned long start_pfn, end_pfn;
        int i, nid;

        /* Record where the zone boundaries are */
        memset(arch_zone_lowest_possible_pfn, 0,
        memset(arch_zone_highest_possible_pfn, 0,

        start_pfn = find_min_pfn_with_active_regions();

        for (i = 0; i < MAX_NR_ZONES; i++) {
                if (i == ZONE_MOVABLE)

                end_pfn = max(max_zone_pfn[i], start_pfn);
                arch_zone_lowest_possible_pfn[i] = start_pfn;
                arch_zone_highest_possible_pfn[i] = end_pfn;

                start_pfn = end_pfn;

        /* Find the PFNs that ZONE_MOVABLE begins at in each node */
        memset(zone_movable_pfn, 0, sizeof(zone_movable_pfn));

        /* Print out the zone ranges */
        pr_info("Zone ranges:\n");
        for (i = 0; i < MAX_NR_ZONES; i++) {
                if (i == ZONE_MOVABLE)
                pr_info("  %-8s ", zone_names[i]);
                if (arch_zone_lowest_possible_pfn[i] ==
                        pr_cont("[mem %#018Lx-%#018Lx]\n",
                                        << PAGE_SHIFT,
                                        << PAGE_SHIFT) - 1);

        /* Print out the PFNs ZONE_MOVABLE begins at in each node */
        pr_info("Movable zone start for each node\n");
        for (i = 0; i < MAX_NUMNODES; i++) {
                if (zone_movable_pfn[i])
                        pr_info("  Node %d: %#018Lx\n", i,
                               (u64)zone_movable_pfn[i] << PAGE_SHIFT);

        /* Print out the early node map */
        pr_info("Early memory node ranges\n");
        for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid)
                pr_info("  node %3d: [mem %#018Lx-%#018Lx]\n", nid,
                        (u64)start_pfn << PAGE_SHIFT,
                        ((u64)end_pfn << PAGE_SHIFT) - 1);

        /* Initialise every node */
        for_each_online_node(nid) {
                pg_data_t *pgdat = NODE_DATA(nid);
                free_area_init_node(nid, NULL,
                                find_min_pfn_for_node(nid), NULL);

                /* Any memory on that node */
                if (pgdat->node_present_pages)
                        node_set_state(nid, N_MEMORY);
                check_for_memory(pgdat, nid);

모든 노드 및 ZONE 정보를 초기화하고 구성한다.

  • 코드 라인 12~23에서 인자로 받은 @max_zone_pfn 배열에서 모든 존을 순회하며 movable 존을 제외하고 각 zone의 경계를 구분한다.
    • arch_zone_lowest_possible_pfn[]에 각 존별로 시작 pfn 값이 지정된다.
    • arch_zone_highest_possible_pfn[]에 각 존별로 끝 pfn 값이 지정된다.
  • 코드 라인 26~27에서 노드별 ZONE_MOVABLE에 대한 시작 pfn 값을 zone_movable_pfn[ ]에 담아온다.
  • 코드 라인 30~44에서 movable 존을 제외한 각 존별 pfn 영역을 출력한다.
  • 코드 라인 47~52에서 각 노드에 등록된 movable 존 정보를 출력한다.
  • 코드 라인 55~59에서 각 노드의 등록된 early 노드 메모리 정보를 출력한다.
  • 코드 라인 62에서 page->flags에 들어갈 섹션 비트 수, 노드 비트 수, 존 비트 수 등을 점검한다.
  • 코드 라인 63에서 마지막 possible 노드 + 1을 전역 nr_node_ids에 설정한다.
  • 코드 라인 64에서 memory memblock이 커버하지 않는 홀을 포함하여 사용하지 않는 메모리 공간을 관리하는 page 구조체 내용을 0으로 채운다.
  • 코드 라인 65~68에서 모든 온라인 노드를 초기화한다.
  • 코드 라인 71~72에서 해당 노드에 가용 페이지가 있다면 해당 노드에 메모리가 존재함을 의미하는 메모리 노드 비트맵의 해당 노드 비트를 1로 설정한다.
  • 코드 라인 73에서 해당 노드의 활성화된 존이 하나라도 있는 경우 해당 노드에 대한 메모리 상태 정보에 normal 또는 highmem 상태를 저장한다.
    • 노드에 32bit 시스템에 highmem이 설정된 경우 N_HIGH_MEMORY, 그렇지 않은 경우 N_NORMAL_MEMORY 상태를 저장한다.


지정한 노드 초기화



void __init free_area_init_node(int nid, unsigned long *zones_size,
                                   unsigned long node_start_pfn,
                                   unsigned long *zholes_size)
        pg_data_t *pgdat = NODE_DATA(nid);
        unsigned long start_pfn = 0;
        unsigned long end_pfn = 0;

        /* pg_data_t should be reset to zero when it's allocated */
        WARN_ON(pgdat->nr_zones || pgdat->kswapd_classzone_idx);

        pgdat->node_id = nid;
        pgdat->node_start_pfn = node_start_pfn;
        pgdat->per_cpu_nodestats = NULL;
        get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
        pr_info("Initmem setup node %d [mem %#018Lx-%#018Lx]\n", nid,
                (u64)start_pfn << PAGE_SHIFT,
                end_pfn ? ((u64)end_pfn << PAGE_SHIFT) - 1 : 0);
        start_pfn = node_start_pfn;
        calculate_node_totalpages(pgdat, start_pfn, end_pfn,
                                  zones_size, zholes_size);



요청한 노드 @nidd의 모든 ZONE 정보를 초기화하고 구성한다.

  • 코드 라인 5~14 에서 노드에 속한 페이지를 관리하는 구조체 포인터를 알아온 후 노드 id와 노드의 시작 pfn 등을 설정한다.
    • UMA 아키텍처: &contig_page_data
  •  코드라인 15~16 에서 지정된 노드의 memory memblock에서 파편화되지 않은 페이지 프레임 시작 번호와 끝 번호를 알아온다.
      • memblock이 멀티 노드를 지원해야 할 때 사용한다.
  • 코드 라인 23~24에서 zones_size[]와 zholes_size[] 정보를 사용하여 노드 정보를 산출한 후 기록한다.
    • ZONE_MOVABLE이 있는 경우 메모리가 존재하는 마지막 zone의 영역이 조정된다.
  • 코드 라인 26에서 노드 별 mem_map을 할당한다.
    • page[] 구조체로 구성된 mem_map을 위해 memblock 할당을 한다
    • 이 루틴은 Sparse 메모리 모델이 아닌 경우에 동작된다.
      • Spasrse 메모리 모델을 사용하는 경우 mem_map은 이미 sparse_init() 함수에서 section_mem_map[]으로 구성되었다.
  • 코드 라인 27에서 메모리가 큰 시스템인 경우 page 구조체를 초기화하려면 많은 시간이 걸린다. 이러한 경우 시스템에 필요한 일부 메모리를 제외한 후  CONFIG_DEFERRED_STRUCT_PAGE_INIT 커널 옵션을 사용하여 별도의 커널 스레드가 동작시켜 나중에 page 구조체를 초기화한다. 즉 page 구조체 초기화를 유예시키는 옵션이다. 이 옵션은 아직 arm 및 arm64에서는 사용하지 않는다.
  • 코드 라인 29에서 노드의 zone 관리를 위해 zone 구조체와 관련된 정보들을 설정한다. 그리고 usemap을 할당하고 초기화하며, 버디 시스템에 사용하는 free_area[], lruvec, pcp 등도 초기화한다.


다음 그림은 1G 메모리를 가진 ARM32에서 존 구획이 나뉘는 모습을 보여준다.

  • 참고로 4G 이하 메모리를 사용하는 대부분의 ARM32는 ZONE_DMA를 사용하지 않는다.


다음 그림은 메모리 영역이 2개로 분리된 6G 메모리를 가진 ARM64에서 존 구획이 나뉘는 모습을 보여준다.


Movable 존 구성

NUMA 시스템에서는 대용량 메모리가 사용된다. 이러한 경우 특정 메모리 노드들에 대해 movable 페이지들만을 할당하도록 제한된 movable 존을 설정할 수 있다. movable 존은 시스템의 last 존의 영역을 나누어 사용한다. ARM32 시스템의 경우 마지막 존인 highmem 영역의 일부를 사용하고, ARM64의 경우 highmem을 사용하지 않으므로 마지막 존인 normal 영역의 일부를 사용한다. 시스템에서 마지막 존과 movable 존의 구획을 나누어 구성하는 다음 방법들을 알아본다.

  • “movable_node” 커널 파라미터 지정
    • hotplug 메모리 설정된 노드들을 모두 movable 존으로 설정한다.
    • 0번 노드는 hotplug 설정할 수 없다.
  • “kernelcore=mirror” 커널 파라미티 지정
    • 고신뢰성 확보를 위해 x86 시스템에서 일부 메모리를 mirror로 사용할 수 있다. 이렇게 신뢰성이 확보되는 영역의 사용에 커널 코어가 사용되도록 할 수 있다. 이런 경우에는 나머지 영역들은 movable zone으로 설정한다.
    • 이 옵션을 사용 시 4G 이하의 메모리 영역에 mirror 플래그가 설정되어 있어야 한다.
  • “kernelcore=nn” 커널 파라미터 지정
    • 전체 페이지에서 kernelcore로 지정된 용량을 제외한 나머지를 movablecore 페이지로 하고 이를 각 노드들에 배분하여 movable 존으로 설정한다.
  • “movablecore=nn” 커널 파라미터 지정
    • 전체 페이지에서 movablecore로 지정된 용량 만큼의 페이지를 각 노드들에 배분하여 movale 존으로 설정한다.


커널 v4.0 이후 다음과 같은 내용이 추가되었다.



mm/page_alloc.c -1/4-

 * Find the PFN the Movable zone begins in each node. Kernel memory
 * is spread evenly between nodes as long as the nodes have enough
 * memory. When they don't, some nodes will have more kernelcore than
 * others
static void __init find_zone_movable_pfns_for_nodes(void)
        int i, nid;
        unsigned long usable_startpfn;
        unsigned long kernelcore_node, kernelcore_remaining;
        /* save the state before borrow the nodemask */
        nodemask_t saved_node_state = node_states[N_MEMORY];
        unsigned long totalpages = early_calculate_totalpages();
        int usable_nodes = nodes_weight(node_states[N_MEMORY]);
        struct memblock_region *r;

        /* Need to find movable_zone earlier when movable_node is specified. */

         * If movable_node is specified, ignore kernelcore and movablecore
         * options.
        if (movable_node_is_enabled()) {
                for_each_memblock(memory, r) {
                        if (!memblock_is_hotpluggable(r))

                        nid = r->nid;

                        usable_startpfn = PFN_DOWN(r->base);
                        zone_movable_pfn[nid] = zone_movable_pfn[nid] ?
                                min(usable_startpfn, zone_movable_pfn[nid]) :

                goto out2;

         * If kernelcore=mirror is specified, ignore movablecore option
        if (mirrored_kernelcore) {
                bool mem_below_4gb_not_mirrored = false;

                for_each_memblock(memory, r) {
                        if (memblock_is_mirror(r))

                        nid = r->nid;

                        usable_startpfn = memblock_region_memory_base_pfn(r);

                        if (usable_startpfn < 0x100000) {
                                mem_below_4gb_not_mirrored = true;

                        zone_movable_pfn[nid] = zone_movable_pfn[nid] ?
                                min(usable_startpfn, zone_movable_pfn[nid]) :

                if (mem_below_4gb_not_mirrored)
                        pr_warn("This configuration results in unmirrored kernel memory.");

                goto out2;

노드별 movable 존 구획을 나눈다.

  • 코드 라인 8에서 모든 노드의 페이지 수를 알아온다.
  • 코드 라인 9에서 메모리가 있는 노드의 수를 알아온다.
  • 코드 라인 13에서 모든 zone에서 메모리가 있는 마지막 zone을 알아와서 전역 변수 movable_zone에 대입한다.
    • ZONE_MOVABLE은 마지막 zone의 일부 또는 전부를 사용하여 구성하게 된다.
  • 코드 라인 19~33에서 Hot-plug용 ZONE_MOVABLE을 구성하기 위해 노드별 zone movable의 시작 주소를 전역 zone_movable_pfn[] 배열에 산출한다.
    • CONFIG_MOVABLE_NODE 커널 옵션을 사용하면서 “movable_node” 커널 파라메터를 사용한 경우 true를 반환한다.
    • hotplug 설정이 있는 memblock의 시작 주소를 zone_movable_pfn[]에 대입하되 zone_movable_pfn[] 값보다 큰 경우에 한정 한다.
  • 코드 라인 38~63에서 “kernelcore=mirror” 커널 파라미터가 설정된 경우 “movablecore” 커널 파라미터는 무시한다.
    • 4G 이하의 메모리에 대해서는 mirror가 설정되어 있지 않은 경우 경고 메시지를 출력한다.


다음 그림은 “movable_node” 커널 파라미터를 사용하여 movable zone을 구성하는 모습을 보여준다.


다음 그림은 “movablecore=mirror” 커널 파라미터를 사용하여 movable zone을 구성하는 모습을 보여준다.


mm/page_alloc.c -2/4-

.       /*
         * If kernelcore=nn% or movablecore=nn% was specified, calculate the
         * amount of necessary memory.
        if (required_kernelcore_percent)
                required_kernelcore = (totalpages * 100 * required_kernelcore_percent) /
        if (required_movablecore_percent)
                required_movablecore = (totalpages * 100 * required_movablecore_percent) /

         * If movablecore= was specified, calculate what size of
         * kernelcore that corresponds so that memory usable for
         * any allocation type is evenly spread. If both kernelcore
         * and movablecore are specified, then the value of kernelcore
         * will be used for required_kernelcore if it's greater than
         * what movablecore would have allowed.
        if (required_movablecore) {
                unsigned long corepages;

                 * Round-up so that ZONE_MOVABLE is at least as large as what
                 * was requested by the user
                required_movablecore =
                        roundup(required_movablecore, MAX_ORDER_NR_PAGES);
                required_movablecore = min(totalpages, required_movablecore);
                corepages = totalpages - required_movablecore;

                required_kernelcore = max(required_kernelcore, corepages);

         * If kernelcore was not specified or kernelcore size is larger
         * than totalpages, there is no ZONE_MOVABLE.
        if (!required_kernelcore || required_kernelcore >= totalpages)
                goto out;
  • 코드 라인 5~7에서 퍼센트를 사용한 “kernelcore=nn%” 커널 파라미터에서 전체 페이지로부터 지정한 퍼센트를 커널 코어 페이지로 지정한다.
  • 코드 라인 8~10에서 퍼센트를 사용한 “movablecore=nn%” 커널 파라미터에서 전체 페이지로부터 지정한 퍼센트를 movable 코어 페이지로 지정한다.
  • 코드 라인 20~33에서”movablecore=” 커널 파라미터가 지정된 경우 “kernelcore=” 보다 우선하여 처리한다. 전체 페이지에서 movable로 지정한 페이지를 제외한 나머지를 커널 코어로 지정한다.
    • movable 페이지는 MAX_ORDER_NR_PAGES 단위로 올림 정렬하여 사용한다.
  • 코드 라인 39~40에서 커널 코어에 배정한 페이지가 없거나 전체 페이지보다 큰 경우 out 레이블을 통해 빠져나간다.


다음 그림은 “kernelcore=” 보다 “movablecore=” 커널 파라미터의 사용을 우선하는 것을 보여준다.



mm/page_alloc.c -3/4-

        /* usable_startpfn is the lowest possible pfn ZONE_MOVABLE can be at */ 
        usable_startpfn = arch_zone_lowest_possible_pfn[movable_zone];

        /* Spread kernelcore memory as evenly as possible throughout nodes */
        kernelcore_node = required_kernelcore / usable_nodes;
        for_each_node_state(nid, N_MEMORY) {
                unsigned long start_pfn, end_pfn;

                 * Recalculate kernelcore_node if the division per node
                 * now exceeds what is necessary to satisfy the requested
                 * amount of memory for the kernel
                if (required_kernelcore < kernelcore_node)
                        kernelcore_node = required_kernelcore / usable_nodes;

                 * As the map is walked, we track how much memory is usable
                 * by the kernel using kernelcore_remaining. When it is
                 * 0, the rest of the node is usable by ZONE_MOVABLE
                kernelcore_remaining = kernelcore_node;

                /* Go through each range of PFNs within this node */
                for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
                        unsigned long size_pages;

                        start_pfn = max(start_pfn, zone_movable_pfn[nid]);
                        if (start_pfn >= end_pfn)

                        /* Account for what is only usable for kernelcore */
                        if (start_pfn < usable_startpfn) {
                                unsigned long kernel_pages;
                                kernel_pages = min(end_pfn, usable_startpfn)
                                                                - start_pfn;

                                kernelcore_remaining -= min(kernel_pages,
                                required_kernelcore -= min(kernel_pages,

                                /* Continue if range is now fully accounted */
                                if (end_pfn <= usable_startpfn) {

                                         * Push zone_movable_pfn to the end so
                                         * that if we have to rebalance
                                         * kernelcore across nodes, we will
                                         * not double account here
                                        zone_movable_pfn[nid] = end_pfn;
                                start_pfn = usable_startpfn;

                         * The usable PFN range for ZONE_MOVABLE is from
                         * start_pfn->end_pfn. Calculate size_pages as the
                         * number of pages used as kernelcore
                        size_pages = end_pfn - start_pfn;
                        if (size_pages > kernelcore_remaining)
                                size_pages = kernelcore_remaining;
                        zone_movable_pfn[nid] = start_pfn + size_pages;

                         * Some kernelcore has been met, update counts and
                         * break if the kernelcore for this node has been
                         * satisfied
                        required_kernelcore -= min(required_kernelcore,
                        kernelcore_remaining -= size_pages;
                        if (!kernelcore_remaining)
  • 코드 라인 2에서 루프를 돌기 전에 가장 아래에 위치한 movable 존의 시작 pfn 값을 usable_startpfn에 지정한다.
    • 이 usable_startpfn 보다 아래에 있는 영역들은 커널 코어에 해당한다.
  • 코드 라인 4~6에서 restart 레이블을 통해 반복되는 경우 요청 커널 코어 페이지 수를 메모리 노드로 나눈 노드별 커널 코어 페이지 수를 산출한다.
  • 코드 라인 7~16에서 메모리 memblock을 순회하며요청 코어 페이지가 노드별 커널 코어 페이지보다 적어진 경우 요청 커널 코어 페이지를 미처리된 메모리 노드로 나눠 노드별 커널 코어 페이지 수를 재산출한다.
  • 코드 라인 26~31에서 메모리 memblock을 순회하며 시작 pfn과 끝 pfn을 알아오고, 해당 메모리 영역 사이에 노드의 movable pfn 경계가 없는 경우 movable 영역으로 처리할 필요가 없으므로 skip 한다.
    • 노드의 첫 memblock 영역을 처리할 때 zone_movable_pfn[nid] 값은 처음에 0 이므로 이 조건에 걸리지 않는다.
  • 코드 라인 34~57에서 커널 코어 영역으로 사용할 페이지 양을 결정한다.
  • 코드 라인 64~67에서 현재 진행되고 있는 노드의 movable 존을 산출하기 위해 현재까지 처리한 커널 코어 양의 끝 위치를 zone_movable_pfn[nid]에 저장해둔다.
  • 코드 라인 74~78에서 커널 코어 잔량 처리를 수행한다.


다음 그림은 “kernelcore=nn” 또는 “movablecore” 커널 파라미터를 사용하여 movable zone을 각 노드에 고르게 분배하여 구성하는 모습을 보여준다.


mm/page_alloc.c -4/4-

         * If there is still required_kernelcore, we do another pass with one
         * less node in the count. This will push zone_movable_pfn[nid] further
         * along on the nodes that still have memory until kernelcore is
         * satisfied
        if (usable_nodes && required_kernelcore > usable_nodes)
                goto restart;

        /* Align start of ZONE_MOVABLE on all nids to MAX_ORDER_NR_PAGES */
        for (nid = 0; nid < MAX_NUMNODES; nid++)
                zone_movable_pfn[nid] =
                        roundup(zone_movable_pfn[nid], MAX_ORDER_NR_PAGES);

        /* restore the node_state */
        node_states[N_MEMORY] = saved_node_state;
  • 코드 라인 7~9에서 커널 코어에 필요한 페이지가 모두 배정되지 않은 경우 다시 한 번 restart 레이블로 이동하여 처리한다.
  • 코드 라인 11~15에서 out2: 레이블에서는 zone_movable_pfn[] 배열 값을 MAX_ORDER_NR_PAGES 단위로 올림 정렬하도록 한다.
  • 코드 라인 17~19에서 이 함수의 처음에 저장해 둔 메모리 노드 비트맵을 복원한다.


다음 그림은 “kernelcore=”로 지정된 페이지 수를 가용 노드 만큼 나누어 배치를 하고 이에 대한 끝 주소를 zone_movable_pfn[] 배열에 저장하는 모습을 보여준다. 이 값은 추후 각 노드별 ZONE_MOVABLE이 시작되는 주소를 설정하는데 사용된다.



다음 4개의 그림은 NUMA 시스템에서 “kernelcore=” 커널 파라메터 값에 따라 ZONE_MOVABLE 영역이 지정되는 모습을 보여준다.







 * This finds a zone that can be used for ZONE_MOVABLE pages. The
 * assumption is made that zones within a node are ordered in monotonic
 * increasing memory addresses so that the "highest" populated zone is used
static void __init find_usable_zone_for_movable(void)
        int zone_index;
        for (zone_index = MAX_NR_ZONES - 1; zone_index >= 0; zone_index--) {
                if (zone_index == ZONE_MOVABLE)

                if (arch_zone_highest_possible_pfn[zone_index] >

        VM_BUG_ON(zone_index == -1);
        movable_zone = zone_index;

가용 zone에서 가장 높이 위치한 zone 인덱스 값을 전역 변수 movable_zone에 저장한다.






 * get_pfn_range_for_nid - Return the start and end page frames for a node
 * @nid: The nid to return the range for. If MAX_NUMNODES, the min and max PFN are returned.
 * @start_pfn: Passed by reference. On return, it will have the node start_pfn.
 * @end_pfn: Passed by reference. On return, it will have the node end_pfn.
 * It returns the start and end page frame of a node based on information
 * provided by memblock_set_node(). If called for a node
 * with no available memory, a warning is printed and the start and end
 * PFNs will be 0.
void __init get_pfn_range_for_nid(unsigned int nid,
                        unsigned long *start_pfn, unsigned long *end_pfn)
        unsigned long this_start_pfn, this_end_pfn;
        int i;

        *start_pfn = -1UL;
        *end_pfn = 0;

        for_each_mem_pfn_range(i, nid, &this_start_pfn, &this_end_pfn, NULL) {
                *start_pfn = min(*start_pfn, this_start_pfn);
                *end_pfn = max(*end_pfn, this_end_pfn);

        if (*start_pfn == -1UL)
                *start_pfn = 0;

해당 노드 @nid의 memory memblock 에서 해당 페이지가 파편화되지 않고 온전히 포함된 페이지 번호만을 찾아 시작 pfn과 끝 pfn으로 알아온다.

  • 만일 노드 지정에 MAX_NUMNODES가 지정되면 DRAM의 min_pfn과 max_pfn이 리턴된다.
  • 참고: for_each_mem_pfn_range() 함수 -> Memblock (2) | 문c


노드 및 노드의 모든 존별 spanned 및 present 페이지 산출



static void __init calculate_node_totalpages(struct pglist_data *pgdat,
                                                unsigned long node_start_pfn,
                                                unsigned long node_end_pfn,
                                                unsigned long *zones_size,
                                                unsigned long *zholes_size)
        unsigned long realtotalpages = 0, totalpages = 0;
        enum zone_type i;

        for (i = 0; i < MAX_NR_ZONES; i++) {
                struct zone *zone = pgdat->node_zones + i;
                unsigned long zone_start_pfn, zone_end_pfn;
                unsigned long size, real_size;

                size = zone_spanned_pages_in_node(pgdat->node_id, i,
                real_size = size - zone_absent_pages_in_node(pgdat->node_id, i,
                                                  node_start_pfn, node_end_pfn,
                if (size)
                        zone->zone_start_pfn = zone_start_pfn;
                        zone->zone_start_pfn = 0;
                zone->spanned_pages = size;
                zone->present_pages = real_size;

                totalpages += size;
                realtotalpages += real_size;

        pgdat->node_spanned_pages = totalpages;
        pgdat->node_present_pages = realtotalpages;
        printk(KERN_DEBUG "On node %d totalpages: %lu\n", pgdat->node_id,

요청 노드 및 요청 노드에 대한 모든 존별로 홀을 포함한 spanned_pages와 실제 사용할 수 있는 페이지인 present_pages를 구한다.

  • pgdat->node_spanned_pages 및 pgdat->node_present_pages 멤버에 노드에 대해 산출한 spanned 및 present 페이지를 저장한다.
  • 존별 zone->spanned_pages 및 zone->present_pages 멤버에 각 존에 대해 산출한 spanned 및 present 페이지를 저장한다.


다음 그림은 0번 노드에서 normal 존과 0번 노드 전체에 대한 spanned 및 present 페이지를 구하는 모습을 보여준다.



spanned 페이지 산출 – 작업중



 * Return the number of pages a zone spans in a node, including holes
 * present_pages = zone_spanned_pages_in_node() - zone_absent_pages_in_node()
static unsigned long __init zone_spanned_pages_in_node(int nid,
                                        unsigned long zone_type,
                                        unsigned long node_start_pfn,
                                        unsigned long node_end_pfn,
                                        unsigned long *zone_start_pfn,
                                        unsigned long *zone_end_pfn,
                                        unsigned long *ignored)
        /* When hotadd a new node from cpu_up(), the node should be empty */
        if (!node_start_pfn && !node_end_pfn)
                return 0;

        /* Get the start and end of the zone */
        *zone_start_pfn = arch_zone_lowest_possible_pfn[zone_type];
        *zone_end_pfn = arch_zone_highest_possible_pfn[zone_type];
        adjust_zone_range_for_zone_movable(nid, zone_type,
                                node_start_pfn, node_end_pfn,
                                zone_start_pfn, zone_end_pfn);

        /* Check that this node has pages within the zone's required range */
        if (*zone_end_pfn < node_start_pfn || *zone_start_pfn > node_end_pfn)
                return 0;

        /* Move the zone boundaries inside the node if necessary */
        *zone_end_pfn = min(*zone_end_pfn, node_end_pfn);
        *zone_start_pfn = max(*zone_start_pfn, node_start_pfn);

        /* Return the spanned pages */
        return *zone_end_pfn - *zone_start_pfn;
static inline unsigned long __init zone_spanned_pages_in_node(int nid,
                                        unsigned long zone_type,
                                        unsigned long node_start_pfn,
                                        unsigned long node_end_pfn,
                                        unsigned long *zone_start_pfn,
                                        unsigned long *zone_end_pfn,
                                        unsigned long *zones_size)
        unsigned int zone;

        *zone_start_pfn = node_start_pfn;
        for (zone = 0; zone < zone_type; zone++)
                *zone_start_pfn += zones_size[zone];

        *zone_end_pfn = *zone_start_pfn + zones_size[zone_type];

        return zones_size[zone_type];

해당 노드에 대해 요청 zone의 hole을 포함한 페이지 수를 알아온다. NUMA 시스템에서는 ZONE_MOVABLE을 사용하는 경우가 있으므로 이 때 highest zone의 영역의 일정 양을 나누어 사용하므로 이에 대한 페이지 수 계산을 해야 한다. UMA의 경우 간단하므로 설명은 생략한다.

  • 코드 라인 19~23에서 movable 존이 사용되는 경우 실제 movable 가능한 페이지 영역을 기준으로 last 존 의 영역을 조정한다.
  • 코드 라인 30에서 zone 끝 pfn 값이 노드 끝 pfn 값을 초과하지 않도록 한다.
  • 코드 라인 31에서 zone 시작 pfn 값이 노드 시작 pfn 값보다 작지 않도록 한다.
  • 코드 라인 34에서 재조정된 zone의 hole을 포함한 페이지 수를 리턴한다.


absent 페이지 산출



/* Return the number of page frames in holes in a zone on a node */
static unsigned long __init zone_absent_pages_in_node(int nid,
                                        unsigned long zone_type,
                                        unsigned long node_start_pfn,
                                        unsigned long node_end_pfn,
                                        unsigned long *ignored)
        unsigned long zone_low = arch_zone_lowest_possible_pfn[zone_type];
        unsigned long zone_high = arch_zone_highest_possible_pfn[zone_type];
        unsigned long zone_start_pfn, zone_end_pfn;
        unsigned long nr_absent;

        /* When hotadd a new node from cpu_up(), the node should be empty */
        if (!node_start_pfn && !node_end_pfn)
                return 0;

        zone_start_pfn = clamp(node_start_pfn, zone_low, zone_high);
        zone_end_pfn = clamp(node_end_pfn, zone_low, zone_high);

        adjust_zone_range_for_zone_movable(nid, zone_type,
                        node_start_pfn, node_end_pfn,
                        &zone_start_pfn, &zone_end_pfn);
        nr_absent = __absent_pages_in_range(nid, zone_start_pfn, zone_end_pfn);

         * ZONE_MOVABLE handling.
         * Treat pages to be ZONE_MOVABLE in ZONE_NORMAL as absent pages
         * and vice versa.
        if (mirrored_kernelcore && zone_movable_pfn[nid]) {
                unsigned long start_pfn, end_pfn;
                struct memblock_region *r;

                for_each_memblock(memory, r) {
                        start_pfn = clamp(memblock_region_memory_base_pfn(r),
                                          zone_start_pfn, zone_end_pfn);
                        end_pfn = clamp(memblock_region_memory_end_pfn(r),
                                        zone_start_pfn, zone_end_pfn);

                        if (zone_type == ZONE_MOVABLE &&
                                nr_absent += end_pfn - start_pfn;

                        if (zone_type == ZONE_NORMAL &&
                                nr_absent += end_pfn - start_pfn;

        return nr_absent;
static inline unsigned long __init zone_absent_pages_in_node(int nid,
                                                unsigned long zone_type,
                                                unsigned long node_start_pfn,
                                                unsigned long node_end_pfn,
                                                unsigned long *zholes_size)
        if (!zholes_size)
                return 0;

        return zholes_size[zone_type];

해당 노드에 대해 요청 zone에서 빈 공간(hole) 페이지 수를 알아온다.

  • CONFIG_HAVE_MEMBLOCK_NODE_MAP 옵션 사용 여부에 따라 빌드되어 호출되는 함수가 다르다.
    • NUMA 시스템에서 옵션을 사용하지 않는 경우(멀티 노드이지만 주소가 연속된 노드로 구성)와 UMA 시스템에서는 해당 노드에서 관리하는 zone의 페이지들이 모두 연속적이어서 특별히 계산 없이 zholes_size[]에 있는 값을 리턴한다.
    • 옵션을 사용하는 경우는 노드 내에 memory block들이 연속되지 않을 때에 빈 공간(hole) 페이지 수를 계산하기 위해 사용한다.
  • 코드 라인 18에서 node_start_pfn 값을 zone 영역으로 들어가도록 조정하여 zone 시작 pfn으로 대입한다.
  • 코드 라인 19에서 node_end_pfn 값을 zone 영역으로 들어가도록 조정하여 zone 끝 pfn으로 대입한다.
  • 코드 라인 21~23에서 실제 movable 가능한 페이지 영역을 기준으로 zone 들의 영역을 조정한다.
  • 코드 라인 24에서 지정된 영역내에서 빈 공간(hole) 페이지 수를 알아온다.
  • 코드 라인 31~49에서 mirrored 커널 코어를 사용한 경우 movable 페이지들을 absent 페이지로 카운트 한다.
  • 코드 라인 51에서 absent 페이지 수를 반환한다.




 * Return the number of holes in a range on a node. If nid is MAX_NUMNODES,
 * then all holes in the requested range will be accounted for.
unsigned long __meminit __absent_pages_in_range(int nid,
                                unsigned long range_start_pfn,
                                unsigned long range_end_pfn)
        unsigned long nr_absent = range_end_pfn - range_start_pfn;
        unsigned long start_pfn, end_pfn;
        int i;

        for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
                start_pfn = clamp(start_pfn, range_start_pfn, range_end_pfn);
                end_pfn = clamp(end_pfn, range_start_pfn, range_end_pfn);
                nr_absent -= end_pfn - start_pfn;
        return nr_absent;

지정된 영역내에서 빈 공간(hole) 페이지 수를 알아온다.

  • 코드 라인 5에서 nr_absent  초기값을 영역에 대한 페이지 수로 한다.
  • 코드 라인 9에서 노드 번호에 해당하는 memory memblock에서 파편화된 페이지를 제외한 즉 온전한 페이지가 1개 이상인 경우의 시작 pfn과 끝 pfn 값을 루프를 돌며 하나씩 알아온다.
  • 코드 라인 10에서 영역에 들어가게 start_pfn 값을 바꾼다.
  • 코드 라인 11에서 영역에 들어가게 end_pfn 값을 바꾼다.
  • 코드 라인 12에서 영역에 포함된 페이지 수를 빼면 사용할 수 없는 페이지 수가 계산된다.
  • 코드 라인 14에서 absent 페이지를 반환한다.


아래 그림은 함수 처리 예를 보인다. (실제 NUMA 시스템 사용 사례는 아니므로 계산에 참고만 한다.)



movable 존에 맞춰 각 존 조정



 * The zone ranges provided by the architecture do not include ZONE_MOVABLE
 * because it is sized independent of architecture. Unlike the other zones,
 * the starting point for ZONE_MOVABLE is not fixed. It may be different
 * in each node depending on the size of each node and how evenly kernelcore
 * is distributed. This helper function adjusts the zone ranges
 * provided by the architecture for a given node by using the end of the
 * highest usable zone for ZONE_MOVABLE. This preserves the assumption that
 * zones within a node are in order of monotonic increases memory addresses
static void __init adjust_zone_range_for_zone_movable(int nid,
                                        unsigned long zone_type,
                                        unsigned long node_start_pfn,
                                        unsigned long node_end_pfn,
                                        unsigned long *zone_start_pfn,
                                        unsigned long *zone_end_pfn)
        /* Only adjust if ZONE_MOVABLE is on this node */
        if (zone_movable_pfn[nid]) {
                /* Size ZONE_MOVABLE */
                if (zone_type == ZONE_MOVABLE) {
                        *zone_start_pfn = zone_movable_pfn[nid];
                        *zone_end_pfn = min(node_end_pfn,

                /* Adjust for ZONE_MOVABLE starting within this range */
                } else if (!mirrored_kernelcore &&
                        *zone_start_pfn < zone_movable_pfn[nid] &&
                        *zone_end_pfn > zone_movable_pfn[nid]) {
                        *zone_end_pfn = zone_movable_pfn[nid];

                /* Check if this whole range is within ZONE_MOVABLE */
                } else if (*zone_start_pfn >= zone_movable_pfn[nid])
                        *zone_start_pfn = *zone_end_pfn;

실제 movable 가능한 페이지 영역을 기준으로 현재 zone의 영역을 다음과 같이 조정 한다.

  • 처리할 zone이 ZONE_MOVABLE인 경우 실제 movable 가능한 페이지 범위로 조정한다.
  • 처리할 zone이 ZONE_MOVABLE이 아닌 경우 movable 가능한 페이지 범위와 겹치지 않도록 조정한다.
  • 코드 라인 9에서 해당 노드에 movable 존이 있는 경우
  • 코드 라인 11~14에서 현재 zone이 ZONE_MOVABLE인 경우 zone 시작 pfn 에 zone_movable_pfn[nid] 값을 대입하고, zone 끝 pfn을 moveable 가능한 페이지 번호로 줄인다.
  • 코드 라인 17~20에서 mirrored 커널 코어가 아니면서 노드의 메모리 일부가 ZONE_MOVABLE로 구성한 경우 last zone의 끝 주소를 조정한다.
  • 코드 라인 23~24에서 요청 zone이 movable 영역보다 높은 경우 잘못 요청한 경우 이므로 zone 시작 pfn에 zone 끝 pfn 값을 대입하여 요청 zone의 size가 0이되게 하여 이 zone을 처리하지 않게 한다. 


Flat 메모리 모델에서 노드용 mem_map 할당



static void __ref alloc_node_mem_map(struct pglist_data *pgdat)
        unsigned long __maybe_unused start = 0;
        unsigned long __maybe_unused offset = 0;

        /* Skip empty nodes */
        if (!pgdat->node_spanned_pages)

        start = pgdat->node_start_pfn & ~(MAX_ORDER_NR_PAGES - 1);
        offset = pgdat->node_start_pfn - start;
        /* ia64 gets its own node_mem_map, before this, without bootmem */
        if (!pgdat->node_mem_map) {
                unsigned long size, end;
                struct page *map;

                 * The zone's endpoints aren't required to be MAX_ORDER
                 * aligned but the node_mem_map endpoints must be in order
                 * for the buddy allocator to function correctly.
                end = pgdat_end_pfn(pgdat);
                end = ALIGN(end, MAX_ORDER_NR_PAGES);
                size =  (end - start) * sizeof(struct page);
                map = memblock_alloc_node_nopanic(size, pgdat->node_id);
                pgdat->node_mem_map = map + offset;
        pr_debug("%s: node %d, pgdat %08lx, node_mem_map %08lx\n",
                                __func__, pgdat->node_id, (unsigned long)pgdat,
                                (unsigned long)pgdat->node_mem_map);
         * With no DISCONTIG, the global mem_map is just set as node 0's
        if (pgdat == NODE_DATA(0)) {
                mem_map = NODE_DATA(0)->node_mem_map;
                if (page_to_pfn(mem_map) != pgdat->node_start_pfn)
                        mem_map -= offset;
static void __ref alloc_node_mem_map(struct pglist_data *pgdat) { }

page[] 구조체로 구성된 flat 메모리 모델용 mem_map을 위해 memblock 할당을 한다. (ARM64의 경우 sparse 메모리 모델을 사용한다.)

  • 코드 라인 8~9에서 노드에 사용 가능한 메모리 페이지 영역이 없는 경우 리턴한다.
  • 코드 라인 11~12에서 노드 시작 pfn을 버디 할당자용 최대 페이지 요청의 절반 단위로 정렬하고, 정렬하여 조정된 만큼을 offset에 저장한다.
  • 코드 라인 14~28에서 ia64 시스템에서는 별도의 mem_map이 미리 지정되어 있다. 따라서 나머지 시스템을 위해 flat 메모리 모델용 mem_map을 할당한다.
  • 코드 라인 29~31에서 노드에 대한 mem_map 정보를 출력한다.
  • 코드 라인 32~37에서 싱글 노드의 경우 mem_map 전역 변수에 할당된 mem_map을 지정한다.
  • 코드 라인 38~41에서 flat 메모리 모델을 사용하는 2M 이하를 사용하는 arm 보드에 문제가 있어 offset을 제거하는 패치를 사용하였다.


다음 그림은 지정된 노드에 대한 mem_map[]을 할당 받아 노드 구조체의 node_mem_map에 연결시키는 모습을 보여준다.


노드 및 노드에 해당하는 존 초기화



 * Set up the zone data structures:
 *   - mark all pages reserved
 *   - mark all memory queues empty
 *   - clear the memory bitmaps
 * NOTE: pgdat should get zeroed by caller.
 * NOTE: this function is only called during early init.
static void __init free_area_init_core(struct pglist_data *pgdat)
        enum zone_type j;
        int nid = pgdat->node_id;

        pgdat->per_cpu_nodestats = &boot_nodestats;

        for (j = 0; j < MAX_NR_ZONES; j++) {
                struct zone *zone = pgdat->node_zones + j;
                unsigned long size, freesize, memmap_pages;
                unsigned long zone_start_pfn = zone->zone_start_pfn;

                size = zone->spanned_pages;
                freesize = zone->present_pages;

                 * Adjust freesize so that it accounts for how much memory
                 * is used by this zone for memmap. This affects the watermark
                 * and per-cpu initialisations
                memmap_pages = calc_memmap_size(size, freesize);
                if (!is_highmem_idx(j)) {
                        if (freesize >= memmap_pages) {
                                freesize -= memmap_pages;
                                if (memmap_pages)
                                               "  %s zone: %lu pages used for memmap\n",
                                               zone_names[j], memmap_pages);
                        } else
                                pr_warn("  %s zone: %lu pages exceeds freesize %lu\n",
                                        zone_names[j], memmap_pages, freesize);

                /* Account for reserved pages */
                if (j == 0 && freesize > dma_reserve) {
                        freesize -= dma_reserve;
                        printk(KERN_DEBUG "  %s zone: %lu pages reserved\n",
                                        zone_names[0], dma_reserve);

                if (!is_highmem_idx(j))
                        nr_kernel_pages += freesize;
                /* Charge for highmem memmap if there are enough kernel pages */
                else if (nr_kernel_pages > memmap_pages * 2)
                        nr_kernel_pages -= memmap_pages;
                nr_all_pages += freesize;

                 * Set an approximate value for lowmem here, it will be adjusted
                 * when the bootmem allocator frees pages into the buddy system.
                 * And all highmem pages will be managed by the buddy system.
                zone_init_internals(zone, j, nid, freesize);

                if (!size)

                setup_usemap(pgdat, zone, zone_start_pfn, size);
                init_currently_empty_zone(zone, zone_start_pfn, size);
                memmap_init(size, nid, j, zone_start_pfn);

지정된 노드의 zone 관리를 위해 zone 구조체와 관련된 정보들을 설정한다. 그리고 usemap을 할당하고 초기화하며, 버디 시스템에 사용하는 free_area[], lruvec, pcp 등도 초기화한다.

  • 코드 라인 6에서 노드에서 사용하는 내부 락 및 큐등을 초기화한다.
  • 코드 라인 7에서 per cpu 노드 stat을 지정한다.
  • 코드 라인 9~22에서 zone 수 만큼 순회하며, page 구조체 배열이 들어갈 페이지 수를 구한다.
  • 코드 라인 23~33에서 highmem 존이 아닌 경우 freesize에서 memmap에 사용될 pages 수 만큼을 감소시킨다.
  • 코드 라인 36~40에서 freesize에서 dma_reserve에 사용될 pages 수 만큼을 감소시킨다.
  • 코드 라인 42~43에서 highmem 존이 아닌 경우 전역 변수 nr_kernel_pages 에 freesize를 추가한다.
  • 코드 라인 45~46에서 nr_kernel_pages가 memmap_pages * 2 보다 큰 경우 nr_kernel_pages에서 memmap_pages 만큼 줄인다.
    • memmap은 보통 lowmem 영역에 할당되는데, 메모리가 무척 큰 32 비트 시스템에서는 lowmem 영역이 작아 memmap을 모두 lowmem에 할당하기에는 부담스러워진다. 이렇게 memmap 영역이 lowmem 영역의 절반 이상을 차지 하는 경우 memmap을 highmem에 생성한다.
  • 코드 라인 47에서전역 변수 nr_all_pages에 freesize를 추가한다.
    • nr_kernel_pages와 nr_all_pages 값은 각 zone의 워터마크를 설정할 때 사용된다.
    • nr_kernel_pages=
      • lowmem pages – mem_map pages(highmem 제외) – dma_reserve
        • 조건: highmem memmap 비중이 lowmem의 절반 이하일 때 – mem_map pages(highmem)
    • nr_all_pages=
      • lowmem pages – mem_map pages(highmem 제외) – dma_reserve + highmem pages
    • 두 개의 변수는 alloc_large_system_hash()에서 해쉬의 크기를 결정할 때 엔트리 크기가 지정되지 않을 경우 메모리의 크기에 비례하여 만들기 위해 사용된다.
      • 예) uhash_entries=, ihash_entries=, dhash_entries=, mhash_entries=
  • 코드 라인 54에서 존에 대한 내부 정보를 초기화한다.
  • 코드 라인 56~57에서 사이즈가 0이 된 경우 다음 존을 처리한다.
  • 코드 라인 60에서 zone별로 usemap을 memblock에 할당 받는다.
  • 코드 라인 61에서 wait table에 대한 해시 엔트리 수를 결정하고 관련 메모리를 할당 받은 후 초기화(waitqueue 및 spinlock) 하고 버디시스템에서 사용하는 free_area[].free_list[]를 초기화한다.
  • 코드 라인 62에서 mem_map의 각 멤버를 초기화한다.


다음 그림은 각 zone의 managed_pages와 전역 nr_kernel_pages 및 nr_all_pages를 한눈에 알아볼 수 있도록 도식화하였다



다음 그림은 위에서 산출한 값을 실제 연산과정으로 살펴보았다.



다음은 ZONE_NORMAL만 있는 경우의 예(rpi2)로 산출한 사례이다.


1) 내부 노드 데이터 초기화



static void __meminit pgdat_init_internals(struct pglist_data *pgdat)




노드에서 사용하는 내부 락 및 큐등을 초기화한다.

  • 코드 라인 3에서 node_size_lock 초기화
  • 코드 라인 5에서 split 큐를 초기화한다.
  • 코드 라인 6에서 kcompactd용 대기큐를 초기화한다.
  • 코드 라인 8에서 kswapd용 대기큐를 초기화한다.
  • 코드 라인 9에서 pfmemalloc용 대기큐를 초기화한다.
  • 코드 라인 11에서 CONFIG_SPARSEMEM 커널 옵션이 설정되어 있지 않으면 pgdat->node_page_ext에 NULL을 대입한다.
  • 코드 라인 12에서 lru용 락을 초기화한다.
  • 코드 라인 13에서 lruvec 리스트를 초기화한다.




void lruvec_init(struct lruvec *lruvec)
        enum lru_list lru;

        memset(lruvec, 0, sizeof(struct lruvec));


lruvec 리스트를 초기화한다.


2) mem_map 사이즈 산출



static unsigned long __paginginit calc_memmap_size(unsigned long spanned_pages,
                                                   unsigned long present_pages)
        unsigned long pages = spanned_pages;

         * Provide a more accurate estimation if there are holes within
         * the zone and SPARSEMEM is in use. If there are holes within the
         * zone, each populated memory region may cost us one or two extra
         * memmap pages due to alignment because memmap pages for each
         * populated regions may not naturally algined on page boundary.
         * So the (present_pages >> 4) heuristic is a tradeoff for that.
        if (spanned_pages > present_pages + (present_pages >> 4) &&
                pages = present_pages;

        return PAGE_ALIGN(pages * sizeof(struct page)) >> PAGE_SHIFT;

spanned size 수 만큼 page 구조체 배열이 들어갈 페이지 수를 구한다.

  • 다만 CONFIG_SPARSEMEM 커널 옵션을 사용하는 경우에는 spanned size가 real size 수의 125% 만큼 보다 큰 경우 spanned size 대신 real size를 대신 사용한다.


3) 내부 존 데이터 초기화



static void __meminit zone_init_internals(struct zone *zone, enum zone_type idx, int nid,
                                                        unsigned long remaining_pages)
        atomic_long_set(&zone->managed_pages, remaining_pages);
        zone_set_nid(zone, nid);
        zone->name = zone_names[idx];
        zone->zone_pgdat = NODE_DATA(nid);

zone 내부에서 사용하는 락 및 리스트 등을 초기화한다.

  • 코드 라인 4에서 managed_pages 값에 remaining_pages를 대입한다.
  • 코드 라인 5에서 존에 노드 id를 설정한다.
  • 코드 라인 6에서 존 이름을 지정한다.
  • 코드 라인 7에서 존에 해당하는 노드를 지정한다.
  • 코드 라인 8~9에서 존 관리용 락을 초기화한다.
  • 코드 라인 10에서 0 오더 페이지 전용 버디 캐시인 pcp를 준비한다.




static __meminit void zone_pcp_init(struct zone *zone)
         * per cpu subsystem is not up at this point. The following code
         * relies on the ability of the linker to provide the
         * offset of a (static) per cpu variable into the per cpu area.
        zone->pageset = &boot_pageset;

        if (populated_zone(zone))
                printk(KERN_DEBUG "  %s zone: %lu pages, LIFO batch:%u\n",
                        zone->name, zone->present_pages,

0 오더 페이지 전용 버디 캐시인 pcp를 준비한다.

  • zone->pageset에 boot_pageset per-cpu 데이터의 주소를 대입한다.


4) 페이지 블럭 order 지정




/* Initialise the number of pages represented by NR_PAGEBLOCK_BITS */
void __init set_pageblock_order(void)
        unsigned int order;

        /* Check that pageblock_nr_pages has not already been setup */
        if (pageblock_order)

                order = HUGETLB_PAGE_ORDER;
                order = MAX_ORDER - 1;

         * Assume the largest contiguous order of interest is a huge page.
         * This value may be variable depending on boot parameters on IA64 and
         * powerpc.
        pageblock_order = order;

 * When CONFIG_HUGETLB_PAGE_SIZE_VARIABLE is not set, set_pageblock_order()
 * is unused as pageblock_order is set at compile-time. See
 * include/linux/pageblock-flags.h for the values of pageblock_order based on
 * the kernel config
void __init set_pageblock_order(void)


페이지 블럭 order 값을 설정한다.

  • huge 페이지를 지원하면 HUGETLB_PAGE_ORDER를 사용하고 그렇지 않은 경우 MAX_ORDER(11)-1 값으로 지정할 수 있다.
    • 예) 4K 페이지 + 2M huge 페이지를 사용하는 경우 HUGETLB_PAGE_ORDER=21-12=9 이다.


5) usemap 할당


이 함수는 SPARSEMEM 메모리 모델이 아닌 경우에 한해 요청한 노드의 usemap을 할당받는다.


static void __init setup_usemap(struct pglist_data *pgdat,
                                struct zone *zone,
                                unsigned long zone_start_pfn,
                                unsigned long zonesize)
        unsigned long usemapsize = usemap_size(zone_start_pfn, zonesize);
        zone->pageblock_flags = NULL;
        if (usemapsize)
                zone->pageblock_flags =

요청한 노드용 usemap을 할당받고 지정한다.

  • usemap은 partial 페이지 관리를 위해 블록 단위로 mobility를 관리한다.



SPARSE 메모리 모델을 사용하는 경우와 아닌 경우 두 가지 구현이 있지만 다음은 sparse 메모리 모델이 아닌 경우의 구현을 소개한다.


 * Calculate the size of the zone->blockflags rounded to an unsigned long
 * Start by making sure zonesize is a multiple of pageblock_order by rounding
 * up. Then use 1 NR_PAGEBLOCK_BITS worth of bits per pageblock, finally
 * round what is now in bits to nearest long in bits, then return it in
 * bytes.
static unsigned long __init usemap_size(unsigned long zone_start_pfn, unsigned long zonesize)
        unsigned long usemapsize;

        zonesize += zone_start_pfn & (pageblock_nr_pages-1);
        usemapsize = roundup(zonesize, pageblock_nr_pages);
        usemapsize = usemapsize >> pageblock_order;
        usemapsize *= NR_PAGEBLOCK_BITS;
        usemapsize = roundup(usemapsize, 8 * sizeof(unsigned long));

        return usemapsize / 8; 

SPARSEMEM 메모리 모델이 아닌 경우의 usemap 사이즈를 산출한다.

  • 코드 라인 6에서 zonesize를 페이지 블럭 단위로 반올림한다.
  • 코드 라인 7~12에서 usemap 사이즈를 산출하여 반환한다.
    • 페이지 블럭 당 사용할 usemap 비트는 NR_PAGEBLOCK_BITS(4)이다.
    • 산출된 usemap 사이즈는 unsingned long 사이즈 단위로 정렬한다.


6) empty 존 초기화



void __meminit init_currently_empty_zone(struct zone *zone,
                                        unsigned long zone_start_pfn,
                                        unsigned long size)
        struct pglist_data *pgdat = zone->zone_pgdat;
        int zone_idx = zone_idx(zone) + 1;

        if (zone_idx > pgdat->nr_zones)
                pgdat->nr_zones = zone_idx;

        zone->zone_start_pfn = zone_start_pfn;

        mminit_dprintk(MMINIT_TRACE, "memmap_init",
                        "Initialising map node %d zone %lu pfns %lu -> %lu\n",
                        (unsigned long)zone_idx(zone),
                        zone_start_pfn, (zone_start_pfn + size));

        zone->initialized = 1;

현재 비어 있는 존에 대한 초기화를 수행한다. 이 때 해당 존의 버디 리스트도 초기화한다.

  • 코드 라인 5~9에서 현재 노드에서 사용할 zone 수를 지정한다.
  • 코드 라인 11에서 zone의시작 pfn을 지정한다.
  • 코드 라인 19에서 zone용 버디 리스트를 초기화한다.
  • 코드 라인 20에서 존이 초기화되었음을 식별하게 한다.




static void __meminit zone_init_free_lists(struct zone *zone)
        unsigned int order, t;
        for_each_migratetype_order(order, t) {
                zone->free_area[order].nr_free = 0;

zone에 해당하는 버디 시스템을 초기화한다.

  • free_area[] 배열의 초기화를 수행한다.


7) mem_map 초기화



void __meminit __weak memmap_init(unsigned long size, int nid,
                                  unsigned long zone, unsigned long start_pfn)
        memmap_init_zone(size, nid, zone, start_pfn, MEMMAP_EARLY, NULL);

할당받은 mem_map(page 디스크립터 배열)을 초기화한다.




 * Initially all pages are reserved - free ones are freed
 * up by memblock_free_all() once the early boot process is
 * done. Non-atomic initialization, single-pass.
void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
                unsigned long start_pfn, enum memmap_context context,
                struct vmem_altmap *altmap)
        unsigned long pfn, end_pfn = start_pfn + size;
        struct page *page;

        if (highest_memmap_pfn < end_pfn - 1)
                highest_memmap_pfn = end_pfn - 1;

         * Honor reservation requested by the driver for this ZONE_DEVICE
         * memory. We limit the total number of pages to initialize to just
         * those that might contain the memory mapping. We will defer the
         * ZONE_DEVICE page initialization until after we have released
         * the hotplug lock.
        if (zone == ZONE_DEVICE) {
                if (!altmap)

                if (start_pfn == altmap->base_pfn)
                        start_pfn += altmap->reserve;
                end_pfn = altmap->base_pfn + vmem_altmap_offset(altmap);

        for (pfn = start_pfn; pfn < end_pfn; pfn++) {
                 * There can be holes in boot-time mem_map[]s handed to this
                 * function.  They do not exist on hotplugged memory.
                if (context == MEMMAP_EARLY) {
                        if (!early_pfn_valid(pfn))
                        if (!early_pfn_in_nid(pfn, nid))
                        if (overlap_memmap_init(zone, &pfn))
                        if (defer_init(nid, pfn, end_pfn))

                page = pfn_to_page(pfn);
                __init_single_page(page, pfn, zone, nid);
                if (context == MEMMAP_HOTPLUG)

                 * Mark the block movable so that blocks are reserved for
                 * movable at startup. This will force kernel allocations
                 * to reserve their blocks rather than leaking throughout
                 * the address space during boot when many long-lived
                 * kernel allocations are made.
                 * bitmap is created for zone's valid pfn range. but memmap
                 * can be created for invalid pages (for alignment)
                 * check here not to call set_pageblock_migratetype() against
                 * pfn out of zone.
                if (!(pfn & (pageblock_nr_pages - 1))) {
                        set_pageblock_migratetype(page, MIGRATE_MOVABLE);

할당받은 mem_map(page 디스크립터 배열)을 초기화한다.

  • 코드 라인 8~9에서 highest_memmap_pfn이 end_pfn-1을 초과하지 않도록 한다.
  • 코드 라인 11~27에서 zone 디바이스의 경우 메모리 크기가 매우 크므로 전체 페이지 디스크립터의 초기화를 일부 제한한다.
  • 코드 라인 29~38에서 시작 pfn 부터 끝 pfn 까지 루프를 돌며 인자 @context가 MEMMAP_EARLY(0) 인 경우 pfn에 해당하는 페이지가 유효하지 않은 경우 skip 한다.
    • early_pfn_in_nid()
      • CONFIG_NODES_SPAN_OTHER_NODES 커널 옵션에 따라 early_pfn_in_nid() 함수 구현은
        • 사용하지 않는 경우  함수는 항상 true이다.
        • 사용하는 경우 해당 pfn이 지정된 노드에 있는지 여부를 알아온다.
  • 코드 라인 39~40에서 overlap된 페이지도 skip 한다.
  • 코드 라인 41~42에서 대용량 메모리가 장착된 시스템에서 한꺼번에 페이지 디스크립터를 초기화하는 것은 매우 긴 시간이 소요된다. 따라서 부트 후 병렬로 처리하기 위해 초기화를 유예시킨다.
  • 코드 라인 45~46에서 pfn 번호에 해당하는 페이지 디스크립터를 초기화한다.
  • 코드 라인 47~48에서 인자 @context가 MEMMAP_HOTPLUG(1) 인 경우 페이지 디스크립터에 Reserved 플래그를 추가한다.
  • 코드 라인 62~65에서 페이지 블럭 단위로 migrattype을 movable로 지정한다.




static void __meminit __init_single_page(struct page *page, unsigned long pfn,
                                unsigned long zone, int nid)
        set_page_links(page, zone, nid, pfn);

        /* The shift won't overflow because ZONE_NORMAL is below 4G. */
        if (!is_highmem_idx(zone))
                set_page_address(page, __va(pfn << PAGE_SHIFT));

요청한 페이지 디스크립터 하나를 초기화한다.

  • 코드 라인 4에서 페이지 디스크립터를 0으로 채운다.
  • 코드 라인 5에서 페이지 디스크립터에 존과 노드 및 섹션 정보를 기록한다.
  • 코드 라인 6에서 페이지 참조 카운터를 1로 초기화한다.
  • 코드 라인 7에서 페이지 매핑 카운터를 -1로 초기화한다.
  • 코드 라인 8에서 last_cpuid에 해당하는 비트를 1로 채워 초기화한다.
  • 코드 라인 9에서 KASAN(Kernel Address SANitizer)용 플래그 비트를 초기화한다.
  • 코드 라인 11에서 페이지의 lru 연결용 노드를 초기화한다.
  • 코드 라인 12~16에서 zone이 highmem이 아니면 page->virtual에  pfn을 가상주소로 바꾼 주소로 설정한다.




Memory Model – (1)

<kernel v5.0>

3가지 메모리 모델

리눅스는 FLATMEM, DISCONTIGMEM 및 SPARSEMEM의 3가지 모델을 제공하며 아키텍처 머신들은 이 중 하나 이상을 지원하며 커널 빌드 시 지원되는 메모리 모델 중 하나를 선택하여 빌드한다.



메모리 모델별 특징


  • 설치된 메모리 뱅크들의 주소가 연속된다.
  • 처음 리눅스에서 사용하던 메모리 모델
  • 참고로 hole이 있어도 flatmem 모델을 사용할 수 있다. 그러나 메모리 전체 크기만큼 mem_map을 생성해면서 hole 크기만큼 낭비가 발생하는 이유로 대부분 그렇게 사용하지 않는다.



  • 2009년 NUMA 시스템을 위해 소개되었다.
  • 설치된 메모리 뱅크들의 간격(hole)이 있는 시스템을 위해 사용된다.
  • ARM은 2010년 핫 플러그에 대응을 못하는 DISCONTIGMEM을 대체하는 SPARSEMEM이 도입되면서 이 모델을 지원하지 않았다.



  • 설치된 메모리 뱅크들의 간격이 발생된다. 홀(hole) 발생 가능.
  • DISCONTIGMEM 보다 성능이 떨어질 수 있지만 hotplug memory 기능이 지원된다.
    • 그러나 특정 아키텍처에 구현된 SPARSEMEM_VMEMMAP을 사용하는 경우 DISCONTIGMEM 보다 더 빠르고 FLATMEM에 필적하는 성능을 보여 64비트 시스템에서는 점점 Sparsemem으로 이전하고 있음.
    • 참고: x86_64: Make sparsemem/vmemmap the default memory model
    • arm64의 경우 sparsemem 메모리 모델과 vmemmap 옵션을 디폴트로 사용한다.
  • 섹션 단위로 online/offline(hotplug memory) 관리가 되며 사이즈는 수십MB~수G로 아키텍처별로 다르다.
    • arm32의 경우 설정된 커널 옵션마다 다르다.
    • arm64의 경우 디폴트 값으로 1G를 사용한다.
  • UMA에서 사용하는 경우
    • ARM의 경우 SA1100(xscale 아키텍처), ARCH-RPC 및 일부 ARM 머신(RealView-PBX)에서 두 개의 메모리 뱅크가 떨어져 있어서 default로 메모리 모델로 사용한다.
    • 또한 메인스트림에 적용된 코드는 아니지만 ARM에서 MULTI_PLATFORM 커널 옵션을 사용하는 경우에도 사용할 수 있도록 패치가 준비되어 있다.




메모리 모델 주요 커널 옵션


메모리 모델 부가 커널 옵션

    • DISCONTIGMEM 메모리 모델을 사용하거나 NUMA 시스템인 경우 사용할 수 있다.
    • NODE_DATA() 매크로를 사용하여 각 노드의 mem_map을 가리킬 수 있게 한다.
    • 전역 node_data[] 배열을 사용하여 노드별로 mem_map에 접근한다.
    • FLATMEM 또는 DISCONTIGMEM 메모리 모델에서 사용할 수 있다.
    • 노드 정보를 기술해 놓은 pglist_data 구조체의 멤버 변수 node_mem_map을 통해 mem_map에 접근한다.
    • SPARSEMEM 메모리 모델을 위해 요청한 범위에 hole이 발생할 수 있으므로 각 섹션 별로 메모리 존재 여부를 관리할 수 있도록 한다.
    • sparse 메모리 모델을 사용할 때 사용되는 두 가지 선택 중 하나이다.
    • mem_section[] 배열을 dynamic 하게 할당 받아 사용하려고 할 때 사용
    • 주로 생성해야 할 섹션 수가 많은 64비트 시스템에서 사용한다.
    • sparse 메모리 모델을 사용할 때 사용되는 두 가지 선택 중 하나이다.
    • 컴파일 시 static하게 할당해둔 mem_section[]을 사용한다.
    • 주로 생성해야 할 섹션 수가 적은 32비트 시스템에서 사용한다.
    • vmemmap을 사용하여 빠르게 pfn과 page descriptor 주소를 변환할 수 있다.
    • vmalloc 주소 범위가 큰 64비트 시스템에서 사용한다.
    • 메모리를 시스템 동작 중에 제거할 수 있다.
    • SPARSEMEM && MEMORY_HOTPLUG에서 선택할 수 있다.
    • 기존 커널에서 사용하였던 BOOTMEM early 메모리 할당자를 사용하지 않는다.
    • ARM은 기본적으로 BOOTMEM을 사용하지 않고 memblock으로 대체되었다. 대부분의 아키텍처에서도 점점 사용하지 않는 추세이다.
    • memblock early 메모리 할당자를 사용한다.
    • ARM은 기본적으로 사용하고 대부분의 아키텍처도 BOOTMEM 대신 early 메모리 할당자로 사용한다.
    • 32bit에서 커널에 미리 1:1 매핑되지 않아 커널이 직접 access를 해야 할 때마다 매핑하여 사용해야 하는 메모리 범위이다.
    • 32bit 시스템에서 시스템 메모리가 커널 공간보다 큰 경우 HIGHMEM 옵션을 사용하여 더 많은 메모리를 활용할 수 있게 한다.
    • 32bit 시스템에서 2차 PTE를 highmem에 할당한다.
    • 32bit 시스템에 수 기가 이상의 메모리를 사용하는 경우 2차 PTE를 highmem에 로드하게 하여 lowmem 메모리를 소모하지 않게 유도한다.
    • page 구조체의 flags 멤버변수에 노드 번호를 기록하지 못하는 경우 노드 번호를 별도로 섹션에 대해 1:1로 매핑하여 저장한다
    • 32비트 시스템에서 비트 자리가 부족하여 노드 번호를 기록하지 못하는 경우 사용

메모리 모델과 페이지 관리맵(mem_map)

전체 물리 메모리의 페이지 프레임 만큼 page 구조체 배열이 mem_map이라하는데 다음과 같이 각 메모리 모델별로 mem_map을 관리한다.
    • *mem_map 포인터가 page[] 구조체 배열을 가리킨다.
    • 노드가 하나 이므로 전역 구조체 contig_page_data를 사용하는데 이 구조체의 멤버 변수 node_mem_map 역시 page[] 구조체 배열을 가리킨다.
    • 노드가 두 개 이상이므로 node_data[] 배열을 사용하는데 이 구조체의 멤버 변수 node_mem_map은 각 노드와 관련된 page[] 구조체 배열을 가리킨다.
    • 두 가지 방법을 사용한다.
        • 섹션 수 만큼 mem_section[] 배열을 컴파일 타임에 정적 메모리에 두고 각 섹션 엔트리의 멤버 변수 section_mem_map이 해당 섹션 크기 만큼의 페이지를 관리하는 page[] 구조체 배열을 가리킨다.
        • 섹션 수 만큼 *mem_section[] 포인터 배열을 정적 메모리에 두고 실제 각 mem_section[] 배열은 커널 초기화를 진행할 때 mem_section[] 배열을 dynamic하게 할당받아 메모리를 사용하고 mem_section[]의 사용은 SPARSEMEM_STATIC과 같다.




memory memblock으로 부터 lowmem 영역의 경계를 파악하여 각각의 zone으로 경계를 나누어 설정하고 0번 노드의 빈 페이지들을 초기화한다. 또한 Sparse 메모리 모델을 지원하는 경우에는 sparse memory의 초기화도 수행한다.





void __init bootmem_init(void)
        unsigned long min, max_low, max_high;

        max_low = max_high = 0;

        find_limits(&min, &max_low, &max_high);

         * Sparsemem tries to allocate bootmem in memory_present(),
         * so must be done after the fixed reservations

         * sparse_init() needs the bootmem allocator up and running.

         * Now free the memory - free_area_init_node needs
         * the sparse mem_map arrays initialized by sparse_init()
         * for memmap_init_zone(), otherwise all PFNs are invalid.
        zone_sizes_init(min, max_low, max_high);

         * This doesn't seem to be used by the Linux memory manager any
         * more, but is used by ll_rw_block.  If we can get rid of it, we
         * also get rid of some of the stuff above as well.
        min_low_pfn = min;
        max_low_pfn = max_low;
        max_pfn = max_high;
  • memblock_allow_resize();
    • memblock_can_resize = 1로 만들어 향후 memblock 관리 영역이 모자랄 때 2배 단위로 커질 수 있도록 한다.
  • find_limits(&min, &max_low, &max_high);
    • memblock 정보로 max_pfn, max_low_pfn, min_low_pfn 값을 얻어온다.
  • arm_memory_present();
    • Sparsemem의 경우 내부에서 mem_section[] 매핑을 위한 allocation이 수행되기 때문에 반드시 fixed reservation이 끝난 후에 이 함수가 호출되어야 한다.
    • 몇 개 32bit ARM 머신을 제외하고 대부분의 32bit ARM에서는 CONFIG_SPARSEMEM 옵션을 사용하지 않는다.
    • 참고: Sparse Memory | 문c
  • sparse_init();
    • Sparse memory 모델을 사용하는 시스템을 위해 관리 영역을 할당받고 매핑 초기화한다.
    • 참고: Sparse Memory | 문c
  • zone_sizes_init(min, max_low, max_high);
    • zone  영역을 나누고 초기화한다.

아래와 같이 memblock 설정 값을 읽어 lowmem 영역의 경계를 나눈다. 이 값은 zone을 나누는 경계로도 사용된다.





void __init memblock_allow_resize(void)
        memblock_can_resize = 1;
  • memblock_can_resize 플래그를 enable 시켜 향후 memblock 관리 영역이 모자랄 때 2배 단위로 커질 수 있도록 한다.




static void __init find_limits(unsigned long *min, unsigned long *max_low,
                               unsigned long *max_high)
        *max_low = PFN_DOWN(memblock_get_current_limit());
        *min = PFN_UP(memblock_start_of_DRAM());
        *max_high = PFN_DOWN(memblock_end_of_DRAM());
  • memblock 정보를 읽어 다음을 설정한다.
  • max_low
    • lowmem/highmem 영역의 경계 pfn
  • min
    • 메모리 영역의 최하 pfn
  • max_high
    • 메모리 영역의 최상 pfn




static void __init zone_sizes_init(unsigned long min, unsigned long max_low,
        unsigned long max_high)
        unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
        struct memblock_region *reg;

         * initialise the zones.
        memset(zone_size, 0, sizeof(zone_size));

         * The memory size has already been determined.  If we need
         * to do anything fancy with the allocation of this memory
         * to the zones, now is the time to do it.
        zone_size[0] = max_low - min;
        zone_size[ZONE_HIGHMEM] = max_high - max_low;

         * Calculate the size of the holes.
         *  holes = node_size - sum(bank_sizes)
        memcpy(zhole_size, zone_size, sizeof(zhole_size));
        for_each_memblock(memory, reg) {
                unsigned long start = memblock_region_memory_base_pfn(reg);
                unsigned long end = memblock_region_memory_end_pfn(reg);

                if (start < max_low) {
                        unsigned long low_end = min(end, max_low);
                        zhole_size[0] -= low_end - start;
                if (end > max_low) {
                        unsigned long high_start = max(start, max_low);
                        zhole_size[ZONE_HIGHMEM] -= end - high_start;

         * Adjust the sizes according to any special requirements for
         * this machine type.
        if (arm_dma_zone_size)
                arm_adjust_dma_zone(zone_size, zhole_size,
                        arm_dma_zone_size >> PAGE_SHIFT);

        free_area_init_node(0, zone_size, min, zhole_size);
  • zone_size[0] = max_low – min;
    • lowmem 영역 사이즈 설정
  • zone_size[ZONE_HIGHMEM] = max_high – max_low;
    • highmem이 동작하는 경우 highmem 영역 사이즈 설정
  • memcpy(zhole_size, zone_size, sizeof(zhole_size));
    • zone_size[]를 zhole_size[]에 복사
  • for_each_memblock(memory, reg) {
    • memory memblock을 루프를 돌며 하나씩 얻어온다.
  • if (start < max_low) {
    • memory memblock이 lowmem 영역에 들어있거나 일부 겹치는 경우
  • unsigned long low_end = min(end, max_low);
    • 끝 주소가 lowmem을 초과하지 않게 한다.
  • zhole_size[0] -= low_end – start;
    • hole 사이즈를 감소시킨다. 이 값이 0이되면 hole이 없는 것이다.
  • highmem 영역에 대해서도 위와 똑같은 방법으로 hole 사이즈를 감소시킨다.
  • if (arm_dma_zone_size)
    • DMA zone 사이즈가 존재하는 경우 dma zone 사이즈만큼 ZONE_DMA에 사이즈를 구성하고 ZONE_NORMAL 영역에서 그 사이즈만큼 뺀다.
  • free_area_init_node(0, zone_size, min, zhole_size);
    • 0번 노드에 zone_size[]와, zhole_size[] 정보를 사용하여 빈 페이지들을 초기화한다.
    • 참고: free_area_init_node() | 문c

아래 그림과 같이 highmem 영역을 사용하는 경우 ZONE_HIGHMEM에 대한 사이즈가 지정되고, 아키텍처가 dma 영역을 별도로 지정하여 사용하는 경우 ZONE_NORMAL에 대한 size를 dma 사이즈 만큼 감소시키고 ZONE_DMA에 대한 사이즈를 dma 사이즈로 지정한다.

  • rpi2: ZONE_NORMAL만 사용한다.