<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) 영역에도 추가한다.
- 다음 2가지 설정에 의해 영역 크기가 할당될 수 있다.
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에 추가한다.
- 다음 3가지 영역을 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
- 디바이스 드라이버(dma for coherent/cma for dma)가 필요로 하는 DMA 영역을 reserve memblock에 추가하고 CMA(Contiguous Memory Allocator)에도 추가한다.
- memblock_dump_all();
- 커널 cmdline에 “debug” 옵션을 사용하는 경우 memory & reserve memblock 영역을 dump 한다.
아래 그림과 같은 순서로 몇 가지 영역을 reserved memblock에 추가한다.
- 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[] 배열에만 추가한다.
- 알아온 영역을 다음 2가지 경우에 따라 처리한다.
- 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[] 배열에만 추가한다.
- 첫 번째 depth의 “reserved-memory” 노드명을 찾아 “status” 속성값이 “ok” 또는 “okay”인 경우 알아온 영역을 다음 2가지 경우에 따라 처리한다.
- 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영역에서 해지
- “no-map” 속성이 찾아지면 true
- 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 속성을 읽어온다.
- rmem->size가 0인 경우는 base 주소가 dynamic하게 지정될 수 있게 __reserved_mem_alloc_size() 함수를 호출하여 reserve memblock에 영역을 추가한다.
- __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;
참고
- Memblock – (1) | 문c
- Memblock – (2) | 문c
- arm_memblock_init() | 문c – 현재 글
- arm64_memblock_init() | 문c