arm_memblock_init()

<kernel v4.0>

reserve memblock 영역에 다음 영역들을 등록한다.

  • 커널 영역 (XIP 커널인 경우 코드를 제외한 커널 영역)
  • initrd 영역
  • 페이지 테이블 영역
  • 아키텍처 머신이 지정하는 reserve 영역
  • DTB 영역 및 DTB가 지정하는 reserved mem 영역
  • CMA 영역(연속된 메모리 핸들링이 필요한 영역)
    • 다음 2가지 설정에 의해 영역 크기가 할당될 수 있다.
      • “cma=” 커널 cmdline 문자열에 의해 호출되어 지정된다.
      • CONFIG_CMA_SIZE_SEL_MBYTES 옵션을 사용하여 요청 영역을 받아 등록
    • cma(Contigugos Memory Allocator) 영역에도 추가한다.

arm_memblock_init

 

arm_memblock_init()

arch/arm/mm/init.c

void __init arm_memblock_init(const struct machine_desc *mdesc)
{
        /* Register the kernel text, kernel data and initrd with memblock. */
#ifdef CONFIG_XIP_KERNEL
        memblock_reserve(__pa(_sdata), _end - _sdata);
#else
        memblock_reserve(__pa(_stext), _end - _stext);
#endif
#ifdef CONFIG_BLK_DEV_INITRD
        /* FDT scan will populate initrd_start */
        if (initrd_start && !phys_initrd_size) {
                phys_initrd_start = __virt_to_phys(initrd_start);
                phys_initrd_size = initrd_end - initrd_start;
        }   
        initrd_start = initrd_end = 0;
        if (phys_initrd_size &&
            !memblock_is_region_memory(phys_initrd_start, phys_initrd_size)) {
                pr_err("INITRD: 0x%08llx+0x%08lx is not a memory region - disabling initrd\n",
                       (u64)phys_initrd_start, phys_initrd_size);
                phys_initrd_start = phys_initrd_size = 0;
        }   
        if (phys_initrd_size &&
            memblock_is_region_reserved(phys_initrd_start, phys_initrd_size)) {
                pr_err("INITRD: 0x%08llx+0x%08lx overlaps in-use memory region - disabling initrd\n",
                       (u64)phys_initrd_start, phys_initrd_size);
                phys_initrd_start = phys_initrd_size = 0;
        }           
        if (phys_initrd_size) {
                memblock_reserve(phys_initrd_start, phys_initrd_size);

                /* Now convert initrd to virtual addresses */
                initrd_start = __phys_to_virt(phys_initrd_start);
                initrd_end = initrd_start + phys_initrd_size;
        }           
#endif      

        arm_mm_memblock_reserve();

        /* reserve any platform specific memblock areas */
        if (mdesc->reserve)
                mdesc->reserve();

        early_init_fdt_scan_reserved_mem();

        /* reserve memory for DMA contiguous allocations */
        dma_contiguous_reserve(arm_dma_limit);

        arm_memblock_steal_permitted = false;
        memblock_dump_all();
}
  • 커널 영역을 reserve memblock에 등록한다.
    • XIP_KERNEL 옵션을 사용하는 경우 code 영역을 제외한 나머지 커널 영역을 등록한다.
  • CONFIG_BLK_DEV_INITRD
    • 특정 메모리 영역을 램디스크로 사용할 수 있다.
  • if (initrd_start && !phys_initrd_size) {
    • initrd_start 가 지정되었고 phys_initrd_size가 0이 아니면 phys_initrd_start 와 phys_initrd_size를 지정한다.
  • if (phys_initrd_size && !memblock_is_region_memory(phys_initrd_start, phys_initrd_size)) {
    • initrd 영역이 memory memblock 영역에 포함되어 있지 않은 경우 에러 메시지를 출력하고 initrd 영역을 memblock에 추가하는 것을 포기하기 위해 크기를 0으로 설정한다.
  • if (phys_initrd_size && memblock_is_region_reserved(phys_initrd_start, phys_initrd_size)) {
    • initrd 영역이 이미 reserved memblock 영역에 겹친 경우 에러 메시지를 출력하고 initrd 영역을 memblock에 추가하는 것을 포기하기 위해 크기를 0으로 설정한다.
  • memblock_reserve(phys_initrd_start, phys_initrd_size);
    • initrd 영역을 reserve memblock에 추가한다.
  • arm_mm_memblock_reserve();
    • 페이지 테이블을 reserve memblock에 추가한다.
  • if (mdesc->reserve) mdesc->reserve();
    • 아키텍처의 지정된 reserve() 함수를  호출한다.
  •  early_init_fdt_scan_reserved_mem();
    • 다음 3가지 영역을 reserve memblock에 추가한다.
      • DTB 영역
      • DTB 헤더의 off_mem_rsvmap 필드가 가리키는 memory reserve 블럭(바이너리)에서 읽은 메모리 영역들
      • DTB reserved-mem 노드 영역이 요청하는 영역을 reserve memblock에 추가한다.
  • dma_contiguous_reserve(arm_dma_limit);
    • 디바이스 드라이버(dma for coherent/cma for dma)가 필요로 하는 DMA 영역을 reserve memblock에 추가하고 CMA(Contiguous Memory Allocator)에도 추가한다.
      • cma_areas[]에 추가된 엔트리는 CMA 드라이버가 로드되면서 초기화될 때 사용한다.
      • dma_mmu_remap[]에 추가된 엔트리는 추후 dma_contiguous_remap() 함수를 통해 페이지 테이블에 IO 속성으로 매핑할 때 사용된다.
      • 참고: CMA(Contiguous Memory Allocator) for DMA | 문c
  • memblock_dump_all();
    • 커널 cmdline에 “debug” 옵션을 사용하는 경우 memory & reserve memblock 영역을 dump 한다.

아래 그림과 같은 순서로 몇 가지 영역을 reserved memblock에 추가한다.

arm_memblock_init-2

  • CMA 관련 테이블은 다음과 같이 2개이다.
    • dma_mmu_remap[] 배열은 추후 테이블에 IO 속성으로 매핑할 때 사용된다.
    • cma_areas[] 배열은 CMA 드라이버가 로드되면서 이 항목을 사용하여 초기화한다.

 

arm_mm_memblock_reserve()

arch/arm/mm/mmu.c

/*
 * Reserve the special regions of memory
 */
void __init arm_mm_memblock_reserve(void)
{
        /*   
         * Reserve the page tables.  These are already in use,
         * and can only be in node 0.
         */
        memblock_reserve(__pa(swapper_pg_dir), SWAPPER_PG_DIR_SIZE);

#ifdef CONFIG_SA1111
        /*   
         * Because of the SA1111 DMA bug, we want to preserve our
         * precious DMA-able memory...
         */
        memblock_reserve(PHYS_OFFSET, __pa(swapper_pg_dir) - PHYS_OFFSET);
#endif
}
  • 커널 1차 페이지 테이블 영역을 reserve memblock에 추가한다.

 

DTB for reserved memory region

일반적인 메모리 영역에서 특정 목적으로 제외(reserve)시켜야 하는 메모리 영역을 지정한다. 아래 예를 살펴본다.

  • reserved-memory 노드로 구성한다.
    • 구성 시 #address-cells와 #size-cells는 루트 노드의 것과 동일해야 한다.
    • ranges 속성이 존재해야 한다.
  • 서브 노드들에는 영역의 시작과 사이즈에 대한 정보가 포함되어 있다.
    • compatible 속성을 두어 연동되는 디바이스 드라이버를 지정할 수 있다.
    • cma 및 dma 드라이버의 경우는 디바이스명으로 “shared-cma-pool” 및 “shared-dma-pool” 로 지정되어 있고 이를 통해서 별도의 지정된 설정 함수를 실행시켜 초기화를 수행한다.
      • 아직 실제 dtb 사례에서 cma용 shared-cma-pool이나 dma용 shared-dma-pool 디바이스 명을 사용하여 구동시킨 사례는 찾아 볼 수 없었지만 설계는 이미 아래 예와 같이 되어 있고 코드도 준비되어 있다.
    • 영역의 크기 정보는 reg와 size를 통해서 한다.
      • reg 속성을 사용하는 경우 static한 방법으로 지정된 메모리 영역을 reserve memblock에 추가한다.
      • size 속성을 사용하는 경우 dynamic 한 방법을 사용하여 디바이스 드라이버가 시작 주소를 구해 영역을 reserve memblock에 추가한다.
        • alloc-range 속성 값으로 지정된 범위내에서 요청한 사이즈 공간을 찾아 reserve memblock에 추가한다.
        • alloc-range 속성을 지정하지 않은 경우 전체 메모리를 대상으로 요청된 사이즈 만큼 reserve memblock에 추가한다.
      • reg와 size를 동시에 지정하는 경우 size는 무시된다.
    • no-map 속성이 있는 경우에는 reserve 영역에서 오히려 제거한다.
/ {
	#address-cells = <1>;
	#size-cells = <1>;

	memory {
		reg = <0x40000000 0x40000000>;
	};

	reserved-memory {
		#address-cells = <1>;
		#size-cells = <1>;
		ranges;

		/* global autoconfigured region for contiguous allocations */
		linux,cma {
			compatible = "shared-dma-pool";
			reusable;
			size = <0x4000000>;
			alignment = <0x2000>;
			linux,cma-default;
		};

		display_reserved: framebuffer@78000000 {
			reg = <0x78000000 0x800000>;
		};

		multimedia_reserved: multimedia@77000000 {
			compatible = "acme,multimedia-memory";
			reg = <0x77000000 0x4000000>;
		};
	};

	/* ... */

	fb0: video@12300000 {
		memory-region = <&display_reserved>;
		/* ... */
	};

	scaler: scaler@12500000 {
		memory-region = <&multimedia_reserved>;
		/* ... */
	};

	codec: codec@12600000 {
		memory-region = <&multimedia_reserved>;
		/* ... */
	};
};

 

early_init_fdt_scan_reserved_mem()

drivers/of/fdt.c

/**
 * early_init_fdt_scan_reserved_mem() - create reserved memory regions
 *
 * This function grabs memory from early allocator for device exclusive use
 * defined in device tree structures. It should be called by arch specific code
 * once the early allocator (i.e. memblock) has been fully activated.
 */
void __init early_init_fdt_scan_reserved_mem(void)
{
        int n;
        u64 base, size;

        if (!initial_boot_params)
                return;

        /* Reserve the dtb region */
        early_init_dt_reserve_memory_arch(__pa(initial_boot_params),
                                          fdt_totalsize(initial_boot_params),
                                          0);

        /* Process header /memreserve/ fields */
        for (n = 0; ; n++) {
                fdt_get_mem_rsv(initial_boot_params, n, &base, &size);
                if (!size)
                        break; 
                early_init_dt_reserve_memory_arch(base, size, 0);
        }   

        of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
        fdt_init_reserved_mem();
}
  • early_init_dt_reserve_memory_arch(__pa(initial_boot_params), fdt_totalsize(initial_boot_params), 0);
    • DTB 영역을 reserve memblock에 추가한다.
  • fdt_get_mem_rsv(initial_boot_params, n, &base, &size);
    • DTB 헤더에서 reservedmem 필드가 가리키는 바이너리 영역을 읽어 reserve할 base(시작주소)및 size를 알아온다.
    • 사이즈가 0이 아닐때 까지 반복된다.
      • DTB에서 reserved memory block은 8바이트 숫자로 시작주소 및 사이즈가 필요한 만큼 반복된다.
  • early_init_dt_reserve_memory_arch(base, size, 0);
    • 알아온 영역을 다음 2가지 경우에 따라 처리한다.
      • static 방법: DTB에서 reg를 읽은 경우 base, size 정보로 reserve memblock에 추가한다.
      • dynamic 방법: DTB에서 size 속성을 읽은 경우 2번에 나누어 초기화 하는데 먼저 reserved_mem[] 배열에만 추가한다.
  • of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
    • 첫 번째 depth의 “reserved-memory” 노드명을 찾아 “status” 속성값이 “ok” 또는 “okay”인 경우 알아온 영역을 다음 2가지 경우에 따라 처리한다.
      • static 방법: DTB에서 reg를 읽은 경우 base, size 정보로 reserve memblock에 추가한다.
      • dynamic 방법: DTB에서 size 속성을 읽은 경우 2번에 나누어 초기화 하는데 먼저 reserved_mem[] 배열에만 추가한다.
  • fdt_init_reserved_mem();
    • dynamic 방법의 연장 즉 2nd phase 초기화로 reserved_mem[] 배열에 등록된 수 만큼 루프를 돌며 읽어와서 DTB의 alloc-range 속성이 요청하는 메모리 range 들에서 reserve할 영역을 찾은 경우 reserve memblock에 추가하고 등록된 디바이스를 찾아 초기화 함수를 실행하게 한다.

 

early_init_dt_reserve_memory_arch()

drivers/of/fdt.c

int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base,
                                        phys_addr_t size, bool nomap)
{
        if (nomap)
                return memblock_remove(base, size);
        return memblock_reserve(base, size);
}
  • nomap이 true인 경우 해당 영역을 reserve memblock에서 삭제한다.
  • nomap이 false인 경우 해당 영역을 reserve memblock에 추가한다.

 

__fdt_scan_reserved_mem()

drivers/of/fdt.c”

/**
 * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
 */
static int __init __fdt_scan_reserved_mem(unsigned long node, const char *uname,
                                          int depth, void *data)
{
        static int found;
        const char *status;
        int err;

        if (!found && depth == 1 && strcmp(uname, "reserved-memory") == 0) {
                if (__reserved_mem_check_root(node) != 0) {
                        pr_err("Reserved memory: unsupported node format, ignoring\n");
                        /* break scan */
                        return 1;
                }
                found = 1;
                /* scan next node */
                return 0;
        } else if (!found) {
                /* scan next node */
                return 0;
        } else if (found && depth < 2) {
                /* scanning of /reserved-memory has been finished */
                return 1;
        }

        status = of_get_flat_dt_prop(node, "status", NULL);
        if (status && strcmp(status, "okay") != 0 && strcmp(status, "ok") != 0)
                return 0;

        err = __reserved_mem_reserve_reg(node, uname);
        if (err == -ENOENT && of_get_flat_dt_prop(node, "size", NULL))
                fdt_reserved_mem_save_node(node, uname, 0, 0);

        /* scan next node */
        return 0;
}
  • if (!found && depth == 1 && strcmp(uname, “reserved-memory”) == 0) {
    • 1 depth 인 노드명이 “reserved-memory” 이면
    •  아래 예) arch/arm/boot/dts/atlas7-evb.dts
      • 0x5e80_0000 부터 8M를 reserve memblock에 추가
      • 0x4600_0000 부터 2M를 reserve memblock에서 삭제
        reserved-memory {
                #address-cells = <1>;
                #size-cells = <1>;
                ranges;

                vpp_reserved: vpp_mem@5e800000 {
                        compatible = "sirf,reserved-memory";
                        reg = <0x5e800000 0x800000>;
                };

                nanddisk_reserved: nanddisk@46000000 {
                        reg = <0x46000000 0x200000>;
                        no-map;
                };
        };
  • if (__reserved_mem_check_root(node) != 0) {
    • 현재 노드의 #address-cells와 #size-cells가 root 노드에 있는 #address-cells와 #size-cells와 같고 “ranges” 속성값이 제공되는 경우 성공리에 0이 리턴된다. 그 외에는 음수의 에러(-EINVAL)를 리턴한다.
  • status = of_get_flat_dt_prop(node, “status”, NULL);
    • reserved-memory 노드를 찾은 다음 depth의 노드에서 “status” 속성을 찾는다.
  • if (status && strcmp(status, “okay”) != 0 && strcmp(status, “ok”) != 0)
    • status 속성이 있는 경우 속성 값이 “okay”가 아니면서 “ok”도 아닌 경우 리턴한다.
  • err = __reserved_mem_reserve_reg(node, uname);
    • 해당 노드의 reg 속성 값으로 reserve memblock에 추가한다.
    • base 주소가 지정되지 않아 dynamic 할당을 시도하는 경우에는 reg 속성 대신 size 속성을 사용하므로 이 때에는 실패로 리턴하게 된다.
  • if (err == -ENOENT && of_get_flat_dt_prop(node, “size”, NULL))
    • 호출한 함수가 에러이면서 “size” 속성을 찾을 수 있는 경우
  • fdt_reserved_mem_save_node(node, uname, 0, 0);
    • 시작 주소와 사이즈를 0으로 해서 전역 변수 reserved_mem[] 배열에 추가한다.
    • 배열에 추가된 이 정보는 추후 fdt_init_reserved_mem() 함수를 호출하여 2nd phase 초기화를 수행하게 한다.

 

__reserved_mem_reserve_reg()

해당 함수는 CONFIG_OF_EARLY_FLATTREE 옵션을 사용한 경우에만 동작한다. (DTB 기본 옵션)

drivers/of/fdt.c

/**
 * res_mem_reserve_reg() - reserve all memory described in 'reg' property
 */
static int __init __reserved_mem_reserve_reg(unsigned long node,
                                             const char *uname)
{
        int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
        phys_addr_t base, size;
        int len;
        const __be32 *prop;
        int nomap, first = 1;

        prop = of_get_flat_dt_prop(node, "reg", &len);
        if (!prop)
                return -ENOENT;

        if (len && len % t_len != 0) {
                pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
                       uname);
                return -EINVAL;
        }

        nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;

        while (len >= t_len) {
                base = dt_mem_next_cell(dt_root_addr_cells, &prop);
                size = dt_mem_next_cell(dt_root_size_cells, &prop);

                if (size &&
                    early_init_dt_reserve_memory_arch(base, size, nomap) == 0)
                        pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %ld MiB\n",
                                uname, &base, (unsigned long)size / SZ_1M);
                else
                        pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %ld MiB\n",
                                uname, &base, (unsigned long)size / SZ_1M);

                len -= t_len;
                if (first) {
                        fdt_reserved_mem_save_node(node, uname, base, size);
                        first = 0;
                }
        }
        return 0;
}

DTB를 분석하여 다음 두 가지 방법 중 하나를 사용하여 memblock에 등록한다.

  • static
    • reserved-mem 노드의 reg 속성에 지정된 크기로 memblock에 곧장 등록한다.
  • dynamic
    • reserved-mem 노드의 size 속성이 지정된 경우 reserved_mem[] 배열에 추가하고 추 후 second pass initialization 루틴(fdt_init_reserved_mem())이 호출될 때 초기화를 진행하게 한다.

 

  • int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
    • 루트 노드에 있는 #addr-cells + #size-cells를 4로 곱한 값이 처리할 데이터 길이다.
  • prop = of_get_flat_dt_prop(node, “reg”, &len);
    • “reg” 속성을 찾는다.
  • nomap = of_get_flat_dt_prop(node, “no-map”, NULL) != NULL;
    • “no-map” 속성이 찾아지면 true
      • reserve영역에서 해지
  • base = dt_mem_next_cell(dt_root_addr_cells, &prop);
    • 루트노드의 #addr-cells x 4 바이트 만큼 읽어서 base에 저장한다.
  • size = dt_mem_next_cell(dt_root_size_cells, &prop);
    • 루트노드의 #size-cells x 4 바이트 만큼 읽어서 size에 저장한다.
  • if (size && early_init_dt_reserve_memory_arch(base, size, nomap) == 0)
    • size가 주어진 경우 해당 영역을 static하게 reserve memblock에 추가하거나 삭제한다.
  •  fdt_reserved_mem_save_node(node, uname, base, size);
    • 처음 한 번만 이루틴이 호출된다.
    • 전역 구조체 reserved_mem[] 배열에 노드 포인터, 노드명, 시작주소, 사이즈 등을 추가한다.
    • 이 배열은 추후에 fdt_init_reserved_mem() 함수가 호출될 때 초기화를 수행한다.

 

fdt_reserved_mem_save_node()

drivers/of/of_reserved_mem.c

/**
 * res_mem_save_node() - save fdt node for second pass initialization
 */
void __init fdt_reserved_mem_save_node(unsigned long node, const char *uname,
                                      phys_addr_t base, phys_addr_t size)
{
        struct reserved_mem *rmem = &reserved_mem[reserved_mem_count];

        if (reserved_mem_count == ARRAY_SIZE(reserved_mem)) {
                pr_err("Reserved memory: not enough space all defined regions.\n");
                return;
        }

        rmem->fdt_node = node;
        rmem->name = uname;
        rmem->base = base;
        rmem->size = size;

        reserved_mem_count++;
        return;
}
  • 전역 구조체 reserved_mem[] 배열에 노드 포인터, 노드명, 시작주소, 사이즈 등을 추가하고 전역 변수 reserved_mem_count를 증가시킨다.
  • 배열은 MAX_RESERVED_REGIONS(16)개로 초기화되어 있다.

 

reserved mem 초기화

fdt_init_reserved_mem()

drivers/of/of_reserved_mem.c

/**
 * fdt_init_reserved_mem - allocate and init all saved reserved memory regions
 */
void __init fdt_init_reserved_mem(void)
{
        int i;
        for (i = 0; i < reserved_mem_count; i++) {
                struct reserved_mem *rmem = &reserved_mem[i];
                unsigned long node = rmem->fdt_node;
                int len;
                const __be32 *prop;
                int err = 0;

                prop = of_get_flat_dt_prop(node, "phandle", &len);
                if (!prop)
                        prop = of_get_flat_dt_prop(node, "linux,phandle", &len);
                if (prop)
                        rmem->phandle = of_read_number(prop, len/4);

                if (rmem->size == 0)
                        err = __reserved_mem_alloc_size(node, rmem->name,
                                                 &rmem->base, &rmem->size);
                if (err == 0)               
                        __reserved_mem_init_node(rmem);
        }            
}

dynamic 방법에 의해 등록된 reserved_mem[] 배열을 읽어 DTB alloc-range 속성이 요청한 메모리 범위에서 size 속성 만큼 reserve 할 수 있는 영역을 찾고 성공한 경우 reserve memblock을 추가한다. 그런 후 각 디바이스 드라이버에 지정된  callback 함수(of_device_id->data)를 호출하여 해당 디바이스 드라이버를 초기화한다.

  • reserved_mem[] 배열에 등록된 항목들을 모두 조회한다.
  • unsigned long node = rmem->fdt_node;
    • rmem->fdt_node는 DTB에 reserved-mem 노드로 등록된 노드이다.
  •  prop = of_get_flat_dt_prop(node, “phandle”, &len);
    • 해당 노드에서 “phandle” 속성을 찾는다. 없으면 “linux,phandle”에서도 찾아본다.
  • if (prop) rmem->phandle = of_read_number(prop, len/4);
    • 속성이 발견되면 rmem->phandle에 값을 읽어 udpate 한다.
  •  err = __reserved_mem_alloc_size(node, rmem->name, &rmem->base, &rmem->size);
    • rmem->size가 0인 경우는 base 주소가 dynamic하게 지정될 수 있게 __reserved_mem_alloc_size() 함수를 호출하여 reserve memblock에 영역을 추가한다.
      • 추가할 사이즈 정보는 DTB의 size 속성을 읽어오고 범위 정보는 DTB의 alloc-range 속성을 읽어온다.
  • __reserved_mem_init_node(rmem);
    • 에러가 없는 경우 __reserved_mem_init_node() 함수를 호출하여 관련 reserved memory에 대한 해당 디바이스의 초기화 함수를 __rmem_of_table_sentinel 테이블에서 검색하여 호출한다.

 

__reserved_mem_init_node()

drivers/of/of_reserved_mem.c

/**
 * res_mem_alloc_size() - allocate reserved memory described by 'size', 'align'
 *                        and 'alloc-ranges' properties
 */
static int __init __reserved_mem_alloc_size(unsigned long node,
        const char *uname, phys_addr_t *res_base, phys_addr_t *res_size)
{
        int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
        phys_addr_t start = 0, end = 0;
        phys_addr_t base = 0, align = 0, size;
        int len;
        const __be32 *prop;
        int nomap;
        int ret;

        prop = of_get_flat_dt_prop(node, "size", &len);
        if (!prop)
                return -EINVAL;

        if (len != dt_root_size_cells * sizeof(__be32)) {
                pr_err("Reserved memory: invalid size property in '%s' node.\n",
                                uname);
                return -EINVAL;
        }
        size = dt_mem_next_cell(dt_root_size_cells, &prop);

        nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;

        prop = of_get_flat_dt_prop(node, "alignment", &len);
        if (prop) {
                if (len != dt_root_addr_cells * sizeof(__be32)) {
                        pr_err("Reserved memory: invalid alignment property in '%s' node.\n",
                                uname);
                        return -EINVAL;
                }
                align = dt_mem_next_cell(dt_root_addr_cells, &prop);
        }

dynamic 방법으로 alloc-ranges 속성이 지정한 범위 내에서 지정한 영역 크기를 reserve memblock에 추가한다.

  • int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
    • 노드에서 읽어와야 할 바이트 수를 알아낸다.
  • prop = of_get_flat_dt_prop(node, “size”, &len);
    • size 속성을 읽어와서 없으면 에러를 리턴한다.
  • if (len != dt_root_size_cells * sizeof(__be32)) {
    • 루트 노드의 #size-cells와 reserved-mem 노드의 #size-cells가 다른 경우 메시지를 출력하고 에러로 리턴한다.
  • size = dt_mem_next_cell(dt_root_size_cells, &prop);
    • size 속성에서 값(byte)을 읽어온다.
  • nomap = of_get_flat_dt_prop(node, “no-map”, NULL) != NULL;
    • no-map 속성이 있으면 true가 된다.
  • prop = of_get_flat_dt_prop(node, “alignment”, &len);
    • alignment 속성을 찾는다.
  • if (len != dt_root_addr_cells * sizeof(__be32)) {
    • 루트 노드의 #addr-cells와 reserved-mem 노드의 #addr-cells가 다른 경우 메시지를 출력하고 에러로 리턴한다.
  • align = dt_mem_next_cell(dt_root_addr_cells, &prop);
    • align 값을 읽어온다.
        prop = of_get_flat_dt_prop(node, "alloc-ranges", &len);
        if (prop) {

                if (len % t_len != 0) {
                        pr_err("Reserved memory: invalid alloc-ranges property in '%s', skipping node.\n",
                               uname);
                        return -EINVAL;
                }

                base = 0;

                while (len > 0) {
                        start = dt_mem_next_cell(dt_root_addr_cells, &prop);
                        end = start + dt_mem_next_cell(dt_root_size_cells,
                                                       &prop);

                        ret = early_init_dt_alloc_reserved_memory_arch(size,
                                        align, start, end, nomap, &base);
                        if (ret == 0) {
                                pr_debug("Reserved memory: allocated memory for '%s' node: base %pa, size %ld MiB\n",
                                        uname, &base,
                                        (unsigned long)size / SZ_1M);
                                break;
                        }
                        len -= t_len;
                }

        } else {
                ret = early_init_dt_alloc_reserved_memory_arch(size, align,
                                                        0, 0, nomap, &base);
                if (ret == 0)
                        pr_debug("Reserved memory: allocated memory for '%s' node: base %pa, size %ld MiB\n",
                                uname, &base, (unsigned long)size / SZ_1M);
        }

        if (base == 0) {
                pr_info("Reserved memory: failed to allocate memory for node '%s'\n",
                        uname);
                return -ENOMEM;
        }

        *res_base = base;
        *res_size = size;

        return 0;
}
  • prop = of_get_flat_dt_prop(node, “alloc-ranges”, &len);
    • alloc_ranges 속성을 찾는다.
  • if (len % t_len != 0) {
    • 루트 노드의 #addr-cells 및 #size-cells 가 reserved-mem 노드의 #addr-cells 및 #size-cells가 다른 경우 메시지를 출력하고 에러를 리턴한다.
  • while (len > 0) {
    • alloc_ranges 속성에서 영역을 여러 개의 배열로 지정한 경우를 위해 루프를 돈다.
  • start = dt_mem_next_cell(dt_root_addr_cells, &prop);
    • 시작 주소를 알아온다.
  • end = start + dt_mem_next_cell(dt_root_size_cells, &prop);
    • 끝 주소를 알아온다.
  • ret = early_init_dt_alloc_reserved_memory_arch(size, align, start, end, nomap, &base);
    • 읽어온 검색 범위에서 reserve memblock을 시도하고 성공하면 루프를 빠져나온다.
  • ret = early_init_dt_alloc_reserved_memory_arch(size, align, 0, 0, nomap, &base);
    • alloc-ranges 속성이 없는 경우에는 검색 범위를 메모리 전체로 지정하여 reserve memblock을 수행한다.
  • if (base == 0) {
    • reserve할 공간이 없어 실패한 경우 메시지를 출력하고 에러를 리턴한다.

 

__reserved_mem_init_node()

drivers/of/of_reserved_mem.c

/**
 * res_mem_init_node() - call region specific reserved memory init code
 */
static int __init __reserved_mem_init_node(struct reserved_mem *rmem)
{
        extern const struct of_device_id __reservedmem_of_table[];
        const struct of_device_id *i;

        for (i = __reservedmem_of_table; i < &__rmem_of_table_sentinel; i++) {
                reservedmem_of_init_fn initfn = i->data;
                const char *compat = i->compatible;

                if (!of_flat_dt_is_compatible(rmem->fdt_node, compat))
                        continue;

                if (initfn(rmem) == 0) {
                        pr_info("Reserved memory: initialized node %s, compatible id %s\n",
                                rmem->name, compat);
                        return 0;
                }
        }
        return -ENOENT;
}

DTB의 reserved-mem 노드의 sub 노드가 사용하는 디바이스명(compat)으로 커널에 등록된 __reservedmem_of_table 에서 검색하여 해당 초기화 함수를 호출한다.

  • __reservedmem_of_table에서 __rmem_of_table_sentinel까지 루프를 돌며 of_device_id 구조체 값을 가져온다.
  • if (!of_flat_dt_is_compatible(rmem->fdt_node, compat))
    • 가져온 구조체의 compat(드라이버명)이 요청한 노드와 같은 드라이버명을 사용하지 않는 경우 continue를 호출하여 다음을 검색한다.
  •  if (initfn(rmem) == 0) {
    • 드라이버명이 같은 경우 해당 구조체의 data에 등록된 함수를 호출한다.
  • 전체를 검색하여 실패한 경우  에러를 리턴한다.

 

__reservedmem_of_table

현재 커널에는 아래와 같이 두 개의 디바이스 드라이버 코드가 준비되어 있다.

  • rpi2: __of_device_cma와 __of_device_dma 두 개 구조체명이 __reservedmem_of_table에 등록된다.

 

struct __of_device_cma

CMA for DMA mapping framework 용도의 디바이스 드라이버로 사용된다.

drivers/base/dma-contiguous.c

static const struct reserved_mem_ops rmem_cma_ops = { 
        .device_init    = rmem_cma_device_init,
        .device_release = rmem_cma_device_release,
};

static int __init rmem_cma_setup(struct reserved_mem *rmem)
{
        phys_addr_t align = PAGE_SIZE << max(MAX_ORDER - 1, pageblock_order);
        phys_addr_t mask = align - 1;
        unsigned long node = rmem->fdt_node;
        struct cma *cma;
        int err;

        if (!of_get_flat_dt_prop(node, "reusable", NULL) ||
            of_get_flat_dt_prop(node, "no-map", NULL))
                return -EINVAL;

        if ((rmem->base & mask) || (rmem->size & mask)) {
                pr_err("Reserved memory: incorrect alignment of CMA region\n");
                return -EINVAL;
        }

        err = cma_init_reserved_mem(rmem->base, rmem->size, 0, &cma);
        if (err) {
                pr_err("Reserved memory: unable to setup CMA region\n");
                return err;
        }
        /* Architecture specific contiguous memory fixup. */
        dma_contiguous_early_fixup(rmem->base, rmem->size);

        if (of_get_flat_dt_prop(node, "linux,cma-default", NULL))
                dma_contiguous_set_default(cma);

        rmem->ops = &rmem_cma_ops;
        rmem->priv = cma;

        pr_info("Reserved memory: created CMA memory pool at %pa, size %ld MiB\n",
                &rmem->base, (unsigned long)rmem->size / SZ_1M);

        return 0;
}
RESERVEDMEM_OF_DECLARE(cma, "shared-cma-pool", rmem_cma_setup);

RESERVEDMEM_OF_DECLARE를 통해서 __of_table_cma 이름의 of_device_id 구조체가 __reservedmem_of_table에 등록된다.

  • 디바이스명(compat)은 “shared-cma-pool”이다.
  • 이 디바이스의 초기화 함수는 rmem_cma_setup() 함수이다.

 

struct __of_device_dma

DMA for Coherent per-device 메모리 핸들링을 위한 디바이스 드라이버에 사용된다.

drivers/base/dma-coherent.c

static const struct reserved_mem_ops rmem_dma_ops = { 
        .device_init    = rmem_dma_device_init,
        .device_release = rmem_dma_device_release,
};

static int __init rmem_dma_setup(struct reserved_mem *rmem)
{
        unsigned long node = rmem->fdt_node;

        if (of_get_flat_dt_prop(node, "reusable", NULL))
                return -EINVAL;

#ifdef CONFIG_ARM
        if (!of_get_flat_dt_prop(node, "no-map", NULL)) {
                pr_err("Reserved memory: regions without no-map are not yet supported\n");
                return -EINVAL;
        }   
#endif

        rmem->ops = &rmem_dma_ops;
        pr_info("Reserved memory: created DMA memory pool at %pa, size %ld MiB\n",
                &rmem->base, (unsigned long)rmem->size / SZ_1M);
        return 0;
}
RESERVEDMEM_OF_DECLARE(dma, "shared-dma-pool", rmem_dma_setup);
  • RESERVEDMEM_OF_DECLARE를 통해서 __of_table_dma 이름의 of_device_id 구조체가 __reservedmem_of_table에 등록된다.
    • 디바이스명(compat) “shared-dma-pool”이다.
    • 이 디바이스의 초기화 함수는 rmem_dma_setup() 함수이다.

 

구조체 및 전역 변수

 

reserved_mem 구조체

include/linux/of_reserved_mem.h

struct reserved_mem {
        const char                      *name;
        unsigned long                   fdt_node;
        unsigned long                   phandle;
        const struct reserved_mem_ops   *ops;
        phys_addr_t                     base;
        phys_addr_t                     size;
        void                            *priv;
};

 

reserved_mem_ops 구조체

include/linux/of_reserved_mem.h

struct reserved_mem_ops {
        int     (*device_init)(struct reserved_mem *rmem,
                               struct device *dev);
        void    (*device_release)(struct reserved_mem *rmem,
                                  struct device *dev);
};

 

전역변수

drivers/of/of_reserved_mem.c

static const struct of_device_id __rmem_of_table_sentinel
        __used __section(__reservedmem_of_table_end);

 

#define MAX_RESERVED_REGIONS    16
static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS];
static int reserved_mem_count;

 

참고

 

sanity_check_meminfo()

이 함수에서는 등록된 memory memblock에 대해 미리 사전 체크를 하여 early memory allocator로 동작할 수 있도록 다음과 같이 준비한다.

  • lowmem 영역만 사용해야 하는 case에 대해 memblock 영역 삭제
    • HIGHMEM을 사용하지 않을 경우 또는 캐시가 VIPT aliasing을 사용하는 경우 memory 영역에 등록된 memblock 들이 lowmem 영역을 초과하는 경우 해당 초과 영역들을 제거한다.
  • arm_lowmem_limithigh_memory 설정
    • memory block의 끝 주소를 arm_lowmem_limit으로 하되  vmalloc_limit(vmalloc_min의 물리주소)을 초과하지 않도록 한다.
    • high_memory는 arm_lowmem_limit의 가상 주소 값이다.
  • memblock.current_limit 설정
    • memory memblock들이 2M 단위로 align되어 있어야 커널 설정 초기에 사용되는 early memory allocator에서 2M 영역을 할당하여 사용하는 reserve memblock을 운영하여야 하므로 각 memory memblock 들이 2M align되어 있지 않은 memblock이 있는 경우 그 지점의 2M round down 주소까지로 사용을 제한하도록 memblock_limit를 설정한다.

sanity_check_meminfo_1a

 

sanity_check_meminfo()

arch/arm/mm/mmu.c

void __init sanity_check_meminfo(void)
{
        phys_addr_t memblock_limit = 0; 
        int highmem = 0; 
        phys_addr_t vmalloc_limit = __pa(vmalloc_min - 1) + 1; 
        struct memblock_region *reg;

        for_each_memblock(memory, reg) {
                phys_addr_t block_start = reg->base;
                phys_addr_t block_end = reg->base + reg->size;
                phys_addr_t size_limit = reg->size;

                if (reg->base >= vmalloc_limit)
                        highmem = 1; 
                else
                        size_limit = vmalloc_limit - reg->base;


                if (!IS_ENABLED(CONFIG_HIGHMEM) || cache_is_vipt_aliasing()) {

                        if (highmem) {
                                pr_notice("Ignoring RAM at %pa-%pa (!CONFIG_HIGHMEM)\n",
                                          &block_start, &block_end);
                                memblock_remove(reg->base, reg->size);
                                continue;
                        }

                        if (reg->size > size_limit) {
                                phys_addr_t overlap_size = reg->size - size_limit;

                                pr_notice("Truncating RAM at %pa-%pa to -%pa",
                                          &block_start, &block_end, &vmalloc_limit);
                                memblock_remove(vmalloc_limit, overlap_size);
                                block_end = vmalloc_limit;
                        }
                }
  • phys_addr_t vmalloc_limit = __pa(vmalloc_min – 1) + 1;
    • vmalloc_min
      • VMALLOC_END(0xff00_0000) – (240 << 20) – VMALLOC_OFFSET(8M)
      • 0xff00_000 – 240M – 8M = 0xef80_0000
      • VMALLOC 영역이 최소 보장되어야 하는 하한 주소로 아키텍처 마다 다르다.
        • 32 bit ARM 에서는 0xef80_0000으로 고정되어 사용된다.
    • vmalloc_limit
      • vmalloc_min의 물리 주소가 담긴다.
      • rpi2: 0x6f80_0000
  • for_each_memblock(memory, reg) {
    • 등록된 전체 memory memblock 영역을 루프로 돈다.
  • if (reg->base >= vmalloc_limit)
    • 영역의 시작 물리 주소가 vmalloc_limit을 초과한 경우 highmem 영역이라 판단한다.
  • if (!IS_ENABLED(CONFIG_HIGHMEM) || cache_is_vipt_aliasing()) {
    • HIGHMEM 설정이 안되어 있거나 d-cache가 vipt aliasing을 사용하는 경우
      • rpi2: d-cache는 CACHEID_VIPT_NONALIASING
  • if (highmem) {
    • highmem 영역을 사용하는 블럭은 삭제한다.
  • if (reg->size > size_limit) {
    • size가 lowmem 영역을 넘어가는 경우 넘어가는 부분 만큼을 제거한다.

HIGHMEM을 사용하지 않는 경우 memblock들이 vmalloc_limit을 초과하는 경우 해당 영역을 제거한다.

sanity_check_meminfo_3b

 

                if (!highmem) {
                        if (block_end > arm_lowmem_limit) {
                                if (reg->size > size_limit)
                                        arm_lowmem_limit = vmalloc_limit;
                                else
                                        arm_lowmem_limit = block_end;
                        }
  • if (block_end > arm_lowmem_limit) {
    • 블럭이 arm_lowmem_limit를 초과한 경우
  • if (reg->size > size_limit)
    • 블럭 사이즈가 lowmem 영역까지 남은 공간을 초과하는 경우 arm_lowmem_limit에 vmalloc_limit을 대입하고 그렇지 않은 경우 블럭의 끝을 지정한다.

sanity_check_meminfo_4a

 

                        /*
                         * Find the first non-pmd-aligned page, and point
                         * memblock_limit at it. This relies on rounding the
                         * limit down to be pmd-aligned, which happens at the
                         * end of this function.
                         *
                         * With this algorithm, the start or end of almost any
                         * bank can be non-pmd-aligned. The only exception is
                         * that the start of the bank 0 must be section-
                         * aligned, since otherwise memory would need to be
                         * allocated when mapping the start of bank 0, which
                         * occurs before any free memory is mapped.
                         */
                        if (!memblock_limit) {
                                if (!IS_ALIGNED(block_start, PMD_SIZE))
                                        memblock_limit = block_start;
                                else if (!IS_ALIGNED(block_end, PMD_SIZE))
                                        memblock_limit = arm_lowmem_limit;
                        }

                }
        }

        high_memory = __va(arm_lowmem_limit - 1) + 1;

        /*
         * Round the memblock limit down to a pmd size.  This
         * helps to ensure that we will allocate memory from the
         * last full pmd, which should be mapped.
         */
        if (memblock_limit)
                memblock_limit = round_down(memblock_limit, PMD_SIZE);
        if (!memblock_limit)
                memblock_limit = arm_lowmem_limit;

        memblock_set_current_limit(memblock_limit);
}
  • if (!memblock_limit) {
    • memblock_limit값이 설정되지 않았으면
  • if (!IS_ALIGNED(block_start, PMD_SIZE))
    • 블럭의 시작 주소가 2M align되어 있지 않은 경우 memblock_limit에 블럭 시작 주소를 대입한다.
  • else if (!IS_ALIGNED(block_end, PMD_SIZE))
    • 블럭의 끝 주소가 2M align되어 있지 않은 경우 memblock_limit에 블럭 끝 주소를 대입한다.
  • memblock_limit = round_down(memblock_limit, PMD_SIZE);
    • memblock_limit 주소를 2M round down 한다.
  • memblock_set_current_limit(memblock_limit);
    • 전역 변수 memblock.current_limit를 설정한다.
  • 등록된 memblock은 커널 설정 초기에 2M 단위의 메모리를 할당 받아 사용한다. 따라서 align되지 않은 메모리가 배열에 등록된 경우 align 된 영역까지만 사용하고 나머지 메모리는 사용하지 않도록 memblock_limit를 설정한다.

sanity_check_meminfo_5a

 

lowmem 영역

  • lowmem 영역은 물리 메모리가 1:1로 커널 영역에 매핑되어 사용할 수 있는 영역이다.
    • vmalloc_limit
      • 현재 커널에서 lowmem 영역을 최대 키울 수 있는 한도내의 물리 메모리 끝 주소
      • 메모리 크기와 관계 없이 커널 영역의 크기에 따라 계산되는 물리 주소
      • 예)
        • VM_SPLIT_3G: 0x2f80_0000 (max lowmem=760M)
        • VM_SPLIT_2G: 0x6f80_0000 (max lowmem=1G+760M)
    • arm_lowmem_limit
      • 물리 메모리 크기가 max lowmem을 초과하는 경우 arm_lowmem_limit는 vmalloc_limit 값과 동일하다.
      • 물리 메모리 크기가 max lowmem보다 작은 경우 arm_lowmem_limit는 물리 메모리의 끝 주소가 대입된다.
    • high_memory
      • arm_lowmem_limit의 가상 주소와 동일하다.

sanity_check_meminfo_2b

 

참고

early_paging_init()

해당 머신의 바뀐 메모리 정보를 위해 초기화를 수행한다. LPAE의 경우 phisical to virtual transalation이 필요하여 추가로 몇 개의 루틴들이 수행되어야 한다.

  • mdesc→init_meminfo() 수행
  • LPAE의 경우 추가로 다음 항목들 수행
    • fixup_pv_table() 수행
    • page table  수정
    • 캐시 플러쉬
    • 해당 CPU 아키텍처의 MMU에 페이지 테이블 설정 변경
    • TTBR1 레지스터 재 설정
    • BP 및 TLB 캐시 플러쉬

early_paging_init

 

early_paging_init()

  • CONFIG_ARM_LPAE가 설정된 경우 두 개의 구현된 함수 중 윗 부분 함수를 수행하고 그렇지 않은 경우 아랫 부분 함수를 수행한다.
  • 머신 구조체의 init_meminfo 콜백 함수가 등록되어 있지 않은 경우 early하게 메모리 정보를 초기화(주로 패치 목적) 할 필요가 없는 것으로 간주하고 빠져나간다.
  • init_mm은 커널이 사용하는 mm_struct 구조체 포인터 변수이다.
  • 커널 코드의 시작과 끝을 map_start, map_end에 저장
  • pgd_offset_k(0)은 커널이 사용하는 pgd(페이지 글로벌 디렉토리)에 있는 첫 번째 엔트리 주소를 알아온다.
  • mdesc->init_meminfo() 콜백 함수를 사용하여 메모리 정보를 초기화한다. 이를 통해 메모리 기초 정보가 바뀌었으므로 관련 정보를 모두 수정하여야 한다. 커널 4.2에서 이 멤버 변수는 pv_fixup으로 변경된다.
    • fixup_pv_table()을 호출하여 각 pv_table 엔트리들을 모두 패치한다.
    • pv_table의 내용이 바뀌었으므로 flush_cache_louis() 함수를 사용하여 명령 캐시(i-cache) 를 flush 한다.
    • 레벨1과 레벨2의 페이지 테이블을 다시 매핑한다.
    • flush_cache_all()을 사용하여 모든 캐시를 비운다.
    • cpu_switch_mm()
      • ARMv7:
        • TTBR0에 pgd0를 설정한다.
        • CONTEXTIDR에 Context ID를 설정한다.
    • cpu_set_ttbr()을 사용하여 TTBR 1레지스터를 설정한다.
    • 마지막으로 branch predict 캐시와 TLB 캐시를 모두 비운다.
#ifdef CONFIG_ARM_LPAE
/*
 * early_paging_init() recreates boot time page table setup, allowing machines
 * to switch over to a high (>4G) address space on LPAE systems
 */
void __init early_paging_init(const struct machine_desc *mdesc,
                              struct proc_info_list *procinfo)
{
        pmdval_t pmdprot = procinfo->__cpu_mm_mmu_flags;
        unsigned long map_start, map_end;
        pgd_t *pgd0, *pgdk;
        pud_t *pud0, *pudk, *pud_start;
        pmd_t *pmd0, *pmdk;
        phys_addr_t phys;
        int i;

        if (!(mdesc->init_meminfo))
                return;

        /* remap kernel code and data */
        map_start = init_mm.start_code & PMD_MASK;
        map_end   = ALIGN(init_mm.brk, PMD_SIZE);

        /* get a handle on things... */
        pgd0 = pgd_offset_k(0);
        pud_start = pud0 = pud_offset(pgd0, 0);
        pmd0 = pmd_offset(pud0, 0);

        pgdk = pgd_offset_k(map_start);
        pudk = pud_offset(pgdk, map_start);
        pmdk = pmd_offset(pudk, map_start);

        mdesc->init_meminfo();

        /* Run the patch stub to update the constants */
        fixup_pv_table(&__pv_table_begin,
                (&__pv_table_end - &__pv_table_begin) << 2);

        /*
         * Cache cleaning operations for self-modifying code
         * We should clean the entries by MVA but running a
         * for loop over every pv_table entry pointer would
         * just complicate the code.
         */
        flush_cache_louis();
        dsb(ishst);
        isb();

        /*
         * FIXME: This code is not architecturally compliant: we modify
         * the mappings in-place, indeed while they are in use by this
         * very same code.  This may lead to unpredictable behaviour of
         * the CPU.
         *
         * Even modifying the mappings in a separate page table does
         * not resolve this.
         *
         * The architecture strongly recommends that when a mapping is
         * changed, that it is changed by first going via an invalid
         * mapping and back to the new mapping.  This is to ensure that
         * no TLB conflicts (caused by the TLB having more than one TLB
         * entry match a translation) can occur.  However, doing that
         * here will result in unmapping the code we are running.
         */
        pr_warn("WARNING: unsafe modification of in-place page tables - tainting kernel\n");
        add_taint(TAINT_CPU_OUT_OF_SPEC, LOCKDEP_STILL_OK);

        /*
         * Remap level 1 table.  This changes the physical addresses
         * used to refer to the level 2 page tables to the high
         * physical address alias, leaving everything else the same.
         */
        for (i = 0; i < PTRS_PER_PGD; pud0++, i++) {
                set_pud(pud0,
                        __pud(__pa(pmd0) | PMD_TYPE_TABLE | L_PGD_SWAPPER));
                pmd0 += PTRS_PER_PMD;
        }

        /*
         * Remap the level 2 table, pointing the mappings at the high
         * physical address alias of these pages.
         */
        phys = __pa(map_start);
        do {
                *pmdk++ = __pmd(phys | pmdprot);
                phys += PMD_SIZE;
        } while (phys < map_end);

        /*
         * Ensure that the above updates are flushed out of the cache.
         * This is not strictly correct; on a system where the caches
         * are coherent with each other, but the MMU page table walks
         * may not be coherent, flush_cache_all() may be a no-op, and
         * this will fail.
         */
        flush_cache_all();

        /*
         * Re-write the TTBR values to point them at the high physical
         * alias of the page tables.  We expect __va() will work on
         * cpu_get_pgd(), which returns the value of TTBR0.
         */
        cpu_switch_mm(pgd0, &init_mm);
        cpu_set_ttbr(1, __pa(pgd0) + TTBR1_OFFSET);

        /* Finally flush any stale TLB values. */
        local_flush_bp_all();
        local_flush_tlb_all();
}
#else

void __init early_paging_init(const struct machine_desc *mdesc,
 struct proc_info_list *procinfo)
{
 if (mdesc->init_meminfo)
 mdesc->init_meminfo();
}

#endif

 

cpu_switch_mm() 매크로

  • cpu_do_switch_mm 매크로를 호출하여 MMU에 페이지 디렉토리 설정 변경을 요청한다.
  • cpu_do_switch_mm 매크로는 각 아키텍처에 따라 수행 방법이 다르다.
    • MULTI_CPU를 사용하는 경우
      • processor->switch_mm() 콜백 함수를 호출한다.
        • switch_mm() 콜백 함수는 페이지 테이블을 설정한다.
      • ARMv7:
        • CONFIG_CPU_V7을 사용하므로 MULTI_CPU 이다.
        • switch_mm은 cpu_v7_switch_mm() 함수가 연결되어 있다.
    • MULTI_CPU를 사용하지 않는 경우
      • 각 아키텍처 이름에 맞게 호출 함수가 존재한다.

arch/arm/include/asm/proc-fns.h

#define cpu_switch_mm(pgd,mm) cpu_do_switch_mm(virt_to_phys(pgd),mm)
  • 아래와 같이 두 개의 루틴 중 빌드 구성에 따라 선택하여 호출한다.

arch/arm/include/asm/glue-proc.h

#define cpu_do_switch_mm                __glue(CPU_NAME,_switch_mm)
  • __glue() 매크로는 두 개의 인수를 합친다.

arch/arm/include/asm/proc-fns.h

#define cpu_do_switch_mm                processor.switch_mm
  • MULTI_CPU로 설정된 경우 해당 프로세서 구조체를 통해 호출

 

cpu_v7_switch_mm()

  • CONTEXTIDR 레지스터에 context ID(tsk) 설정
  • TTBR0에 pgd0 설정

arch/arm/mm/proc-v7-2level.S

/*
 *      cpu_v7_switch_mm(pgd_phys, tsk)
 *
 *      Set the translation table base pointer to be pgd_phys
 *
 *      - pgd_phys - physical address of new TTB
 *
 *      It is assumed that:
 *      - we are not using split page tables
 */
ENTRY(cpu_v7_switch_mm)
#ifdef CONFIG_MMU
        mov     r2, #0
        mmid    r1, r1                          @ get mm->context.id
        ALT_SMP(orr     r0, r0, #TTB_FLAGS_SMP)
        ALT_UP(orr      r0, r0, #TTB_FLAGS_UP)
#ifdef CONFIG_ARM_ERRATA_430973
        mcr     p15, 0, r2, c7, c5, 6           @ flush BTAC/BTB
#endif
#ifdef CONFIG_PID_IN_CONTEXTIDR
        mrc     p15, 0, r2, c13, c0, 1          @ read current context ID
        lsr     r2, r2, #8                      @ extract the PID
        bfi     r1, r2, #8, #24                 @ insert into new context ID
#endif
#ifdef CONFIG_ARM_ERRATA_754322
        dsb
#endif
        mcr     p15, 0, r1, c13, c0, 1          @ set context ID
        isb
        mcr     p15, 0, r0, c2, c0, 0           @ set TTB 0
        isb
#endif
        bx      lr
ENDPROC(cpu_v7_switch_mm)

 

 

__glue() 매크로

  • 2 개의 인수를 합쳐 하나의 이름으로 만든다.

arch/arm/include/asm/glue.h

#define ____glue(name,fn)       name##fn
#define __glue(name,fn)         ____glue(name,fn)

 

 

 

flush_cache_louis()

  • setup_arch() → early_paging_init() – flush_cache_louis()

flush_cache_louis

parse_early_param()

<kernel v5.0>

커멘드 라인 파라미터 파싱

부트 커멘드라인 문자열을 파싱하여 해당 파라미터가 early 파라미터인 경우 해당 설정 함수를 호출한다.

boot_command_line(이하 cmdline 또는 커멘드 라인) 파라미터로 요청받은 문자열을 토큰으로 parsing 하여 이에 대응하는 설정 함수를 setup_param 테이블에서 찾고 해당 항목이 early로 설정되어 있는 경우 이를 호출하여 실행한다. 또한 요청 토큰이 “console”인 경우 setup_param 테이블에서 “earlycon”을 찾아 해당 설정 함수를 호출한다. DTB 내부에서도 chosen 노드의  stdout-path 속성값에 해당하는 console  디바이스를 earlycon_of_table 에서 찾은 경우 해당 설정 함수를 동작시킨다.

  • setup_param 테이블에서 early_console 함수를 찾아 등록된 초기화 함수 수행
    • __setup_start 부터 __setup_end 영역
    • obs_kernel_param 구조체 엔트리들
  • 다음 조건에 해당되는 커널 파라미터를 발견하면 해당 커널 파라미터에 등록된 함수를 호출한다.
    • early 파라미터 호출
      • 요청한 파라미터가 등록된 커널 파라미터 문자열과 같으면서 early 설정이 된 경우
    • earlycon 호출
      • 요청한 파라미터가 “console”이고 등록된 커널 파라미터는 “earlycon”인 경우
  • cmdline 문자열 중 “console” 을 발견 시 콘솔 디바이스명으로 모든 earlycon으로 등록된 모든 초기화 함수를 수행
  • 예) rpi2: earlycon=xxx를 설정한 경우:
    • pl011_setup_earlycon(“xxx”) → setup_earlycon() → pl011_early_console_setup(“xxx”)
    • uart_setup_earlycon(“xxx”) → setup_earlycon() → early_serial8250_setup(“xxx”)
    • uart8250_setup_earlycon(“xxx”) → 상동
    • setup_of_earlycon(“xxx”) → early_init_dt_scan_chosen_serial()
      • 디바이스 트리에서 /chosen의 stdout-path를 찾아냄
  • 예) rpi2는 두 개의 드라이버를 console로 지정한다.
    • dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p6 rootfstype=ext4 elevator=deadline rootwait
      • ttyAMA는 ARM에서 제공하는 pl011 UART 드라이버이다.
      • tty는 리눅스 기본 tty 드라이버이다.
    • earlycon이 필요 시
      • “earlycon=pl011,0x3f201000,115200n8”
    • earlyprintk가 필요 시
      • “earlyprintk”
    • earlycon과 earlyprintk와 동시 사용 시
      • “earlycon=pl011,0x3f201000,115200n8 earlyprintk”

 

다음 그림은 매치되는 early 파라미터들의 셋업 함수를 호출한다.

  • 예) rpi2에 등록된 earlycon 관련 항목들
    • EARLYCON_DECLARE(pl011, pl011_early_console_setup);
      • 연결함수: pl011_setup_earlycon() -> setup_earlycon() -> pl011_early_console_setup()
    • EARLYCON_DECLARE(uart, early_serial8250_setup);
      • 연결함수: uart_setup_earlycon() -> setup_earlycon() -> early_serial8250_setup()
    • EARLYCON_DECLARE(uart8250, early_serial8250_setup);
      • 연결함수: uart8250_setup_earlycon() -> setup_earlycon() -> early_serial8250_setup()
    • early_param(“earlycon”, setup_of_earlycon);
      • 연결함수: setup_of_earlycon() -> early_init_dt_scan_chosen_serial() -> of_setup_earlycon() -> 예) pl011_early_console_setup()
  • 예) rpi2에 등록된 earlyprintk 관련 항목
    • early_param(“earlyprintk”, setup_early_printk);

 

parse_early_param()

init/main.c

/* Arch code calls this early on, or if not, just before other parsing. */
void __init parse_early_param(void)
{
        static int done __initdata;
        static char tmp_cmdline[COMMAND_LINE_SIZE] __initdata;

        if (done)
                return;

        /* All fall through to do_early_param. */
        strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
        parse_early_options(tmp_cmdline);
        done = 1; 
}

커멘트 라인 파라미터들 중 early 파라미터에 해당하는 설정 함수를 호출한다.

  • 코드 라인 11에서 전역 변수 boot_command_line의 내용을 tmp_cmdline에 복사한다.
    • boot_command_line
      • A) 부트로더가 다음 중 하나를 전달해 준다.
        • ATAG _CMDLINE 문자열 – ARM32 only
        • DTB의 “/chosen” 노드의 “bootargs” 속성 값
      • B) 커널에서도 준비한 문자열
        • 커널 옵션으로 입력한 커맨드라인 문자열 CONFIG_CMDLINE이 준비된다.
      • 위의 A) 및 B)를 아래 옵션에 따라 조합하여 사용한다.
        • 1) CONFIG_CMDLINE_EXTEND
          • A)와 B)를 합쳐서 사용한다.
        • 2) CONFIG_CLDLINE_FORCE
          • B)를 사용한다.
        • 3) no option (default)
          • A)를 사용한다.
  • 코드 라인 12에서 early 파라미터에 해당하는 설정 함수를 호출한다.

 

parse_early_options()

init/main.c

void __init parse_early_options(char *cmdline)
{
        parse_args("early options", cmdline, NULL, 0, 0, 0, NULL,
                   do_early_param);
}

do_early_param() 함수 주소를 인수로 parse_args() 함수를 호출한다.

  • 파라미터 블록, 개수, 범위가 지정되는 경우 그 파라미터 범위에 해당하는 토큰과 매치되는 경우 해당 파라미터에 값을 대입한다.
  • 그러나 파라미터 블록, 개수 및 범위가 0으로 전달되는 경우 각 토큰을 파싱하게 되면 param과 val 값을 가지고 항상 unknown handler인 do_early_param() 함수가 호출된다.

 

parse_args()

kernel/params.c

/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
char *parse_args(const char *doing,
                 char *args,
                 const struct kernel_param *params,
                 unsigned num,
                 s16 min_level,
                 s16 max_level,
                 void *arg,
                 int (*unknown)(char *param, char *val,
                                const char *doing, void *arg))
{
        char *param, *val, *err = NULL;

        /* Chew leading spaces */
        args = skip_spaces(args);

        if (*args)
                pr_debug("doing %s, parsing ARGS: '%s'\n", doing, args);

        while (*args) {
                int ret;
                int irq_was_disabled;

                args = next_arg(args, &param, &val);
                /* Stop at -- */
                if (!val && strcmp(param, "--") == 0)
                        return err ?: args;
                irq_was_disabled = irqs_disabled();
                ret = parse_one(param, val, doing, params, num,
                                min_level, max_level, arg, unknown);
                if (irq_was_disabled && !irqs_disabled())
                        pr_warn("%s: option '%s' enabled irq's!\n",
                                doing, param);

                switch (ret) {
                case 0:
                        continue;
                case -ENOENT:
                        pr_err("%s: Unknown parameter `%s'\n", doing, param);
                        break;
                case -ENOSPC:
                        pr_err("%s: `%s' too large for parameter `%s'\n",
                               doing, val ?: "", param);
                        break;
                default:
                        pr_err("%s: `%s' invalid for parameter `%s'\n",
                               doing, val ?: "", param);
                        break;
                }

                err = ERR_PTR(ret);
        }

        return err;
}

커멘드 라인 파라미터를 파싱한 토큰과 값으로 파라미터 블럭 @params에서 @min_level ~ @max_level 범위의 파라미터 테이블을 검색하여 일치하는 토큰이 있는 경우 해당 파라미터에 값을 대입한다. 만일 매치되는 조건이 없으면 @unknown 함수를 호출한다.

  • 코드 라인 15~18에서 args 인수에는 cmdline의 주소를 담고 있는데 space(0x20, 탭, 라인피드 등) 인 경우 skip 한다.
    • 예) ”  console=xxx” -> “console=xxx”
  • 코드 라인 20~24에서 parsing할 문자열이 남아 있는 동안 루프를 돌며 토큰을 “=” 문자로 분리하여 param과 val로 담는다.
    • (abc=1)
    • space 문자로 토큰과 토큰을 분리한다.
      • (aaa=1 bbb=2 ccc=3)
    • 쌍 따옴표(“)가 사용된 경우 중간에 space가 있어도 토큰을 분리하지 않는다.
      • (aaa=”1″ bbb=”2 2″ ccc=”3″)
        • param=(aaa), val=(1)
        • param=(bbb), val=(2 2)
        • param=(ccc), val=(3)
  • 코드 라인 26~27에서 val 값이 없으면서 param 값이 “–” 인 경우 더 이상 파싱을 하지 않고 함수를 종료한다.
  • 코드 라인 28에서 SCTLR의 인터럽트 마스크(“I”, 1번 비트)가 disable된 상태인지 알아온다.
    • true = irq disabled status, false = irq enabled status
  • 코드 라인 29~30에서 파싱된 토큰의 param과 val 그리고 doing(“early options”메시지 출력용) 및 do_early_param() 함수 포인터를 인자로 parse_one()을 호출한다.
    • 파라미터 블록, 개수, 범위가 지정되는 경우 그 파라미터 범위에 해당하는 토큰과 매치되는 경우 해당 파라미터에 값을 대입한다
    • 그러나 파라미터 블록, 개수 및 범위가 0으로 전달되는 경우 각 토큰을 파싱하게 되면 param과 val 값을 가지고 항상 unknown handler인 do_early_param() 함수가 호출된다.
  • 코드 라인 31~33에서 irq 설정 상태가 바뀌었으면 어떤 파라미터 옵션에서 바뀌었는지 warning을 출력한다.
    • 파라미터로 인해 특정 코드(디바이스 드라이버 등)에서 irq를 enable하고 나오는지를 확인하기 위해 경고 출력을 위한 디버그 코드이다.
    • 커널이 초기 설정 중에는 인터럽트가 마스크되어 동작하지 않고 있는데 갑자기 커널 파라미터로 인해 인터럽트가 발생되면 안되기 때문에 이를 확인하기 위함이다.
  • 코드 라인 35~49에서 파싱한 결과가 에러인 경우 에러 메시지를 출력하고 리턴한다. 성공인 경우  다음 토큰을 위해 루프를 계속 진행한다.

 

do_early_param()

init/main.c

/* Check for early params. */
static int __init do_early_param(char *param, char *val, const char *unused)
{                
        const struct obs_kernel_param *p;

        for (p = __setup_start; p < __setup_end; p++) {
                if ((p->early && parameq(param, p->str)) ||
                    (strcmp(param, "console") == 0 &&
                     strcmp(p->str, "earlycon") == 0)
                ) {
                        if (p->setup_func(val) != 0)
                                pr_warn("Malformed early option '%s'\n", param);
                }
        }
        /* We accept everything at this stage. */
        return 0;
}

다음 조건에 해당되는 early 커널 파라미터를 발견하면 @val 값 인수를 가지고 해당 커널 파라미터에 등록된 함수를 호출한다.

  • 요청한 커멘드 라인 파라미터가 early 커널 셋업 파라미터와 매치된 경우
    • 예) “earlyprintk”
  • 요청한 커멘드 라인 파라미터가 “console”로 시작한 경우
    • 예) “console=pl011”
  • early_param(“earlycon”)으로 등록한 셋업 함수
    • 현재 param_setup_earlycon() 함수 하나만 사용되고 있다.

 

  • 코드 라인 6에서 __setup_start 주소 영역 부터 __setup_end 주소 영역까지에 여러 개의 커널 파라미터인 obs_kernel_param 구조체가 있는데 순서대로 검색하여 p를 대입한다.
  • 코드 라인 7~10에서 p->early 항목이 설정되어 있으면서 p->str이 인수로 받은 param 문자열과 같은 경우이거나 p->str이 “earlycon”이면서 인수로 받은 param 문자열이 “console”인 경우
  • 코드 라인 11~12에서 p->setup_func()을 호출하여 에러가 있는 경우 경고 메시지를 출력한다.

 


디바이스 트리를 통한 파라미터 지정

디바이스 트리를 통해 파라미터 및 earlycon을 지정할 수 있다.

 

다음과 같이 DTB의 chosen 노드에 stdout-path를 지정하여 earlycon에 사용할 수 있고, bootargs를 통해 커멘드 라인 파라미터를 지정할 수 있다.

        chosen {
                bootargs = "console=ttyS0,115200n8 earlyprintk";
                stdout-path = "serial0:115200n8";
        };

 

디바이스 트리를 통한 earlycon 지정

커멘드 라인 파라메터에서 “earlycon” 또는 “console”이 지정될 때 디바이스 트리의 chosen 노드에서 “stdout-path”를 early 콘솔 디바이스로 지정한다. “console” 뒤에 디바이스가 지정되면 안된다.

early_init_dt_scan_chosen_stdout()

drivers/of/fdt.c

int __init early_init_dt_scan_chosen_stdout(void)
{
        int offset;
        const char *p, *q, *options = NULL;
        int l;
        const struct earlycon_id **p_match;
        const void *fdt = initial_boot_params;

        offset = fdt_path_offset(fdt, "/chosen");
        if (offset < 0)
                offset = fdt_path_offset(fdt, "/chosen@0");
        if (offset < 0)
                return -ENOENT;

        p = fdt_getprop(fdt, offset, "stdout-path", &l);
        if (!p)
                p = fdt_getprop(fdt, offset, "linux,stdout-path", &l);
        if (!p || !l)
                return -ENOENT;

        q = strchrnul(p, ':');
        if (*q != '\0')
                options = q + 1;
        l = q - p;

        /* Get the node specified by stdout-path */
        offset = fdt_path_offset_namelen(fdt, p, l);
        if (offset < 0) {
                pr_warn("earlycon: stdout-path %.*s not found\n", l, p);
                return 0;
        }

        for (p_match = __earlycon_table; p_match < __earlycon_table_end;
             p_match++) {
                const struct earlycon_id *match = *p_match;

                if (!match->compatible[0])
                        continue;

                if (fdt_node_check_compatible(fdt, offset, match->compatible))
                        continue;

                of_setup_earlycon(match, offset, options);
                return 0;
        }
        return -ENODEV;
}

이 함수는 CONFIG_SERIAL_EARLYCON이 설정되어 있는 경우 DTB에서 /chosen 노드의 stdout-path 속성에 지정된 compatible(디바이스명)을 알아와서 earlycon 테이블에 등록한 모든 earlycon 디바이스의 이름과 같은 디바이스의 설정 함수를 호출한다.

  • 코드 라인 9~13에서 “/chosen” 또는 “/chosen@0” 노드를 검색한다.
  • 코드 라인 15~19에서 발견한 노드에서 “stdout-path” 또는 “linux,stdout-path” 속성을 검색한다.
  • 코드 라인 21~31에서 발견한 속성에서 디바이스명과 옵션을 분리한다.
    • 예) “serial0:115200n8” 에서 offset은 “serial0″를 의미하고, options는 “115200n8″을 의미한다.
  • 코드 라인33~38에서 __earlycon_of_table 주소 부터 compatible[0]이 있는 동안 검색한다.
  • 코드 라인40~41에서 compatible 속성 값에서 디바이스명(match->compatible)이 매치되지 않으면 skip 한다.
    • fdt_node_check_compatible()
      • compatible 속성 값에서 문자열 비교: 0=match, 1=non match, 길이=”compatible” 속성이 발견되지 않는 경우
  • 코드 라인 43에서 early console 디바이스를 셋업한다.
    • match->data에는 디바이스의 setup 함수 주소가 담겨있다.
      • rpi2 예) match->data = pl011_early_console_setup()

 

예) DTB용 콘솔 디바이스 드라이버 소스 – earlycon_of_table 섹션에 저장된다.

  • OF_EARLYCON_DECLARE(pl011, “arm,pl011”, pl011_early_console_setup);

 

of_setup_earlycon()

drivers/tty/serial/earlycon.c

int __init of_setup_earlycon(const struct earlycon_id *match,
                             unsigned long node,
                             const char *options)
{
        int err;
        struct uart_port *port = &early_console_dev.port;
        const __be32 *val;
        bool big_endian;
        u64 addr;

        spin_lock_init(&port->lock);
        port->iotype = UPIO_MEM;
        addr = of_flat_dt_translate_address(node);
        if (addr == OF_BAD_ADDR) {
                pr_warn("[%s] bad address\n", match->name);
                return -ENXIO;
        }
        port->mapbase = addr;

        val = of_get_flat_dt_prop(node, "reg-offset", NULL);
        if (val)
                port->mapbase += be32_to_cpu(*val);
        port->membase = earlycon_map(port->mapbase, SZ_4K);

        val = of_get_flat_dt_prop(node, "reg-shift", NULL);
        if (val)
                port->regshift = be32_to_cpu(*val);
        big_endian = of_get_flat_dt_prop(node, "big-endian", NULL) != NULL ||
                (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) &&
                 of_get_flat_dt_prop(node, "native-endian", NULL) != NULL);
        val = of_get_flat_dt_prop(node, "reg-io-width", NULL);
        if (val) {
                switch (be32_to_cpu(*val)) {
                case 1:
                        port->iotype = UPIO_MEM;
                        break;
                case 2:
                        port->iotype = UPIO_MEM16;
                        break;
                case 4:
                        port->iotype = (big_endian) ? UPIO_MEM32BE : UPIO_MEM32;
                        break;
                default:
                        pr_warn("[%s] unsupported reg-io-width\n", match->name);
                        return -EINVAL;
                }
        }

        val = of_get_flat_dt_prop(node, "current-speed", NULL);
        if (val)
                early_console_dev.baud = be32_to_cpu(*val);

        val = of_get_flat_dt_prop(node, "clock-frequency", NULL);
        if (val)
                port->uartclk = be32_to_cpu(*val);

        if (options) {
                early_console_dev.baud = simple_strtoul(options, NULL, 0);
                strlcpy(early_console_dev.options, options,
                        sizeof(early_console_dev.options));
        }
        earlycon_init(&early_console_dev, match->name);
        err = match->setup(&early_console_dev, options);
        if (err < 0)
                return err;
        if (!early_console_dev.con->write)
                return -ENODEV;

        register_console(early_console_dev.con);
        return 0;
}

디바이스 트리를 통해 early 콘솔 디바이스 속성 값들을 읽어온 후 디바이스의 설정 함수를 호출한 후 콘솔 디바이스로 등록한다.

  • 코드 라인 12~18에서 레지스터 주소를 알아온다.
    • UPIO_MEM
      • 유저 스페이스 노출가능한 mmio(주소 지정된 io)로 처리 bit 및 endian이 지정되지 않은 driver-specific mmio이다.
      • 참고로 8250은 8bit 리틀 엔디안 이고 pl011은 16bit 리틀 엔디안이다.
  • 코드 라인 20~22에서 “reg-offset” 속성이 있는 경우 해당 값 만큼 offset을 주소에 더한다.
  • 코드 라인 23에서 early 콘솔 디바이스를 4K 페이지만큼 매핑한다.
  • 코드 라인 25~27에서 “reg-shift” 속성이 있는 경우 regshift 값에 대입해둔다.
  • 코드 라인 28~30에서 빅 엔디안 요청이 있는지 여부를 확인한다. 다음 2가지 경우로 판단한다.
    • “big-endian” 속성이 있는 경우
    • cpu가 big-endian으로 동작하면서 “native-endian” 속성이 있는 경우
  • 코드 라인 31~47에서 콘솔 버스 크기를 알아와서 크기에 따라 다음과 같이 포트 타입을 지정한다.
    • 1 바이트 크기인 경우 포트 타입을 UPIO_MEM으로 한다.
    • 2 바이트 크기인 경우 포트 타입을 UPIO_MEM16으로 한다.
    • 4 바이트 크기인 경우 포트 타입을 UPIO_MEM32BE 또는 UPIO_MEM32로 한다.
  • 코드 라인 49~51에서 “current-speed” 값을 읽어 시리얼 속도를 지정한다.
  • 코드 라인 53~55에서 “clock-frequency” 값을 읽어 클럭 값을 지정한다.
  • 코드 라인 57~61에서 콘솔 디바이스에 옵션(콘솔명 + ‘:’ + 옵션)이 지정된 경우 시리얼 속도를 지정하고, 옵션도 지정해둔다.
  • 코드 라인 62에서 early 콘솔 디바이스의 이름과 데이터를 지정한 후, 설정 정보를 출력한다.
    • 예) earlycon: pl11 at MMIO 0x0000000009000000 (options ”)
  • 코드 라인 63~65에서 매치된 디바이스의 설정 함수를 호출한다.
  • 코드 라인 66~67에서 early 콘솔 드라이버에 출력 후크 함수가 구현되지 않은 경우 -ENODEV 에러를 반환한다.
  • 코드 라인 69에서 콘솔 디바이스로 등록한다.

 

참고

 

setup_machine_tags()

arch 번호로 태그테이블에서 machine을 검색하여 machine_desc 구조체 포인터를 찾고 ATAG를 디바이스 트리 구조로 변경한다.

setup_machine_tags

 

setup_machine_tags()

  • for_each_machine_desc()
    • __arch_info_begin ~ __arch_info_end 영역에 위치한 machine_desc 구조체 배열에서 머신 번호가 같은 경우를 찾는다.
    • machine_desc 구조체 배열은 .arch.info.init 섹션에 위치한다.
  • 만일 machine을 검색하여 찾지 못한 경우 machine table을 덤프하고 정지한다.
  • CONFIG_DEPRECATED_PARAM_STRUCT
    • ATAG 사용 하기 전에는 PARAM_STRUCT를 사용했다.
    •  convert_to_tag_list()
      • 태그의 처음이 ATAG_CORE가 아니면 PARAM_STRUCT 방식이라고 판단하여 ATAG 구조로 변환한다.
  • 처음 태그가 ATAG_CORE가 아닌 경우 “Warning: Neither atags nor dtb found” 경고 메시지를  출력하고 default 태그 구조체를 사용한다.
  • fixup 콜백함수가 null이 아닌 경우 fixup 콜백 함수를 수행한다.
    • 펌웨어에 문제가 있는 경우를 패치하기 위한 함수가 존재하는 경우 호출
    • 예) mach-msm/board-msm7x30.c – msm7x30_fixup() 참고
  • 태그가 ATAG_CORE 인 경우
    • 물리 메모리 사이즈가 이미 존재하는 경우 태그 정보를 무시하기 위해 squash_mem_tags()를 호출하여 ATAG_MEM을 ATAG_NONE으로 변경한다.
      • memblock_phys_mem_size = memblock.memory.total_size
    • save_atags()
      • 전역 변수 atags_copy 문자열 배열에 태그를 저장
    • parse_tags()
      • __tagtable_begin 부터 __tagtable_end 위치에 존재하는 태그 테이블에서 하나 씩 비교하여 동일한 태그인 경우 해당 태그의 parse 루틴을 호출한 후 리턴한다.
        • 태그 테이블은 .taglist.init 섹션에 위치한다.
      • parsing이 실패하면 “Ignoring unrecognised tag”라고 경고 출력한다.
      • 각 태그에 대한 파싱 함수 목록
        • ATAG_CORE: parse_tag_core()
        • ATAG_MEM: parse_tag_mem32()
        • ATAG_CMDLINE: parse_tag_cmdline
        • ATAG_INITRD: parse_tag_initrd()
        • ATAG_INITRD2, parse_tag_initrd2()
        • ATAG_VIDEOTEXT: parse_tag_videotext()
        • ATAG_RAMDIST: parse_tag_ramdisk()
        • ATAG_SERAIL: parse_tag_serialnr()
        • ATAG_REVISION: parse_tag_revision()
  • 마지막으로 전역 변수 boot_command_line에 default_cmd_line 값을 대입한다.
    • default_cmd_line은 컴파일 시 초기 설정된 값이 있고 커널 파라메터 설정에 따라 parse_tag_cmdline()을 수행하고 난 후 변경될 수 있다.
const struct machine_desc * __init
setup_machine_tags(phys_addr_t __atags_pointer, unsigned int machine_nr)
{
        struct tag *tags = (struct tag *)&default_tags;
        const struct machine_desc *mdesc = NULL, *p;
        char *from = default_command_line;

        default_tags.mem.start = PHYS_OFFSET;

        /*
         * locate machine in the list of supported machines.
         */
        for_each_machine_desc(p)
                if (machine_nr == p->nr) {
                        pr_info("Machine: %s\n", p->name);
                        mdesc = p;
                        break;
                }

        if (!mdesc) {
                early_print("\nError: unrecognized/unsupported machine ID"
                            " (r1 = 0x%08x).\n\n", machine_nr);
                dump_machine_table(); /* does not return */
        }

        if (__atags_pointer)
                tags = phys_to_virt(__atags_pointer);
        else if (mdesc->atag_offset)
                tags = (void *)(PAGE_OFFSET + mdesc->atag_offset);

#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
        /*
         * If we have the old style parameters, convert them to
         * a tag list.
         */
        if (tags->hdr.tag != ATAG_CORE)
                convert_to_tag_list(tags);
#endif
        if (tags->hdr.tag != ATAG_CORE) {
                early_print("Warning: Neither atags nor dtb found\n");
                tags = (struct tag *)&default_tags;
        }

        if (mdesc->fixup)
                mdesc->fixup(tags, &from);

        if (tags->hdr.tag == ATAG_CORE) {
                if (memblock_phys_mem_size())
                        squash_mem_tags(tags);
                save_atags(tags);
                parse_tags(tags);
        }

        /* parse_early_param needs a boot_command_line */
        strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);

        return mdesc;
}

 

ATAG용 Machine 정보

MACHINE_START()

  • ATAG용 machine_desc 구조체 선언 매크로
    • ATAG용에서는 nr로 검색하므로 nr 값이 중요하다.
      • arm용 머신 번호는 arch/arm/tools/mach-types 화일을 참고한다.
    • DTB용은 DT_MACHINE_START() 매크로를 사용하고 name으로 검색한다.
  • __used를 사용하여 이 객체가 참조되지 않아도 컴파일러가 제거하지 않도록 한다.
  • MACHINE_END()와 쌍으로 사용한다.

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

 

machine_desc 구조체

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

struct machine_desc {
        unsigned int            nr;             /* architecture number  */
        const char              *name;          /* architecture name    */
        unsigned long           atag_offset;    /* tagged list (relative) */
        const char *const       *dt_compat;     /* array of device tree
                                                 * 'compatible' strings */

        unsigned int            nr_irqs;        /* number of IRQs */

#ifdef CONFIG_ZONE_DMA
        phys_addr_t             dma_zone_size;  /* size of DMA-able area */
#endif

        unsigned int            video_start;    /* start of video RAM   */
        unsigned int            video_end;      /* end of video RAM     */

        unsigned char           reserve_lp0 :1; /* never has lp0        */
        unsigned char           reserve_lp1 :1; /* never has lp1        */
        unsigned char           reserve_lp2 :1; /* never has lp2        */
        enum reboot_mode        reboot_mode;    /* default restart mode */
        unsigned                l2c_aux_val;    /* L2 cache aux value   */
        unsigned                l2c_aux_mask;   /* L2 cache aux mask    */
        void                    (*l2c_write_sec)(unsigned long, unsigned);
        struct smp_operations   *smp;           /* SMP operations       */
        bool                    (*smp_init)(void);
        void                    (*fixup)(struct tag *, char **);
        void                    (*dt_fixup)(void);
        void                    (*init_meminfo)(void);
        void                    (*reserve)(void);/* reserve mem blocks  */
        void                    (*map_io)(void);/* IO mapping function  */
        void                    (*init_early)(void);
        void                    (*init_irq)(void);
        void                    (*init_time)(void);
        void                    (*init_machine)(void);
        void                    (*init_late)(void);
#ifdef CONFIG_MULTI_IRQ_HANDLER
        void                    (*handle_irq)(struct pt_regs *);
#endif
        void                    (*restart)(enum reboot_mode, const char *);
};

 

라즈베리파이 1 & 2 MACHINE 구조체 선언

arch/arm/mach-bcm2709/bcm2709.c

static const char * const bcm2709_compat[] = {
        "brcm,bcm2709",
        "brcm,bcm2708", /* Could use bcm2708 in a pinch */
        NULL
};

MACHINE_START(BCM2709, "BCM2709")
    /* Maintainer: Broadcom Europe Ltd. */
#ifdef CONFIG_SMP
        .smp            = smp_ops(bcm2709_smp_ops),
#endif
        .map_io = bcm2709_map_io,
        .init_irq = bcm2709_init_irq,
        .init_time = bcm2709_timer_init,
        .init_machine = bcm2709_init,
        .init_early = bcm2709_init_early,
        .reserve = board_reserve,
        .restart        = bcm2709_restart,
        .dt_compat = bcm2709_compat,
MACHINE_END

MACHINE_START(BCM2708, "BCM2709")
    /* Maintainer: Broadcom Europe Ltd. */
#ifdef CONFIG_SMP
        .smp            = smp_ops(bcm2709_smp_ops),
#endif
        .map_io = bcm2709_map_io,
        .init_irq = bcm2709_init_irq,
        .init_time = bcm2709_timer_init,
        .init_machine = bcm2709_init,
        .init_early = bcm2709_init_early,
        .reserve = board_reserve,
        .restart        = bcm2709_restart,
        .dt_compat = bcm2709_compat,
MACHINE_END

 

ATAG Parsing

tag 및 tagtable 구조체

arch/arm/include/uapi/asm/setup.h

struct tag {
        struct tag_header hdr;
        union {
                struct tag_core         core;
                struct tag_mem32        mem;
                struct tag_videotext    videotext;
                struct tag_ramdisk      ramdisk;
                struct tag_initrd       initrd;
                struct tag_serialnr     serialnr;
                struct tag_revision     revision;
                struct tag_videolfb     videolfb;
                struct tag_cmdline      cmdline;

                /*
                 * Acorn specific
                 */
                struct tag_acorn        acorn;

                /*
                 * DC21285 specific
                 */
                struct tag_memclk       memclk;
        } u;
};

struct tagtable {
        __u32 tag;
        int (*parse)(const struct tag *);
};

 

 

parse_tag()

  •  태그 영역에 저장된 태그들 중 아키텍처 번호가 같은 태그들에 연결된 parse 콜백 함수를  호출한다.
/*
 * Scan the tag table for this tag, and call its parse function.
 * The tag table is built by the linker from all the __tagtable
 * declarations.
 */
static int __init parse_tag(const struct tag *tag)
{
        extern struct tagtable __tagtable_begin, __tagtable_end;
        struct tagtable *t;

        for (t = &__tagtable_begin; t < &__tagtable_end; t++)
                if (tag->hdr.tag == t->tag) {
                        t->parse(tag);
                        break;
                }

        return t < &__tagtable_end;
}

 

 

parse_tag_core()

  • 전역 변수 root_mountflags에 루트 마운트 플래그 속성에서 MS_RDONLY를 제거하고 저장
  • 전역 변수 ROOT_DEV에 디바이스 번호를 저장한다.

arch/arm/kernel/atags_parse.c

static int __init parse_tag_core(const struct tag *tag)
{
        if (tag->hdr.size > 2) {
                if ((tag->u.core.flags & 1) == 0)
                        root_mountflags &= ~MS_RDONLY;
                ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
        }
        return 0;
}

__tagtable(ATAG_CORE, parse_tag_core);

 

parse_tag_mem32()

  • arm_add_memory() 함수를 사용하여 메모리 영역을 추가한다.
static int __init parse_tag_mem32(const struct tag *tag)
{
        return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
}

__tagtable(ATAG_MEM, parse_tag_mem32);

 

parse_tag_videotext()

  • screen_info 구조체에 파라메터 값들을 저장한다.
#if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
static int __init parse_tag_videotext(const struct tag *tag)
{
        screen_info.orig_x            = tag->u.videotext.x;
        screen_info.orig_y            = tag->u.videotext.y;
        screen_info.orig_video_page   = tag->u.videotext.video_page;
        screen_info.orig_video_mode   = tag->u.videotext.video_mode;
        screen_info.orig_video_cols   = tag->u.videotext.video_cols;
        screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
        screen_info.orig_video_lines  = tag->u.videotext.video_lines;
        screen_info.orig_video_isVGA  = tag->u.videotext.video_isvga;
        screen_info.orig_video_points = tag->u.videotext.video_points;
        return 0;
}

__tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
#endif

 

parse_tag_ramdisk()

  • 전역 변수 rd_image_start에 램디스크 시작 주소를 저장한다.
  • 전역 변수 rd_doload와 rd_prompt에 플래그 상태를 저장한다.
  • 전역 변수 rd_size에 램디스크 사이즈를 저장한다.
#ifdef CONFIG_BLK_DEV_RAM
static int __init parse_tag_ramdisk(const struct tag *tag)
{
        extern int rd_size, rd_image_start, rd_prompt, rd_doload;

        rd_image_start = tag->u.ramdisk.start;
        rd_doload = (tag->u.ramdisk.flags & 1) == 0;
        rd_prompt = (tag->u.ramdisk.flags & 2) == 0;

        if (tag->u.ramdisk.size)
                rd_size = tag->u.ramdisk.size;

        return 0;
}

__tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
#endif

 

parse_tag_serialnr()

  • 전역 변수 system_serial_low와 system_serial_high에 시리얼 low 값과 high 값을 저장한다.
static int __init parse_tag_serialnr(const struct tag *tag)
{
        system_serial_low = tag->u.serialnr.low;
        system_serial_high = tag->u.serialnr.high;
        return 0;
}

__tagtable(ATAG_SERIAL, parse_tag_serialnr);

 

parse_tag_revision()

  •  전역 변수 system_rev에 리비전 정보를 저장한다.
static int __init parse_tag_revision(const struct tag *tag)
{
        system_rev = tag->u.revision.rev;
        return 0;
}

__tagtable(ATAG_REVISION, parse_tag_revision);

 

parse_tag_cmdline()

  • 다음 3가지 case에 대해 수행한다.
    • CONFIG_CMDLINE_EXTEND
      • default_command_line에 ATAG가 전달한 cmdline을 추가한다.
    • CONFIG_CMDLINE_FORCE
      • ATAG가 전달한 cmdline을 무시하고 default_command_line을 사용한다.
    • cmdline 관련 옵션이 없는 경우
      • default_command_line에 ATAG가 전달한 cmdline을 겹쳐 쓴다.
static int __init parse_tag_cmdline(const struct tag *tag)
{
#if defined(CONFIG_CMDLINE_EXTEND)
        strlcat(default_command_line, " ", COMMAND_LINE_SIZE);
        strlcat(default_command_line, tag->u.cmdline.cmdline,
                COMMAND_LINE_SIZE);
#elif defined(CONFIG_CMDLINE_FORCE)
        pr_warn("Ignoring tag cmdline (using the default kernel command line)\n");
#else
        strlcpy(default_command_line, tag->u.cmdline.cmdline,
                COMMAND_LINE_SIZE);
#endif
        return 0;
}

__tagtable(ATAG_CMDLINE, parse_tag_cmdline);

 

기타 함수

arm_add_memory()

arch/arm/kernel/setup.c

int __init arm_add_memory(u64 start, u64 size)
{
        u64 aligned_start;

        /*   
         * Ensure that start/size are aligned to a page boundary.
         * Size is rounded down, start is rounded up.
         */
        aligned_start = PAGE_ALIGN(start);
        if (aligned_start > start + size)
                size = 0; 
        else 
                size -= aligned_start - start;

#ifndef CONFIG_ARCH_PHYS_ADDR_T_64BIT
        if (aligned_start > ULONG_MAX) {
                pr_crit("Ignoring memory at 0x%08llx outside 32-bit physical address space\n",
                        (long long)start);
                return -EINVAL;
        }

        if (aligned_start + size > ULONG_MAX) {
                pr_crit("Truncating memory at 0x%08llx to fit in 32-bit physical address space\n",
                        (long long)start);
                /*   
                 * To ensure bank->start + bank->size is representable in
                 * 32 bits, we use ULONG_MAX as the upper limit rather than 4GB.
                 * This means we lose a page after masking.
                 */
                size = ULONG_MAX - aligned_start;
        }    
#endif

        if (aligned_start < PHYS_OFFSET) {
                if (aligned_start + size <= PHYS_OFFSET) {
                        pr_info("Ignoring memory below PHYS_OFFSET: 0x%08llx-0x%08llx\n",
                                aligned_start, aligned_start + size);
                        return -EINVAL;
                }

                pr_info("Ignoring memory below PHYS_OFFSET: 0x%08llx-0x%08llx\n",
                        aligned_start, (u64)PHYS_OFFSET);

                size -= PHYS_OFFSET - aligned_start;
                aligned_start = PHYS_OFFSET;
        }

        start = aligned_start;
        size = size & ~(phys_addr_t)(PAGE_SIZE - 1);

        /*   
         * Check whether this memory region has non-zero size or
         * invalid node number.
         */
        if (size == 0)
                return -EINVAL;

        memblock_add(start, size);
        return 0;
}
  • aligned_start = PAGE_ALIGN(start);
    • start 주소에 대해 4K round up 한다.
  • if (aligned_start > start + size)
    • 4K round up 한 aligned_start 주소가 start + size를 초과하는 경우 size를 0으로 변경하고 그렇지 않은 경우 4K round up으로 인해 발생한 그 차이만큼 size에서 뺀다.
    • 결국 4K align 되어 남는 하위 메모리는 버리게 된다.
    • 예) arm_add_memory(0x1234_5678, 0x1000_0000)
      • 물리 메모리 주소 0x1234_5678 부터 256M 크기의 메모리를 추가하라는 요청
      • 수행 후 물리 메모리 주소 0x1234_5000 부터 (256M – 0x678) 크기의 메모리를 추가
  • CONFIG_ARCH_PHYS_ADDR_T_64BIT
    • LPAE 설정 시 사용된다.
  • if (aligned_start + size > ULONG_MAX) {
    • 추가할 메모리 영역이 32비트 주소의 끝을 초과하는 경우 size를 32비트 이내에 들어갈 수 있도록 조정한다.
    • 예) arm_add_memory(0xf000_0000, 0x2000_0000)
      • 물리 메모리 주소 0xf000_0000 부터 512M 크기의 메모리를 추가하라는 요청
      • 수행 후 물리 메모리 주소 0xf000_0000 부터 0x0fff_ffff 크기의 메모리를 추가
  • if (aligned_start < PHYS_OFFSET) {
    • 요청한 시작 주소가 물리 메모리 시작 주소보다 작은 경우
  • if (aligned_start + size <= PHYS_OFFSET) {
    • size 까지 합친 요청 영역이 물리 메모리 시작 주소보다 작아 범위를 아예 벗어난 경우 에러를 경고하고 함수를 리턴한다.
    • 요청한 구간이 물리 메모리 이하에서 시작하였다는 것을 경고 출력하고 물리 메모리 시작 주소 이하의 요청 메모리를 제거한 범위를 시작 주소와 사이즈를 재 조정한다.
    • 예) arm_add_memory(0x1F00_0000, 0x1000_0000) 이 때 PHYS_OFFSET=0x2000_0000
      • aligned_start = 0x2000_0000
      • size = 0x0f00_000
  • size = size & ~(phys_addr_t)(PAGE_SIZE – 1);
    • 사이즈 또한 align 되어 있지 않으면 round down 하여 버린다.
    • 예) arm_add_memory(0x2000_0000, 0x1234_5678)
      • size = 0x1234_5000
  •  if (size == 0)
    • 추가 할 사이즈가 0이면 함수를 빠져나간다.
  • memblock_add(start, size);
    • memory memblock 에 메모리 영역을 추가한다.

 

참고