arm_memblock_init()

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;

 

참고

답글 남기기

이메일은 공개되지 않습니다. 필수 입력창은 * 로 표시되어 있습니다.