code cat

arch/arm/mm/init.c : mem_init(void)

        unsigned long reserved_pages, free_pages;
        struct memblock_region *reg;

 /*
         * Since our memory may not be contiguous, calculate the
         * real number of pages we have in this system
         */
        printk(KERN_INFO "Memory:");
        num_physpages = 0;
        for_each_memblock(memory, reg) {
                unsigned long pages = memblock_region_memory_end_pfn(reg) -
                        memblock_region_memory_base_pfn(reg);
                num_physpages += pages;
                printk(" %ldMB", pages >> (20 - PAGE_SHIFT));
        }
        printk(" = %luMB total\n", num_physpages >> (20 - PAGE_SHIFT));

        printk(KERN_NOTICE "Memory: %luk/%luk available, %luk reserved, %luK highmem\n",
                nr_free_pages() << (PAGE_SHIFT-10),
                free_pages << (PAGE_SHIFT-10),
                reserved_pages << (PAGE_SHIFT-10),
                totalhigh_pages << (PAGE_SHIFT-10));

include/linux/memblock.h

#define for_each_memblock(memblock_type, region)                                        \
        for (region = memblock.memblock_type.regions;                           \
             region < (memblock.memblock_type.regions + memblock.memblock_type.cnt);    \
             region++)

include/linux/memblock.h

/**
 * memblock_region_memory_end_pfn - Return the end_pfn this region
 * @reg: memblock_region structure
 */
static inline unsigned long memblock_region_memory_end_pfn(const struct memblock_region *reg)
{
        return PFN_DOWN(reg->base + reg->size);
}

include/linux/memblock.h

/**
 * memblock_region_reserved_base_pfn - Return the lowest pfn intersecting with the reserved region
 * @reg: memblock_region structure
 */
static inline unsigned long memblock_region_reserved_base_pfn(const struct memblock_region *reg)
{
        return PFN_DOWN(reg->base);
}

include/linux/memblock.h

struct memblock {
        phys_addr_t current_limit;
        phys_addr_t memory_size;        /* Updated by memblock_analyze() */
        struct memblock_type memory;
        struct memblock_type reserved;
};

meminfo 라는 구조체에 nr_banks 와 membank라는 구조체가 멤버로 있다.  이들은 부팅 과정에서 이미 arm_add_memory라는 함수를 통해서 bank에 대한 start 및 size가 정해졌있다.(
early_init_dt_add_memory()나 parse_tag_mem32()등의 함수를 통해서 세팅된다(확인필요)

struct membank {
        phys_addr_t start;
        phys_addr_t size;
        unsigned int highmem;
};

struct meminfo {
        int nr_banks;
        struct membank bank[NR_BANKS];
};

그리고 arch/arm/mm/init.c:find_limits()라는 함수를 통해서, 각 메모리 뱅크를 돌면서 (참고로 이건 3.1.10소스다. 최신은 좀 틀리다)

static void __init find_limits(unsigned long *min, unsigned long *max_low,
        unsigned long *max_high)
{
        struct meminfo *mi = &meminfo;
        int i;

        *min = -1UL;
        *max_low = *max_high = 0;

        for_each_bank (i, mi) {
                struct membank *bank = &mi->bank[i];
                unsigned long start, end;

                start = bank_pfn_start(bank);
                end = bank_pfn_end(bank);

                if (*min > start)
                        *min = start;
                if (*max_high < end)
                        *max_high = end;
                if (bank->highmem)
                        continue;
                if (*max_low < end)
                        *max_low = end;
        }
}

밑의 매크로를 통해서 페이지프레임넘버를 가져온다.  

#define bank_pfn_start(bank)    __phys_to_pfn((bank)->start)
#define bank_pfn_end(bank)      __phys_to_pfn((bank)->start + (bank)->size)

#define __phys_to_pfn(paddr)    ((unsigned long)((paddr) >> PAGE_SHIFT))

가져온 pfn을 start, end에 assign하고 전달받은 min, max_low, max_high를 그에 맞게 설정해 준다.  

그 후, bootmem_init()에서 arm_bootmem_init(min, max_low)를 통해 bootmem bitmap page 할당, bootmem allocator 초기화, lowmem 해재, lowmem memblock reservation 등을 한다.

위의 할당된 bootmem 은 나중에 init/main.c 에서 mem_init()를 호출하면,

static void __init mm_init(void)
{
        /*
         * page_cgroup requires countinous pages as memmap
         * and it's bigger than MAX_ORDER unless SPARSEMEM.
         */
        page_cgroup_init_flatmem();
        mem_init();
        kmem_cache_init();
        percpu_init_late();
        pgtable_cache_init();
        vmalloc_init();
}

mem_init()에서 bootmem에 할당되었던 메모리를 해제한다.
 600 totalram_pages += free_all_bootmem();

mm/bootmem.c

unsigned long __init free_all_bootmem(void)
{
        unsigned long total_pages = 0;
        bootmem_data_t *bdata;

        list_for_each_entry(bdata, &bdata_list, list)
                total_pages += free_all_bootmem_core(bdata);

        return total_pages;
}

자 그러면 이제 우리가 원하던 부분이다.

        reserved_pages = free_pages = 0;

        for_each_bank(i, &meminfo) {
                struct membank *bank = &meminfo.bank[i];
                unsigned int pfn1, pfn2;
                struct page *page, *end;

                pfn1 = bank_pfn_start(bank);
                pfn2 = bank_pfn_end(bank);

                page = pfn_to_page(pfn1);
                end  = pfn_to_page(pfn2 - 1) + 1;

                do {
                        if (PageReserved(page))
                                reserved_pages++;
                        else if (!page_count(page))
                                free_pages++;
                        page++;
                } while (page < end);
        }

        /*
         * Since our memory may not be contiguous, calculate the
         * real number of pages we have in this system
         */
        printk(KERN_INFO "Memory:");
        num_physpages = 0;
        for_each_memblock(memory, reg) {
                unsigned long pages = memblock_region_memory_end_pfn(reg) -
                        memblock_region_memory_base_pfn(reg);
                num_physpages += pages;
                printk(" %ldMB", pages >> (20 - PAGE_SHIFT));
        }
        printk(" = %luMB total\n", num_physpages >> (20 - PAGE_SHIFT));

        printk(KERN_NOTICE "Memory: %luk/%luk available, %luk reserved, %luK highmem\n",
                nr_free_pages() << (PAGE_SHIFT-10),
                free_pages << (PAGE_SHIFT-10),
                reserved_pages << (PAGE_SHIFT-10),
                totalhigh_pages << (PAGE_SHIFT-10));

#define MLK(b, t) b, t, ((t) - (b)) >> 10
#define MLM(b, t) b, t, ((t) - (b)) >> 20
#define MLK_ROUNDUP(b, t) b, t, DIV_ROUND_UP(((t) - (b)), SZ_1K)

        printk(KERN_NOTICE "Virtual kernel memory layout:\n"
                        "    vector  : 0x%08lx - 0x%08lx   (%4ld kB)\n"
#ifdef CONFIG_HAVE_TCM
                        "    DTCM    : 0x%08lx - 0x%08lx   (%4ld kB)\n"
                        "    ITCM    : 0x%08lx - 0x%08lx   (%4ld kB)\n"
#endif
                        "    fixmap  : 0x%08lx - 0x%08lx   (%4ld kB)\n"
#ifdef CONFIG_MMU
                        "    DMA     : 0x%08lx - 0x%08lx   (%4ld MB)\n"
#endif
                        "    vmalloc : 0x%08lx - 0x%08lx   (%4ld MB)\n"
                        "    lowmem  : 0x%08lx - 0x%08lx   (%4ld MB)\n"
#ifdef CONFIG_HIGHMEM
                        "    pkmap   : 0x%08lx - 0x%08lx   (%4ld MB)\n"
#endif
                        "    modules : 0x%08lx - 0x%08lx   (%4ld MB)\n"
                        "      .text : 0x%p" " - 0x%p" "   (%4d kB)\n"
                        "      .init : 0x%p" " - 0x%p" "   (%4d kB)\n"
                        "      .data : 0x%p" " - 0x%p" "   (%4d kB)\n"
                        "       .bss : 0x%p" " - 0x%p" "   (%4d kB)\n",

meminfo의 nr_bank숫자 만큼 루핑을 하면서, bank의 start주소와 end주소의 pfn을 가져와, 각각 page, end에 저장시키고, page에서부터 end까지 안에서 루핑하면서, page가 reserved일 경우, reserved_pages++ 하고, !page_count(page)일 경우 free_pages++하고, 마지막으로 page를 increment시킨다.

 for_each_memblock(memory, reg) 는 

#define for_each_memblock(memblock_type, region)                                        \
        for (region = memblock.memblock_type.regions;                           \
             region < (memblock.memblock_type.regions + memblock.memblock_type.cnt);    \
             region++)

memblock_type의 memory안의 memblock_region의 regions을 돌면서(memory의 cnt숫자만큼), 

struct memblock_region {
        phys_addr_t base;
        phys_addr_t size;
};

struct memblock_type {
        unsigned long cnt;      /* number of regions */
        unsigned long max;      /* size of the allocated array */
        struct memblock_region *regions;
};

struct memblock {
        phys_addr_t current_limit;
        phys_addr_t memory_size;        /* Updated by memblock_analyze() */
        struct memblock_type memory;
        struct memblock_type reserved;
};

pages에 region의 base + size의 PFN 값에서 base의 PFN값을 뺀 값을 설정한다.

                unsigned long pages = memblock_region_memory_end_pfn(reg) -
                        memblock_region_memory_base_pfn(reg);

그리고 이렇게 얻어진 pages를 num_phypages에 증가시켜준다.

그러면 드디오 이 num_phypages >> (20 - PAGE_SHIFT)가
Memory: = xxx MB total

에 나오는 xxx가 된다. 

driver초기화 시에 흔히 불리는 module_init(x)는 include/linux/init.h에

로 정의되어 있다.  여기서 x는 kernel 부팅 타임이나 모듈 삽입시에 불리는 함수명이 된다.

built in 모듈일 경우, do_initcalls()에서 불릴 것이고,

module 일 경우, module insertion에 불린다.

MACH_TYPE_XXX 와 machine 이름을 overwrite하기 위해서는 아래 매크로를 활용하면 된다.

linux/arch/arm/include/asm/mach/arch.h

 * Set of macros to define architecture features.  This is built into
 * a table by the linker.
 */
#define MACHINE_START(_type,_name)                      \
static const struct machine_desc __mach_desc_##_type    \
 __used                                                 \
 __attribute__((__section__(".arch.info.init"))) = {    \
        .nr             = MACH_TYPE_##_type,            \
        .name           = _name,

#define MACHINE_END                             \
};

start_kernel()-->setup_arch()-->setup_machine_tags()

arch/arm/kernel/setup.c에서setup_arch()함수 내에서 머신이름을 설정한다.

setup_arch(char **cmdline_p) { struct machine_desc *mdesc; mdesc = setup_machine_fdt(__atgs_pointer); if (!mdesc) mdesc = setup_machine_tags(machine_arch_type);

machine_arch_type은 setup_machine_tags의 인자로 넘어가고, setup_machine_tags()내의
for_each_machine_desc는 __arch_info_begin 에서 __arch_info_end 를 순환하면서 machine_desc구조체의 nr(architecture number를 인자로 받아온 machine_arch_type과 비교하여 같은 경우, archiecture name을 찍어준다.

static struct machine_desc * __init setup_machine_tags(unsigned int nr) { struct machine_desc *mdesc = NULL, *p; ... for_each_machine_desc(p) if (nr == p->nr) { printk("Machine: %s\n", p->name); mdesc = p; break; } }