code cat

[    3.11328] init: skipping insecure file '/default.prop'
[    3.133259] init: skipping insecure file '/init.rc'

라는 에러 메세지가 나오면서 부팅이 안되면, 이는 다음과 같이 젤리빈(이상버전 동일?)에서 다음과 같이 파일 스탯을 참조하여, owner외에 writable 못하게 막아놓았기 때문이다.

    char *data;
    int sz;
    int fd;
    struct stat sb;

    data = 0;
    fd = open(fn, O_RDONLY);
    if(fd < 0) return 0;

    // for security reasons, disallow world-writable
    // or group-writable files
    if (fstat(fd, &sb) < 0) {
        ERROR("fstat failed for '%s'\n", fn);
        goto oops;
    }
    if ((sb.st_mode & (S_IWGRP | S_IWOTH)) != 0) {

그럼 간단히, 644 혹은, 655 정도로 파일 퍼미션을 바꿔주면 된다.

dentry cache hash table size 지정은,
fs/dcache.c에서 alloc_large_system_hash를 통해서 된다.  그전에 dhash_entries는 kernel cmdline에서 지정하여 원하는 값을 패스 할 수 있다.
static void __init dcache_init(void)
{
        int loop;

        /* 
         * A constructor could be added for stable state like the lists,
         * but it is probably not worth it because of the cache nature
         * of the dcache. 
         */
        dentry_cache = KMEM_CACHE(dentry,
                SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);

        /* Hash may have been set up in dcache_init_early */
        if (!hashdist)
                return;

        dentry_hashtable =
                alloc_large_system_hash("Dentry cache",
                                        sizeof(struct hlist_bl_head),
                                        dhash_entries,
                                        13,
                                        0,
                                        &d_hash_shift,
                                        &d_hash_mask,
                                        0);

        for (loop = 0; loop < (1 << d_hash_shift); loop++)
                INIT_HLIST_BL_HEAD(dentry_hashtable + loop);
}

그리고 만약 dhash_entries값이 0이면(전역비초기화 변수 이므로 0으로 되어 bss영역에 있을 것이다) 5395라인 하위로 타고 들어가, nr_kernel_pages에 기반을 둔 2의 배수를 설정하고 기타 log2작업(아 이건 나중에 보자...)을 통해 hash table size를 출력한다. 

void *__init alloc_large_system_hash(const char *tablename,
                                     unsigned long bucketsize,
                                     unsigned long numentries,
                                     int scale,
                                     int flags,
                                     unsigned int *_hash_shift,
                                     unsigned int *_hash_mask,
                                     unsigned long limit)
{
        unsigned long long max = limit;
        unsigned long log2qty, size;
        void *table = NULL;

        /* allow the kernel cmdline to have a say */
        if (!numentries) {
                /* round applicable memory size up to nearest megabyte */
                numentries = nr_kernel_pages;
                numentries += (1UL << (20 - PAGE_SHIFT)) - 1;
                numentries >>= 20 - PAGE_SHIFT;
                numentries <<= 20 - PAGE_SHIFT;

                /* limit to 1 bucket per 2^scale bytes of low memory */
                if (scale > PAGE_SHIFT)
                        numentries >>= (scale - PAGE_SHIFT);
                else
                        numentries <<= (PAGE_SHIFT - scale);

                /* Make sure we've got at least a 0-order allocation.. */
                if (unlikely(flags & HASH_SMALL)) {
                        /* Makes no sense without HASH_EARLY */
                        WARN_ON(!(flags & HASH_EARLY));
                        if (!(numentries >> *_hash_shift)) {
                                numentries = 1UL << *_hash_shift;
                                BUG_ON(!numentries);
                        }
                } else if (unlikely((numentries * bucketsize) < PAGE_SIZE))
                        numentries = PAGE_SIZE / bucketsize;
        }
        numentries = roundup_pow_of_two(numentries);

        /* limit allocation size to 1/16 total memory by default */
        if (max == 0) {
                max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
                do_div(max, bucketsize);
        }

        if (numentries > max)
                numentries = max;

        log2qty = ilog2(numentries);

        do {
                size = bucketsize << log2qty;
                if (flags & HASH_EARLY)
                        table = alloc_bootmem_nopanic(size);
                else if (hashdist)
                        table = __vmalloc(size, GFP_ATOMIC, PAGE_KERNEL);
                else {
                        /*
                         * If bucketsize is not a power-of-two, we may free
                         * some pages at the end of hash table which
                         * alloc_pages_exact() automatically does
                         */
                        if (get_order(size) < MAX_ORDER) {
                                table = alloc_pages_exact(size, GFP_ATOMIC);
                                kmemleak_alloc(table, size, 1, GFP_ATOMIC);
                        }
                }
        } while (!table && size > PAGE_SIZE && --log2qty);

        if (!table)
                panic("Failed to allocate %s hash table\n", tablename);

        printk(KERN_INFO "%s hash table entries: %ld (order: %d, %lu bytes)\n",
               tablename,
               (1UL << log2qty),
               ilog2(size) - PAGE_SHIFT,
               size);

        if (_hash_shift)
                *_hash_shift = log2qty;
        if (_hash_mask)
                *_hash_mask = (1 << log2qty) - 1;

        return table;
}

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; } }