작성자: 문영일

디바이스 드라이버가 사용하는 DMA 영역을 CMA(Contiguous Memory Allocator)에 등록하고 reserve memblock 추가한 후 해당 영역의 메모리 할당관리를 수행한다.

 

dma_contiguous_reserve()

drivers/base/dma-contiguous.c

/**
 * dma_contiguous_reserve() - reserve area(s) for contiguous memory handling
 * @limit: End address of the reserved memory (optional, 0 for any).
 *
 * This function reserves memory from early allocator. It should be
 * called by arch specific code once the early allocator (memblock or bootmem)
 * has been activated and all other subsystems have already allocated/reserved
 * memory.          
 */
void __init dma_contiguous_reserve(phys_addr_t limit)
{
        phys_addr_t selected_size = 0;
        phys_addr_t selected_base = 0;
        phys_addr_t selected_limit = limit;
        bool fixed = false;

        pr_debug("%s(limit %08lx)\n", __func__, (unsigned long)limit);

        if (size_cmdline != -1) {
                selected_size = size_cmdline;
                selected_base = base_cmdline;
                selected_limit = min_not_zero(limit_cmdline, limit);
                if (base_cmdline + size_cmdline == limit_cmdline)
                        fixed = true;
        } else {
#ifdef CONFIG_CMA_SIZE_SEL_MBYTES
                selected_size = size_bytes;
#elif defined(CONFIG_CMA_SIZE_SEL_PERCENTAGE)
                selected_size = cma_early_percent_memory();
#elif defined(CONFIG_CMA_SIZE_SEL_MIN)
                selected_size = min(size_bytes, cma_early_percent_memory());
#elif defined(CONFIG_CMA_SIZE_SEL_MAX)
                selected_size = max(size_bytes, cma_early_percent_memory());
#endif
        }

        if (selected_size && !dma_contiguous_default_area) {
                pr_debug("%s: reserving %ld MiB for global area\n", __func__,
                         (unsigned long)selected_size / SZ_1M);

                dma_contiguous_reserve_area(selected_size, selected_base,
                                            selected_limit,
                                            &dma_contiguous_default_area,
                                            fixed);
        }
}

커널 파라메터 또는 커널 옵션으로 요청한 메모리 사이즈만큼의 영역을 CMA(Contigugou Memory Allocator)에 관리 항목으로 추가하되 한 번만 요청을 받는다.

• 커널 파라메터에 “cma=”가 설정되어 early_cma() 루틴이 호출되는 경우 size_cmdline, base_cmdline, limit_cmdline 등을 알아온다.
  • 요청 영역이 limit와 동일한 경우 fixed는 true로 설정하여 정확히 base(시작주소)에 할당 할 수 있도록 요청한다.
  • fixed가 false인 경우 base 부터 limit 사이즈 크기로 요청한다.
• if (size_cmdline != -1) {
  • size_cmdline 정보를 알아온 경우 파싱된 전역변수 값들을 사용한다.
• CONFIG_CMA_SIZE_SEL_MBYTES
  • size_cmdline 정보를 알아오지 못한 경우에 커널 옵션으로 설정한 값을 사용한다.
  • size_bytes = CMA_SIZE_MBYTES * SZ_1M
    • CMA_SIZE_MBYTES = CONFIG_CMA_SIZE_MBYTES
• if (selected_size && !dma_contiguous_default_area) {
  • 사이즈가 0보다 크면서 cma 관리 영역을 처음 설정되는 경우(null)
• dma_contiguous_reserve_area(selected_size, selected_base, selected_limit, &dma_contiguous_default_area, fixed);
  • cma를 구성할 메모리 시작 주소, 사이즈, limit 및 fixed 값으로 cma에 관리 항목을 추가하고 추후 리매핑을 하기 위해 리매핑 정보도 구성한다.
  • cma 관리 항목에 추가하고 reserve memblock에도 추가된다.

 

dma_contiguous_reserve_area()

drivers/base/dma-contiguous.c

/**
 * dma_contiguous_reserve_area() - reserve custom contiguous area
 * @size: Size of the reserved area (in bytes),
 * @base: Base address of the reserved area optional, use 0 for any
 * @limit: End address of the reserved memory (optional, 0 for any).
 * @res_cma: Pointer to store the created cma region.
 * @fixed: hint about where to place the reserved area
 *
 * This function reserves memory from early allocator. It should be
 * called by arch specific code once the early allocator (memblock or bootmem)
 * has been activated and all other subsystems have already allocated/reserved
 * memory. This function allows to create custom reserved areas for specific
 * devices.
 *
 * If @fixed is true, reserve contiguous area at exactly @base.  If false,
 * reserve in range from @base to @limit.
 */
int __init dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base,
                                       phys_addr_t limit, struct cma **res_cma,
                                       bool fixed)
{
        int ret;

        ret = cma_declare_contiguous(base, size, limit, 0, 0, fixed, res_cma);
        if (ret)
                return ret;

        /* Architecture specific contiguous memory fixup. */
        dma_contiguous_early_fixup(cma_get_base(*res_cma),
                                cma_get_size(*res_cma));

        return 0;
}

• ret = cma_declare_contiguous(base, size, limit, 0, 0, fixed, res_cma);
  • cma_areas[]에 관리 항목을 추가하고 관리할 메모리 크기 정보인 base, size, limit, alignment 및 order_per_bit를 사용하여 base_pfn, count, bitmap 할당, alignment 및 order_per_bit 를 설정한다.
    • cma 에서 사용하는 비트맵은 각 비트가 1개 페이지를 표현하도록 하게 한다.
    • 영역의 alignment 단위는 1 페이지로 한다.
    • 해당 영역은 reserve memblock에도 등록된다.
  • 실패하는 경우 에러를 리턴한다.
  • 추가한 엔트리들은 CMA 드라이버가 로드될 때 호출되어 초기화한다.
• dma_contiguous_early_fixup(cma_get_base(*res_cma), cma_get_size(*res_cma));
  • cma에서 관리할 메모리 영역을 dma_mmu_remap[] 배열에 추가한다.
  • 이렇게 배열에 정보만 단순히 추가한 후 나중에 setup_arch() -> paging_init() -> dma_contiguous_remap() 순서대로 함수를 호출하여 리매핑을 하게 한다.

 

dma_contiguous_early_fixup()

arch/arm/mm/dma-mapping.c

void __init dma_contiguous_early_fixup(phys_addr_t base, unsigned long size)
{
        dma_mmu_remap[dma_mmu_remap_num].base = base;
        dma_mmu_remap[dma_mmu_remap_num].size = size;
        dma_mmu_remap_num++;
}

• dma_mmu_remap[] 배열에 추가한다.

 

CMA 메모리 early 설정 루틴

early_cma()

“cma= ” 커널 파라메터에 의해 호출되어 사용된다.

drivers/base/dma-contiguous.c

/*
 * Default global CMA area size can be defined in kernel's .config.
 * This is useful mainly for distro maintainers to create a kernel
 * that works correctly for most supported systems.
 * The size can be set in bytes or as a percentage of the total memory
 * in the system.
 *
 * Users, who want to set the size of global CMA area for their system
 * should use cma= kernel parameter.
 */
static const phys_addr_t size_bytes = CMA_SIZE_MBYTES * SZ_1M;
static phys_addr_t size_cmdline = -1;
static phys_addr_t base_cmdline;
static phys_addr_t limit_cmdline;

static int __init early_cma(char *p)
{
        pr_debug("%s(%s)\n", __func__, p);
        size_cmdline = memparse(p, &p);
        if (*p != '@')
                return 0;
        base_cmdline = memparse(p + 1, &p);
        if (*p != '-') {
                limit_cmdline = base_cmdline + size_cmdline;
                return 0;
        }
        limit_cmdline = memparse(p + 1, &p);

        return 0;
}
early_param("cma", early_cma);

다음과 같이 사용예를 알아본다.

• cma=4M
  • 0x0000_0000 ~ arm_dma_limit(DMA 사이즈) 영역내에서 4M의 CMA용 공간을 할당한다.
• cma=4M@0x00c00000
  • 0x00c0_0000 ~ arm_dma_limit(DMA 사이즈) 영역내에서 4M의 CMA용 공간을 할당한다.
• cma=4M@0x10000000-0x40000000
  • 0x1000_0000 ~ 0x4000_0000 영역내에서 4M의 CMA용 공간을 할당한다.
• cma=4M@0x10000000-0x10400000
  • 정확히 0x1000_0000 위치에서 4M의 CMA용 공간을 할당한다. (fix된 위치)

 

구조체 및 전역 변수

dma_contig_early_reserve 구조체

arch/arm/mm/dma-mapping.c

struct dma_contig_early_reserve {
        phys_addr_t base;
        unsigned long size;
};

 

전역변수

arch/arm/mm/dma-mapping.c

static struct dma_contig_early_reserve dma_mmu_remap[MAX_CMA_AREAS] __initdata;
static int dma_mmu_remap_num __initdata;

• dma_mmu_remap[]
  • MAX_CMA_AREAS는 CONFIG_CMA_AREAS 커널 옵션 + 1 값이다.
• dma_mmu_remap_num
  • 리매핑할 항목의 수

 

참고

• CMA(Contiguous Memory Allocator) | 문c
• dma_contiguous_remap()

버디 시스템이 연속된 물리 메모리의 할당 관리를 하는 시스x템인데, 그 중 특별히 디바이스들이 사용하는 연속된 물리 메모리에 대해 우선권을 주기 위해 사용하는 시스템이 CMA이다.
디바이스 장치를 위해 특별히 영역을 한정지어 CMA 영역으로 설정을 하면 버디 시스템은 보통 때에는 이 영역을 movable 페이지로 할당 관리한다. 이 영역이 movable 페이지로 가득 찰 때 디바이스가 연속된 물리 메모리를 요청하는 경우 CMA 영역의 일부 페이지들을 CMA 영역이 아닌 다른 영역으로 이주시키고 CMA 메모리 할당자가 디바이스가 필요로 하는 크기만큼의 메모리 페이지를 할당해준다.

 

• 2010년 삼성이 만든 연속 메모리 할당자이며 IBM 및 LG가 참여하여 발전시켰다.
• CONFIG_CMA 커널 옵션을 사용한다.
• CMA 기능은 주로 DMA 서브시스템에서 필요로하는 물리적으로 연속된 메모리를 커널 실행 시 별도로 reserve하지 않고 할당받아 사용할 수 있도록 관리하기 위해 사용된다.
  • CONFIG_DMA_CMA 커널 옵션을 사용한다.
  • 그외 powerpc 아키텍처에서는 kvm을 위해서도 사용된다.
  • “cma=” 커널 파라메터로 cma 영역을 지정하고 이 영역에는 cma 및 movable 페이지만 사용되도록 제한되며 cma 영역이 부족한 경우 movable 페이지를 다른 곳으로 이주시킨다.
• 버디 할당자와는 다르게 2의 차수 단위의 사이즈로 할당을 제한하지 않는다. (10M 영역 할당 등)
• cma 할당자는 dma 서브 시스템과 완전 통합되어 dma를 사용하는 디바이스 드라이버 개발자가 별도의 cma api를 사용할 필요 없다.
  • 참고: Document/DMA-API.txt | kernel.org

다음 그림은 cma 가  cma_area[] 구조체 배열에서 관리되는 것을 나타내며 각각의 cma area는 비트맵으로 관리되는 것을 나타낸다.

 

Cache-Coherent 문제

• h/w가 캐시 coherent 기능을 제공하지 않는 경우 s/w 자체적으로  캐시 coherent 기능이 필요한데 이를 위해 페이지 할당 시 dma_alloc_coherent() 함수를 통해 캐시를 사용하지 않는 매핑을 사용한다.
  • dma_map_single() 함수를 통해 사용하는 경우 캐시 coherent 없이 빠르게 access하는 버퍼를 만들 수도 있다.
    • DMA Pool 할당자를 통해 dma_pool_create() 및 dma_pool_alloc() 함수도 사용할 수 있다.
• 불행하게도 캐시 매핑에 대해 현재 cma 구조가 완전하지 않는 문제가 있다. 캐시 coherent 기능을 위해 언캐시 매핑이 필요한데 이미 커널의 lowmem 영역을 매핑하여 캐시가 사용되게 사용되므로 dma 영역으로 할당하는 언캐시된 메모리 페이지에 대해서 두 개의 매핑이 충돌하는 문제가 있다.
  • 이에 대해 2가지 해법으로 진행이되고 있다. 하나는 highmem에 cma 영역을 할당하게 하는 방법이다.(단 메모리가 작거나 64비트 시스템은 highmem이 없음…^^;) 두 번째는 dma-buffer로 할당되어 사용되는 영역은 커널의 리니어 매핑에서 제거하는 방법이다.
    • 현재는 두 번째의 방법을 밀고있다. 이 방법을 사용하므로 커널 메모리 영역(lowmem)이 huge 페이지를 사용하여 크게 리니어 매핑되는데 이 영역의 일부가 분할되어 매핑되면서 TLB 캐시 성능이 저하되는 것은 피할 수 없다.
    • CMA and ARM | LWN.net

 

CMA 관리 영역 추가

이 함수에서 정의된 cma 관리 영역들은 추후 cma 드라이버가 로드되면서 초기화 된 후 할당 관리를 사용할 수 있다. CONFIG_MODULE 커널 옵션을 사용하지 않을 경우에는 아래의 루틴에 의해 초기화된다.

• core_initcall(cma_init_reserved_areas);
  • 등록되는 모든 initcall 함수들은 kernel_init 스레드의 do_initcalls() 함수에서 호출된다.

 

cma_declare_contiguous()

mm/cma.c

/**
 * cma_declare_contiguous() - reserve custom contiguous area
 * @base: Base address of the reserved area optional, use 0 for any
 * @size: Size of the reserved area (in bytes),
 * @limit: End address of the reserved memory (optional, 0 for any).
 * @alignment: Alignment for the CMA area, should be power of 2 or zero
 * @order_per_bit: Order of pages represented by one bit on bitmap.
 * @fixed: hint about where to place the reserved area
 * @res_cma: Pointer to store the created cma region.
 *
 * This function reserves memory from early allocator. It should be
 * called by arch specific code once the early allocator (memblock or bootmem)
 * has been activated and all other subsystems have already allocated/reserved
 * memory. This function allows to create custom reserved areas.
 *
 * If @fixed is true, reserve contiguous area at exactly @base.  If false,
 * reserve in range from @base to @limit.
 */
int __init cma_declare_contiguous(phys_addr_t base,
                        phys_addr_t size, phys_addr_t limit,
                        phys_addr_t alignment, unsigned int order_per_bit,
                        bool fixed, struct cma **res_cma)
{
        phys_addr_t memblock_end = memblock_end_of_DRAM();
        phys_addr_t highmem_start;
        int ret = 0;

#ifdef CONFIG_X86
        /*
         * high_memory isn't direct mapped memory so retrieving its physical
         * address isn't appropriate.  But it would be useful to check the
         * physical address of the highmem boundary so it's justfiable to get
         * the physical address from it.  On x86 there is a validation check for
         * this case, so the following workaround is needed to avoid it.
         */
        highmem_start = __pa_nodebug(high_memory);
#else
        highmem_start = __pa(high_memory);
#endif
        pr_debug("%s(size %pa, base %pa, limit %pa alignment %pa)\n",
                __func__, &size, &base, &limit, &alignment);

        if (cma_area_count == ARRAY_SIZE(cma_areas)) {
                pr_err("Not enough slots for CMA reserved regions!\n");
                return -ENOSPC;
        }

        if (!size)
                return -EINVAL;

        if (alignment && !is_power_of_2(alignment))
                return -EINVAL;

CMA로 관리하고자 하는 메모리 영역을 설정한다. 메모리 영역은 최대 MAX_CMA_AREAS 갯수 이내로 제한된다.

• phys_addr_t memblock_end = memblock_end_of_DRAM();
  • memory memblock에 등록된 마지막 항목의 base + size를 하여 끝 주소를 알아온다.
• highmem_start = __pa(high_memory);
  • high_memory
    • 물리 메모리 사이즈를 최대 lowmem 영역의 사이즈와 비교하여
      • 초과하는 경우 high_memory는 max lowmem 영역의 의 끝 가상 주소
      • 초과하지 않는 경우 high_memory는 lowmem 영역의 끝 가상 주소
• if (cma_area_count == ARRAY_SIZE(cma_areas)) {
  • cma_areas 배열이 가득 찬 경우 에러 메시지를 출력하고 에러를 리턴한다.
• if (alignment && !is_power_of_2(alignment))
  • alignment가 지정된 경우 2의 차수가 아닌 경우 그냥 에러를 리턴한다.

        /*
         * Sanitise input arguments.
         * Pages both ends in CMA area could be merged into adjacent unmovable
         * migratetype page by page allocator's buddy algorithm. In the case,
         * you couldn't get a contiguous memory, which is not what we want.
         */
        alignment = max(alignment,
                (phys_addr_t)PAGE_SIZE << max(MAX_ORDER - 1, pageblock_order));
        base = ALIGN(base, alignment);
        size = ALIGN(size, alignment);
        limit &= ~(alignment - 1);

        if (!base)
                fixed = false;

        /* size should be aligned with order_per_bit */
        if (!IS_ALIGNED(size >> PAGE_SHIFT, 1 << order_per_bit))
                return -EINVAL;

        /*
         * If allocating at a fixed base the request region must not cross the
         * low/high memory boundary.
         */
        if (fixed && base < highmem_start && base + size > highmem_start) {
                ret = -EINVAL;
                pr_err("Region at %pa defined on low/high memory boundary (%pa)\n",
                        &base, &highmem_start);
                goto err;
        }

• alignment = max(alignment, (phys_addr_t)PAGE_SIZE << max(MAX_ORDER – 1, pageblock_order))
  • pageblock_order
    • 32bit ARM은 CONFIG_HUGETLB_PAGE 옵션을 지원하지 않는다.
  • MAXORDER(11=버디에서 사용)-1과 같다.
• alignment와 4M(PAGE_SIZE << 10) 중 큰 수를 대입
• base = ALIGN(base, alignment);
  • base를 alignment 단위로round up
• size = ALIGN(size, alignment);
  • size를 alignment 단위로 round up
• limit &= ~(alignment – 1);
  • limit를 alignment 단위로 round down
• if (!base)
  • base가 0이면 인수 fixed 값을 false로 변경한다.
  • 결국 fixed를 true로 하여 이 함수를 호출한 경우에도 base가 0일 때만 true로 유지된다.
• if (!IS_ALIGNED(size >> PAGE_SHIFT, 1 << order_per_bit))
  • size가 2^order_per_bit 페이지(4K)로 align되지 않으면 에러를 리턴한다.
• if (fixed && base < highmem_start && base + size > highmem_start) {
  • fixed가 true이면서 영역이 highmem 영역과 겹치면
    • 영역이 low/high 메모리 경계에 정의되었다고 에러 메시지를 출력하고 에러를 리턴한다.

        /*
         * If the limit is unspecified or above the memblock end, its effective
         * value will be the memblock end. Set it explicitly to simplify further
         * checks.
         */
        if (limit == 0 || limit > memblock_end)
                limit = memblock_end;

        /* Reserve memory */
        if (fixed) {
                if (memblock_is_region_reserved(base, size) ||
                    memblock_reserve(base, size) < 0) {
                        ret = -EBUSY;
                        goto err;
                }
        } else {
                phys_addr_t addr = 0;

                /*
                 * All pages in the reserved area must come from the same zone.
                 * If the requested region crosses the low/high memory boundary,
                 * try allocating from high memory first and fall back to low
                 * memory in case of failure.
                 */
                if (base < highmem_start && limit > highmem_start) {
                        addr = memblock_alloc_range(size, alignment,
                                                    highmem_start, limit);
                        limit = highmem_start;
                }

                if (!addr) {
                        addr = memblock_alloc_range(size, alignment, base,
                                                    limit);
                        if (!addr) {
                                ret = -ENOMEM;
                                goto err;
                        }
                }

                /*
                 * kmemleak scans/reads tracked objects for pointers to other
                 * objects but this address isn't mapped and accessible
                 */
                kmemleak_ignore(phys_to_virt(addr));
                base = addr;
        }

        ret = cma_init_reserved_mem(base, size, order_per_bit, res_cma);
        if (ret)
                goto err;

        pr_info("Reserved %ld MiB at %pa\n", (unsigned long)size / SZ_1M,
                &base);
        return 0;

err:
        pr_err("Failed to reserve %ld MiB\n", (unsigned long)size / SZ_1M);
        return ret;
}

• if (limit == 0 || limit > memblock_end)
  • limit가 0이거나 limit가 memblock_end를 초과하는 경우 limit를 memblock_end로 설정한다.
  • CMA에 메모리 만큼의 사이즈를 등록한다.
• if (fixed) {
  • 추가 시 lowmem 내에서 고정적으로 base 주소부터 추가를 하려는 경우
• if (memblock_is_region_reserved(base, size) || memblock_reserve(base, size) < 0) {
  • 영역이 reserve memblock에 등록되었었거나 영역을 reserve memblock에 등록 에러된 경우 에러를 리턴한다.

fixed가 false인 경우 추가할 영역이 lowmem과 highmem영역의 경계인 경우 먼저 highmem 영역에 할당을 시도하고 실패하는 경우 lowmem 영역에 할당한다.

• if (base < highmem_start && limit > highmem_start) {
  • 추가할 영역이 highmem 영역과 lowmem 영역의 경계인 경우
• addr = memblock_alloc_range(size, alignment, highmem_start, limit);
  • highmem_start 부터 limit 범위 사이에서 요청 사이즈를 할당한다.
• if (!addr) {
  • highmem 영역에 할당을 실패한 경우
• addr = memblock_alloc_range(size, alignment, base, limit);
  • base 부터 limit 범위 사이에 요청 사이즈를 할당하고 실패하면 에러를 리턴한다.
• kmemleak_ignore(phys_to_virt(addr));
  • 이 주소가 scan되고 leak로 리포트되지 않도록 무시하게 한다.
• ret = cma_init_reserved_mem(base, size, order_per_bit, res_cma);
  • reserve된 영역을 다시 한 번 sanity check를 수행하고 cma 관리 항목을 설정한다.
  • cma 관리 항목(cma area 정보)은 추후 각 항목이 초기화되어야 한다..
    • CMA 모듈이 로드될 때 cma_init_reserved_area()가 호출되며 이 때 각 영역이 초기화된다.

 

cma_init_reserved_mem()

mm/cma.c

/**
 * cma_init_reserved_mem() - create custom contiguous area from reserved memory
 * @base: Base address of the reserved area
 * @size: Size of the reserved area (in bytes),
 * @order_per_bit: Order of pages represented by one bit on bitmap.
 * @res_cma: Pointer to store the created cma region.
 *
 * This function creates custom contiguous area from already reserved memory.
 */
int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
                                 int order_per_bit, struct cma **res_cma)
{
        struct cma *cma;
        phys_addr_t alignment;

        /* Sanity checks */
        if (cma_area_count == ARRAY_SIZE(cma_areas)) {
                pr_err("Not enough slots for CMA reserved regions!\n");
                return -ENOSPC;
        }

        if (!size || !memblock_is_region_reserved(base, size))
                return -EINVAL;

        /* ensure minimal alignment requied by mm core */
        alignment = PAGE_SIZE << max(MAX_ORDER - 1, pageblock_order);

        /* alignment should be aligned with order_per_bit */
        if (!IS_ALIGNED(alignment >> PAGE_SHIFT, 1 << order_per_bit))
                return -EINVAL;

        if (ALIGN(base, alignment) != base || ALIGN(size, alignment) != size)
                return -EINVAL;

        /*
         * Each reserved area must be initialised later, when more kernel
         * subsystems (like slab allocator) are available.
         */
        cma = &cma_areas[cma_area_count];
        cma->base_pfn = PFN_DOWN(base);
        cma->count = size >> PAGE_SHIFT;
        cma->order_per_bit = order_per_bit;
        *res_cma = cma;
        cma_area_count++;
        totalcma_pages += (size / PAGE_SIZE);

        return 0;
}

• if (cma_area_count == ARRAY_SIZE(cma_areas)) {
  • cma_areas[]에 더 이상 할당할 공간이 없는 경우 에러를 출력하고 리턴한다.
• if (!size || !memblock_is_region_reserved(base, size))
  • size가 0이거나 요청 영역이 reserve memblock에 없는 경우 에러를 리턴한다.
•  alignment = PAGE_SIZE << max(MAX_ORDER – 1, pageblock_order);
  • pageblock_order
    • 32bit ARM은 CONFIG_HUGETLB_PAGE 옵션을 지원하지 않는다.
    • MAXORDER(11=버디에서 사용)-1과 같다.
  • 4M = PAGE_SIZE(4K) << (MAXORDER(11) – 1)
• if (!IS_ALIGNED(alignment >> PAGE_SHIFT, 1 << order_per_bit))
  • alignment가 order_per_bit 단위로 align 되어 있지 않은 경우 에러를 리턴한다.
• if (ALIGN(base, alignment) != base || ALIGN(size, alignment) != size)
  • 요청 시작 주소와 사이즈가 alignment 단위로 align 되어 있지 않은 경우 에러를 리턴한다.
• cma_areas[]에 요청 항목을 추가, cma_area_count를 1 증가시키고 totalcma_pages에 추가된 페이지 수를 증가시킨다.

아래 그림은 cma_init_reserved_mem() 함수를 통하여 만들어질 때 영역에 대한 size와 base가 4M 단위 및 2^order_per_bit 페이지로 align되어야 만들어질 수 있는 것을 나타낸다.

 

cma 할당과 해제

cma_alloc()

mm/cma.c

/**
 * cma_alloc() - allocate pages from contiguous area
 * @cma:   Contiguous memory region for which the allocation is performed.
 * @count: Requested number of pages.
 * @align: Requested alignment of pages (in PAGE_SIZE order).
 *
 * This function allocates part of contiguous memory on specific
 * contiguous memory area.
 */
struct page *cma_alloc(struct cma *cma, int count, unsigned int align)
{
        unsigned long mask, offset, pfn, start = 0;
        unsigned long bitmap_maxno, bitmap_no, bitmap_count;
        struct page *page = NULL;
        int ret;

        if (!cma || !cma->count)
                return NULL;

        pr_debug("%s(cma %p, count %d, align %d)\n", __func__, (void *)cma,
                 count, align);

        if (!count)
                return NULL;

        mask = cma_bitmap_aligned_mask(cma, align);
        offset = cma_bitmap_aligned_offset(cma, align);
        bitmap_maxno = cma_bitmap_maxno(cma);
        bitmap_count = cma_bitmap_pages_to_bits(cma, count);

        for (;;) {
                mutex_lock(&cma->lock);
                bitmap_no = bitmap_find_next_zero_area_off(cma->bitmap,
                                bitmap_maxno, start, bitmap_count, mask,
                                offset);
                if (bitmap_no >= bitmap_maxno) {
                        mutex_unlock(&cma->lock);
                        break;
                }
                bitmap_set(cma->bitmap, bitmap_no, bitmap_count);
                /*
                 * It's safe to drop the lock here. We've marked this region for
                 * our exclusive use. If the migration fails we will take the
                 * lock again and unmark it.
                 */
                mutex_unlock(&cma->lock);

                pfn = cma->base_pfn + (bitmap_no << cma->order_per_bit);
                mutex_lock(&cma_mutex);
                ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA);
                mutex_unlock(&cma_mutex);
                if (ret == 0) {
                        page = pfn_to_page(pfn);
                        break;
                }

                cma_clear_bitmap(cma, pfn, count);
                if (ret != -EBUSY)
                        break;

                pr_debug("%s(): memory range at %p is busy, retrying\n",
                         __func__, pfn_to_page(pfn));
                /* try again with a bit different memory target */
                start = bitmap_no + mask + 1;
        }

        pr_debug("%s(): returned %p\n", __func__, page);
        return page;
}

• if (!cma || !cma->count)
  • cma가 null이거나 cma에 사용할 수 있는 비트가 없는 경우 null 리턴
• if (!count)
  • 요청 count(bit)가 없는 경우 null 리턴
• mask = cma_bitmap_aligned_mask(cma, align);
  • align이 cma->order_per_bit 보다 큰 경우 그 차이만큼의 비트 수를 마스크 비트 1로 만들어 리턴
    • 예) align=4(64K), cma->order_per_bit=2(16K)
      • 3 (두 개의 bit를 1로 하여 만든 마스크)
• offset = cma_bitmap_aligned_offset(cma, align);
  • 시작 주소를 2 ^ align page로 align할 때 사용할 수 없는 사이즈를 offset으로 알아온다.
• bitmap_maxno = cma_bitmap_maxno(cma);
  • 비트맵에서 최대 사용할 수 있는 비트 수를 알아온다.
• bitmap_count = cma_bitmap_pages_to_bits(cma, count);
  • 요청 count(페이지)에 대해 필요한 비트맵 비트 수
• bitmap_no = bitmap_find_next_zero_area_off(cma->bitmap, bitmap_maxno, start, bitmap_count, mask, offset);
  • 비트맵에서 빈자리를 찾아 bitmap_no를 알아온다.
    • cma->bitmap 부터 검색을 하여 size만큼의 bit를 mask하여 0이 나오면 빈 자리라 판단하여 bitmap_no를 알아온다. (offset은 할당하지 않는 영역)
• if (bitmap_no >= bitmap_maxno) {
  • 추가할 공간이 없으면 null을 return 한다.
•  bitmap_set(cma->bitmap, bitmap_no, bitmap_count);
  • bitmap_no 위치에 bitmap_count bit 수 만큼 1로 설정한다.
• pfn = cma->base_pfn + (bitmap_no << cma->order_per_bit);
  • 할당한 위치에 대한 pfn
  • 예) base_pfn=0x1000, bitmap_no=1, order_per_bit=1
    • 0x1002 = 0x1000 + (1 << 1)
• ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA);
  • 필요한 만큼의 페이지들을 모두 MIGRATE_CMA로 할당하고 성공하는 경우 page 구조체 포인터를 리턴한다. 이 영역에 들어가 있는 기존 movable 페이지들은 모두 compaction 과정을 통해 이주시킨다.
•  cma_clear_bitmap(cma, pfn, count);
  • 할당이 실패한 경우 bitmap을 다시 지운다.
  • 만일 실패 사요가 -EBUSY가 아닌 경우 null을 리턴한다.
• start = bitmap_no + mask + 1;
  • 다음 비트맵 위치에서 다시 한 번 할당을 시도한다.

아래 그림에서는 align 단위를 다르게 하여 cma_alloc() 함수를 호출하였을 때 페이지가 할당되는 모습을 나타낸다.

 

cma_bitmap_aligned_mask()

mm/cma.c

static unsigned long cma_bitmap_aligned_mask(struct cma *cma, int align_order)
{
        if (align_order <= cma->order_per_bit)
                return 0;
        return (1UL << (align_order - cma->order_per_bit)) - 1;
}

• align_order와 cma->order_per_bit의 차이만큼의 비트 수를 1로 만들어 리턴
  • 해당 cma 항목에서 비트가 관리하는 페이지 단위가 요청한 align_order보다 크거나 같으면 0을 리턴한다.
  • 예) align_order = 4(64K 단위), cma->order_per_bit = 2(16K 단위)
    • 3 (2개의 비트를 1로 설정하여 마스크로 만든다.)

아래 그림은 요청 단위를 2^3 page로 할당하고자 할 때 기존 cma 영역이 2 페이지 단위로 관리되던 것에 대하여 그 비트 차이만큼의 mask 값을 알아온다.

 

cma_bitmap_aligned_offset()

mm/cma.c

/*
 * Find a PFN aligned to the specified order and return an offset represented in
 * order_per_bits.
 */
static unsigned long cma_bitmap_aligned_offset(struct cma *cma, int align_order)
{
        if (align_order <= cma->order_per_bit)
                return 0;

        return (ALIGN(cma->base_pfn, (1UL << align_order))
                - cma->base_pfn) >> cma->order_per_bit;
}

• cma->base_pfn이 요청한 align_order로 되어 있지 않은 경우 align_order 단위의 검색을 위해 필요한 offset를 리턴한다.
  • 해당 cma 항목에서 비트가 관리하는 페이지 단위가 요청한 align_order보다 크거나 같으면 0을 리턴한다.
  • 시작 pfn을 align_order만큼 좌측으로 shift한 후 시작 pfn을 뺀 후 cma->order_per_bit 만큼 우측 쉬프트
    • 예) 0x0001_2344, cma->order_per_bit = 2(16K 단위), align_order = 4(64K 단위)
      • 0xC(0x0001_2350 – 0x0001_2344) >> 2 = 3

아래 그림은 cma->base_pfn이 2^3 page 수 만큼 align이 되어 있지 않을 경우 그 차이만큼 offset을 알아오는 것을 나타낸다.

 

cma_bitmap_maxno()

mm/cma.c

static unsigned long cma_bitmap_maxno(struct cma *cma)
{
        return cma->count >> cma->order_per_bit;
}

• 비트맵에서 사용하는 최대 비트 수
  • 예) cma->count=800, cma->order_per_bit=2
    • 200개 비트

 

cma_bitmap_pages_to_bits()

mm/cma.c

static unsigned long cma_bitmap_pages_to_bits(struct cma *cma,
                                                unsigned long pages)
{
        return ALIGN(pages, 1UL << cma->order_per_bit) >> cma->order_per_bit;
}

• 요청 페이지에 대해 필요한 비트맵에서 사용할 비트 수
  • 비트맵이 사용하는 최소 단위의 사이즈로 align하였을 때 필요한 비트 수를 리턴한다.
  • 예) pages=5(20K 요청), cma->order_per_bit=2(16K 단위)
    • 2(16K x 2) = 8 >> 2

 

cma_release()

mm/cma.c

/**
 * cma_release() - release allocated pages
 * @cma:   Contiguous memory region for which the allocation is performed.
 * @pages: Allocated pages.
 * @count: Number of allocated pages.
 *
 * This function releases memory allocated by alloc_cma().
 * It returns false when provided pages do not belong to contiguous area and
 * true otherwise.
 */
bool cma_release(struct cma *cma, struct page *pages, int count)
{
        unsigned long pfn;

        if (!cma || !pages)
                return false;

        pr_debug("%s(page %p)\n", __func__, (void *)pages);

        pfn = page_to_pfn(pages);

        if (pfn < cma->base_pfn || pfn >= cma->base_pfn + cma->count)
                return false;

        VM_BUG_ON(pfn + count > cma->base_pfn + cma->count);

        free_contig_range(pfn, count);
        cma_clear_bitmap(cma, pfn, count);

        return true;
}

• if (!cma || !pages)
  • cma가 null이거나 pages 포인터가 null 인경우 false를 리턴한다.
• 요청 페이지의 시작 물리 주소가 cma 영역을 벗어난 경우 false를 리턴한다.
• free_contig_range(pfn, count)
  • cma 영역의 pfn 주소에서 count(페이지 수) 만큼 해제한다.
• cma_clear_bitmap(cma, pfn, count);
  • 해당 영역의 페이지를 비트맵에서 clear한다.

 

free_contig_range()

mm/page_alloc.c

void free_contig_range(unsigned long pfn, unsigned nr_pages)
{
        unsigned int count = 0; 

        for (; nr_pages--; pfn++) {
                struct page *page = pfn_to_page(pfn);

                count += page_count(page) != 1;
                __free_page(page);
        }
        WARN(count != 0, "%d pages are still in use!\n", count);
}

• pfn부터 요청한 페이지 수 만큼 루프를 돌며 페이지를 해제 한다.

 

cma_clear_bitmap()

mm/cma.c

static void cma_clear_bitmap(struct cma *cma, unsigned long pfn, int count)
{
        unsigned long bitmap_no, bitmap_count;

        bitmap_no = (pfn - cma->base_pfn) >> cma->order_per_bit;
        bitmap_count = cma_bitmap_pages_to_bits(cma, count);

        mutex_lock(&cma->lock);
        bitmap_clear(cma->bitmap, bitmap_no, bitmap_count);
        mutex_unlock(&cma->lock);
}

• bitmap_no = (pfn – cma->base_pfn) >> cma->order_per_bit;
  • bitmap 번호를 구한다.
• bitmap_count = cma_bitmap_pages_to_bits(cma, count)
  • count(페이지)로 필요한 비트 수를 구한다.
• bitmap_clear(cma->bitmap, bitmap_no, bitmap_count);
  • 비트맵에서 bitmap_no 위치부터 bitmap_count bit 수 만큼 clear 한다.

 

CMA 영역 초기화

cma_init_reserved_areas()

mm/cma.c

static int __init cma_init_reserved_areas(void)
{
        int i;

        for (i = 0; i < cma_area_count; i++) {
                int ret = cma_activate_area(&cma_areas[i]);

                if (ret)
                        return ret;
        }

        return 0;
}
core_initcall(cma_init_reserved_areas);

• core_initcall(cma_init_reserved_areas);
  • CONFIG_MODULE 커널 옵션에 따라 호출되는 위치가 달라진다.
    • CONFIG_MODULE 설정이 없는 경우
      • 등록되는 모든 initcall 함수들은 kernel_init 스레드의 do_initcalls() 함수에서 호출된다.
    • CONFIG_MODULE 설정이 있는 경우
      • 드라이버들 내부에 있는 module_init(cma_init_reserved_areas) 선언과 동일하다. 따라서 cma 드라이버 모듈이 로드되는 경우 cma_init_reserved_areas() 함수가 호출된다.

 

cma_activate_area()

mm/cma.c

static int __init cma_activate_area(struct cma *cma)
{
        int bitmap_size = BITS_TO_LONGS(cma_bitmap_maxno(cma)) * sizeof(long);
        unsigned long base_pfn = cma->base_pfn, pfn = base_pfn;
        unsigned i = cma->count >> pageblock_order;
        struct zone *zone;

        cma->bitmap = kzalloc(bitmap_size, GFP_KERNEL);

        if (!cma->bitmap)
                return -ENOMEM;

        WARN_ON_ONCE(!pfn_valid(pfn));
        zone = page_zone(pfn_to_page(pfn));

        do {
                unsigned j;

                base_pfn = pfn;
                for (j = pageblock_nr_pages; j; --j, pfn++) {
                        WARN_ON_ONCE(!pfn_valid(pfn));
                        /*
                         * alloc_contig_range requires the pfn range
                         * specified to be in the same zone. Make this
                         * simple by forcing the entire CMA resv range
                         * to be in the same zone.
                         */
                        if (page_zone(pfn_to_page(pfn)) != zone)
                                goto err;
                }
                init_cma_reserved_pageblock(pfn_to_page(base_pfn));
        } while (--i);

        mutex_init(&cma->lock);
        return 0;

err:
        kfree(cma->bitmap);
        cma->count = 0;
        return -EINVAL;
}

 

모듈 관련

아래 매크로 코드들은 2015년 5월 커널 v4.2-rc3에서 include/linux/init.h  -> include/linux/module.h 로 옮겼다.

 

core_initcall()

include/linux/init.h

#define core_initcall(fn)               module_init(fn)

• CONFIG_MODULE이 선언되어 있는 경우 module_init()을 호출한다.

 

module_init()

include/linux/init.h

/* Each module must use one module_init(). */
#define module_init(initfn)                                     \
        static inline initcall_t __inittest(void)               \
        { return initfn; }                                      \
        int init_module(void) __attribute__((alias(#initfn)));

• initcall_t
  • 다음과 같이 인수 없는 함수 포인터이다.
  • typedef int (*initcall_t)(void);
• 인수 initfn 함수를 호출하고 결과를 int 타입으로 리턴한다.
• int init_module(void) __attribute__((alias(#initfn)));
  • alias 컴파일러 속성을 사용하여 init_module() 함수명을 alias명으로 사용할 때 인수 initfn을 호출한다.

 

구조체 및 주요 변수

struct cma

mm/cma.c

struct cma {
        unsigned long   base_pfn;
        unsigned long   count;
        unsigned long   *bitmap;
        unsigned int order_per_bit; /* Order of pages represented by one bit */
        struct mutex    lock;
};

• base_pfn
  • 시작 물리 주소의 pfn 번호
• count
  • 관리 페이지 수
• bitmap
  • 비트맵 데이터
• order_per_bit
  • 비트맵의 1비트가  표현하는 order 페이지(2^N 페이지, 0=1페이지, 1=2페이지, 2=4페이지, …)
• lock
  • 비트맵 조작시 동기화를 위해 사용

 

전역 변수

mm/cma.c

static struct cma cma_areas[MAX_CMA_AREAS];
static unsigned cma_area_count;
static DEFINE_MUTEX(cma_mutex);

• cma_areas[]
  • CONFIG_CMA_AREAS 커널 옵션이 설정된 경우 (1 + CONFIG_CMA_AREAS), 그렇지 않은 경우 0 이다.
• cma_area_count
  • cma_areas[] 배열에서 사용하는 항목 수
• cma_mutex
  • cma 영역 할당 시 동기화를 위해 사용

 

mm/page_alloc.c

unsigned long totalcma_pages __read_mostly;

• totalcma_pages
  • cma에 사용된 페이지 수

 

참고

• CMA: generalize CMA reserved area management functionality
• CMA(Contiguous Memory Allocator) for DMA | 문c
• Contiguous Memory Allocator | LWN.net
• A reworked contiguous memory allocator | LWN.net
• CMA and ARM | LWN.net
• Contiguous memory allocation for drivers | LWN.net
• CMA documentation file | LWN.net
• A deep dive into CMA | LWN.net
• Linux Kernel CMA | Mark Veltzer – odf file 다운로드
• Document/DMA-API-HOWTO.txt | kernel.org
• Document/DMA-API.txt | kernel.org
• Guaranteed Contiguous Memory Allocator | 박성재 – 다운로드 pdf

페이지 테이블 관련 명령(pgd, pud, pmd, pte)은 32bit ARM 리눅스용에 대해 제한하여 설명한다.

• ARM 리눅스에서는 3단계 페이지 테이블 관리를 사용
  • pgd -> pmd -> pte
• ARM h/w에서는 2단계 페이지 테이블 관리를 사용한다.
  • pgd(pmd) -> pte

 

엔트리 타입

• pgd_t
  • typedef struct { pmdval_t pgd[2]; } pgd_t;
  • pmdval_t는 u32형이다.
• pmd_t
  • typedef struct { pmdval_t pmd; } pmd_t;
• pte_t
  • typedef struct { pteval_t pte; } pte_t;
  • pteval_t는 u32형이다.

 

pgd 관련

pgd_val()

arch/arm/include/asm/pgtable-2level-types.h

#define pgd_val(x)      ((x).pgd[0])

• 두 개의 pgd 엔트리 중 첫 번째 pgd 엔트리 값을 리턴한다.

 

pgd_index()

arch/arm/include/asm/pgtable.h

/* to find an entry in a page-table-directory */
#define pgd_index(addr)         ((addr) >> PGDIR_SHIFT)

• 주어진 주소의 pgd 인덱스 값(0~2047)을 리턴한다.
• PGDIR_SHIFT=21 (=2M round down)

addr[31:21] 값을 우측으로 PGDIR_SHIFT(21) 비트 만큼 쉬프트하여 인덱스로 활용 (0~2047(0x7ff))

• rpi2 예) pgd_index(0x8a00_0000) = 0x450

 

pgd_offset()

arch/arm/include/asm/pgtable.h

#define pgd_offset(mm, addr)    ((mm)->pgd + pgd_index(addr))

• mm_struct 구조체가 가리키는 pgd 주소 + pgd 인덱스를 하여 pgd의 offset 주소를 알아올 수 있다.

 

pgd_offset_k()

arch/arm/include/asm/pgtable.h

/* to find an entry in a kernel page-table-directory */
#define pgd_offset_k(addr)      pgd_offset(&init_mm, addr)

• “_k” suffix(접미) 는 커널이라는 뜻이다. 즉 커널이 사용하는 level-1 PGD 에서 pgd 엔트리 가상 주소를 알아온다.

 

 

pgd_addr_end()

include/asm-generic/pgtable.h

/*
 * When walking page tables, get the address of the next boundary,
 * or the end address of the range if that comes earlier.  Although no
 * vma end wraps to 0, rounded up __boundary may wrap to 0 throughout.
 */

#define pgd_addr_end(addr, end)                                         \
({      unsigned long __boundary = ((addr) + PGDIR_SIZE) & PGDIR_MASK;  \
        (__boundary - 1 < (end) - 1)? __boundary: (end);                \
})

• addr 값에 2M를 더한 값을 round down 하고 end 주소 보다 작은 경우 리턴한다. 그렇지 않은 경우 end를 리턴한다.
• 예) addr=0x1000_0000, end=0x1040_0000
  • 호출1=0x1020_0000, 호출2=0x1040_0000
• 예) addr=0x1000_0004, end=0x1040_0004
  • 호출1=0x1020_0000, 호출2=0x1040_0000, 호출3=0x1040_0004

 

pud 관련

pud_val()

include/asm-generic/pgtable-nopud.h

#define pud_val(x)                              (pgd_val((x).pgd))

• pud 엔트리 값을 리턴한다.
• 실제 pud 테이블이 없으므로 pgd 값을 사용한다.

 

pud_offset()

include/asm-generic/pgtable-nopud.h

static inline pud_t * pud_offset(pgd_t * pgd, unsigned long address)
{
        return (pud_t *)pgd;
}

• pud의 offset은 pud 테이블이 없으므로 그냥 첫 번째 인수인 pgd만 리턴한다.

 

pmd 관련

pmd_val()

arch/arm/include/asm/pgtable-2level-types.h

#define pmd_val(x)      ((x).pmd)

• pmd 엔트리 값을 리턴한다.

 

pmd_index()

• 사용하지 않음.

 

pmd_offset()

arch/arm/include/asm/pgtable-2level.h

static inline pmd_t *pmd_offset(pud_t *pud, unsigned long addr)
{
        return (pmd_t *)pud;
}

• pmd의 offset은 pmd 테이블이 없으므로 그냥 첫 번째 인수인 pud만 리턴한다.

 

pmd_off_k()

arch/arm/mm/mm.h

static inline pmd_t *pmd_off_k(unsigned long virt)
{
        return pmd_offset(pud_offset(pgd_offset_k(virt), virt), virt);
}

가상 주소에 대응하는 pmd 엔트리 가상 주소를 알아온다.

•  pgd_offset_k()
  • 커널이 사용하는 level-1 PGD 에서 가상 주소에 대응하는 pgd 엔트리 가상 주소를 알아온다
• pud_offset()
  • 첫 번째 인수인 pgd 엔트리 가상 주소를 리턴한다.
• pmd_offset()
  • 첫 번째 인수가 가리키는 pmd 테이블에서 가상 주소에 대응하는 pmd 엔트리 가상 주소를 알아온다.

 

pmd_page_vaddr()

arch/arm/include/asm/pgtable.h

arch/arm/include/asm/pgtable.h

static inline pte_t *pmd_page_vaddr(pmd_t pmd)
{
        return __va(pmd_val(pmd) & PHYS_MASK & (s32)PAGE_MASK);
}

• pmd 테이블의 가상 주소값을 알아온다.
• pmd 값을 4K round down 한 후 가상 주소로 변환한다.

pmd[31:12] 값을 가상주소로 변환하여 pte 테이블을 가리키는 가상 주소를 알아낸다.

• 예) rpi2: pmd_page_vaddr(0x0234_5678) = 0x8234_5000

 

pmd_clear()

arch/arm/include/asm/pgtable-2level.h

#define pmd_clear(pmdp)                 \
        do {                            \
                pmdp[0] = __pmd(0);     \
                pmdp[1] = __pmd(0);     \
                clean_pmd_entry(pmdp);  \
        } while (0)

• pmd 엔트리 2개를 삭제한다.
  • pgd 엔트리 하나가 pmd 엔트리 2개 이므로 결국 pgd 엔트리를 지우는 것과 동일하다.
• clean_pmd_entry(pmdp);
  • TLB를 삭제한다.

 

clean_pmd_entry()

arch/arm/include/asm/tlbflush.h

static inline void clean_pmd_entry(void *pmd)
{
        const unsigned int __tlb_flag = __cpu_tlb_flags;
        
        tlb_op(TLB_DCLEAN, "c7, c10, 1  @ flush_pmd", pmd);
        tlb_l2_op(TLB_L2CLEAN_FR, "c15, c9, 1  @ L2 flush_pmd", pmd);
}

• L1-TLB 엔트리와 L2-TLB 엔트리를 flush(여기서는 invalidate) 한다.

 

pte 관련

pte_val()

arch/arm/include/asm/pgtable-2level-types.h

#define pte_val(x)      ((x).pte)

• pte 엔트리 값을 리턴한다.

 

pte_index()

arch/arm/include/asm/pgtable.h

#define pte_index(addr)         (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))

• 주어진 주소의 pte 인덱스 값(0~511)을 리턴한다.
• PTRS_PER_PTE=512
• PAGE_SHIFT=12 (=4K round down)

addr[12:20] 값을 우측으로 12bit 쉬프트하여 인덱스로 활용 (0~511(0x1ff))

• rpi2 예) pte_index(0x8a12_0000) = 0x120

 

pte_offset_kernel()

arch/arm/include/asm/pgtable.h

#define pte_offset_kernel(pmd,addr)     (pmd_page_vaddr(*(pmd)) + pte_index(addr))

level-1 테이블에서 pmd 포인터가 가리키는 pmd_t 값에 연동된 level-2 테이블에서 addr 값으로 pte index를 알아내어 해당 pte_t의 주소를 알아낸다.

• 예) rpi2: *pmd=0x0a00_0000
  • pte_offset_kernel(0x8000_6008, 0x8234_5000) = 0x8a00_0514

 

__pte_map() & __pte_unmap()

CONFIG_HIGHPTE

• pte 테이블을 highmem에서 운용하고자 할 때 사용하는 커널 옵션이다.
• highmem에 있는 페이지 테이블을 access  할 때 kmap_atomic()을 사용하여 highmem에 위치한 페이지 테이블을 fixmap에 매핑 후 그 페이지 access 할 수 있다. 사용한 후에는 kunmap_atomic()을 사용하여 페이지 테이블을 fixmap에서 언매핑하여야 한다.

pte 페이지 테이블을 lowmem에서 운영하는 경우에는 별도의 매핑을 할 필요가 없으므로 곧바로 해당 영역의 주소를 알아와서 access할 수 있다.

arch/arm/include/asm/pgtable.h

#ifndef CONFIG_HIGHPTE
#define __pte_map(pmd)          pmd_page_vaddr(*(pmd))
#define __pte_unmap(pte)        do { } while (0)
#else
#define __pte_map(pmd)          (pte_t *)kmap_atomic(pmd_page(*(pmd)))
#define __pte_unmap(pte)        kunmap_atomic(pte)
#endif

level-1 테이블에서 pmd 포인터가 가리키는 pmd_t 값에 연동된 pte 테이블의 가상 주소 값을 알아낸다.

• 예) rpi2: *pmd = 0x0a10_0000
  • __pte_map(0x8000_6004) = 0x8a10_0000

 

pte_offset_map()

arch/arm/include/asm/pgtable.h

#define pte_offset_map(pmd,addr)        (__pte_map(pmd) + pte_index(addr))

level-1 테이블에서 pmd 포인터가 가리키는 pmd_t 값에 연동된 level-2 테이블에서 addr 값으로 pte index를 알아내어 해당 pte_t의 가상 주소를 알아낸다.

• 예) rpi2: *pmd=0x0a00_0000
  • pte_offset_kernel(0x8000_6008, 0x8234_5000) = 0x8a00_0514

 

set_pte_ext()

arch/arm/include/asm/pgtable-2level.h

#define set_pte_ext(ptep,pte,ext) cpu_set_pte_ext(ptep,pte,ext)

 

pte_clear()

arch/arm/include/asm/pgtable.h

#define pte_clear(mm,addr,ptep) set_pte_ext(ptep, __pte(0), 0)

 

cpu_set_pte_ext()

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

#define cpu_set_pte_ext                 processor.set_pte_ext

cpu_v7_set_pte_ext()

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

/*
 *      cpu_v7_set_pte_ext(ptep, pte)
 *
 *      Set a level 2 translation table entry.
 *
 *      - ptep  - pointer to level 2 translation table entry
 *                (hardware version is stored at +2048 bytes)
 *      - pte   - PTE value to store
 *      - ext   - value for extended PTE bits
 */
ENTRY(cpu_v7_set_pte_ext)
#ifdef CONFIG_MMU
        str     r1, [r0]                        @ linux version

        bic     r3, r1, #0x000003f0
        bic     r3, r3, #PTE_TYPE_MASK
        orr     r3, r3, r2
        orr     r3, r3, #PTE_EXT_AP0 | 2

        tst     r1, #1 << 4
        orrne   r3, r3, #PTE_EXT_TEX(1)

        eor     r1, r1, #L_PTE_DIRTY
        tst     r1, #L_PTE_RDONLY | L_PTE_DIRTY
        orrne   r3, r3, #PTE_EXT_APX

        tst     r1, #L_PTE_USER
        orrne   r3, r3, #PTE_EXT_AP1

        tst     r1, #L_PTE_XN
        orrne   r3, r3, #PTE_EXT_XN

        tst     r1, #L_PTE_YOUNG
        tstne   r1, #L_PTE_VALID
        eorne   r1, r1, #L_PTE_NONE
        tstne   r1, #L_PTE_NONE
        moveq   r3, #0

 ARM(   str     r3, [r0, #2048]! )
 THUMB( add     r0, r0, #2048 )
 THUMB( str     r3, [r0] )
        ALT_SMP(W(nop))
        ALT_UP (mcr     p15, 0, r0, c7, c10, 1)         @ flush_pte
#endif
        bx      lr  
ENDPROC(cpu_v7_set_pte_ext)

ptep 주소에 위치한 pte 엔트리를 설정하는 경우 ptep로부터 2K byte 윗 쪽에 위치한 hw pte 엔트리 역시 linux pte 속성 값을 h/w pte 속성 값으로 변환하여 설정한다.

r1(linux pte 엔트리 값)

• MT(Memory Type)
  • 0: MT_UNCACHED
  • 1: MT_BUFFERABLE
  • 2: MT_WRITETHROUGH
  • 3: MT_WRITEBACK
  • 4: MT_DEVICE_SHARED
  • 6: MT_MINICACHE
  • 9: MT_DEV_WC
  • B: MT_DEV_CACHED
  • C: MT_DEV_NONSHARED
  • F: MT_VECTORS

r3(hw pte 엔트리 값), r2(ext, hw용 확장 pte 플래그)

• r3 값의 h/w pte AP, TEX, Table, XN 비트는 linux pte 값을 사용하여 재 설정하기 위해 일단 clear 한다.
  • r3 → 비트클리어(0x3f3)

• r3에 인수로 받은 h/w용 pte 플래그를 합치고 privileged access 권한에서 read 또는 read/write 권한을 주기위해 EXT_AP0을 설정하고 2차 테이블을 지원하기 위해 TABLE 비트를 설정한다.
  • r3 | ext(hw용 확장 pte 플래그) | PTE_EXT_AP0(0x10) | 2

• pte의 bit4가 1인 경우 TRE를 설정한다.
  • r3 | PTE_EXT_TEX(0x40)

• pte의 L_PTE_DIRTY가 없거나 L_PTE_RDONLY가 있으면 EXT_APX를 설정하여 read only로 만든다.
  • r3 | PTX_EXT_APX(0x200)

• pte의 L_PTE_USER가 있으면 unprivileged access 권한에서도 read 또는 read/write 권한을 주기 위해 EXT_AP1을 설정한다.
  • r3 | PTE_EXT_AP1(0x20)

• pte의 L_PTE_XN가 있으면 페이지에서 실행코드가 동작하지 않도록 XN을 설정한다.
  • r3 | PTEX_EXT_XN(0x1)

• pte의 L_PTE_YOUNG이 없거나 L_PTE_VALID(L_PTE_PRESENT)가 없거나 L_PTE_NONE이 있으면 r3을 모두 0으로 변경
  • 리눅스 PTE 엔트리에만 있는 L_PTE_YOUNG이 있으면서 L_PTE_PRESENT가 없는 경우 pte 엔트리가 아니라 swap 엔트리를 의미한다. (H/W PTE 값은 0을 대입)
    • 참고: swap-entry | 문c
  • 리눅스 PTE 엔트리에만 있는 L_PTE_NONE은 PAGE_NONE 매핑으로 automatic NUMA balancing을 위해 일부러 유저 페이지에 대한 fault를 발생시켜 사용하기 위해 이용한다. (H/W PTE 값은 0을 대입)
    • 참고: ARM: mm: introduce present, faulting entries for PAGE_NONE | LWN.net

 

• 리눅스용 pte 엔트리 속성 -> h/w pte 엔트리 속성 변환 예)
  • linux pte 엔트리=0x1234_565f(0b0001_0010_0011_0100_0101_0110_0101_1111)
    • pfn=0x12345, prot=MT_MEMORY_RW = SHARE | XN | DIRTY | WA(0b0111) | YOUNG | PRESENT
  • h/w pte 엔트리=0x1234_545f(0b0001_0010_0011_0100_0101_0100_0101_1111)
    • pfn=0x12345, prot=SHARE | AP(0b001=RW,NA) | TEX(0b001) | C | B | TABLE | XN

 

실제 연결된 페이지 테이블 예)

 

xxx_page() 관련

pgd_page()

include/asm-generic/pgtable-nopud.h

#define pgd_page(pgd)                           (pud_page((pud_t){ pgd }))

• pud page()를 호출 -> pmd_page() 호출하여 pmd 테이블에 대응하는 page를 리턴한다.

 

pud_page()

• 사용하지 않음.

 

pmd_page()

arch/arm/include/asm/pgtable.h

#define pmd_page(pmd)           pfn_to_page(__phys_to_pfn(pmd_val(pmd) & PHYS_MASK))

• pmd 테이블에 대응하는 page를 리턴한다

 

pte_page()

arch/arm/include/asm/pgtable.h

#define pte_page(pte)           pfn_to_page(pte_pfn(pte))

• pte 값에 대응하는 pfn 값을 알아온 후 해당 page를 리턴한다.

 

pte_pfn()

arch/arm/include/asm/pgtable.h

#define pte_pfn(pte)            ((pte_val(pte) & PHYS_MASK) >> PAGE_SHIFT)

• pte 엔트리 값을 12 bit 우측 쉬프트하여 pfn(물리 주소 frame 번호) 값으로 변환한다.

 

pfn_to_page()

include/asm-generic/memory_model.h

#define pfn_to_page __pfn_to_page

#define __pfn_to_page(pfn)      (mem_map + ((pfn) - ARCH_PFN_OFFSET))

• pfn 번호에 대응하는 page 구조체 주소를 알아온다.
• __pfn_to_page
  • 메모리 모델에 따라 구현이 다르다.
  • CONFIG_FLATMEM
    • ARCH_PFN_OFFSET = 물리주소 PFN
    • rpi2: mem_map + pfn
  • mem_map은 PFN0부터 시작되는 물리메모리 페이지의 정보인 page[] 구조체 배열을 가리킨다.

 

참고

• 페이지 테이블 | 문c
• 페이지 테이블 엔트리 속성 | 문c

<kernel v5.15>

Memory Model -2- (mem_map)

PFN(Page Frame Number)와 물리 모델별로 mem_map을 관리하는 방법에 대해 알아본다.

 

PFN(Page Frame Number)

PFN은 물리 주소에 사용되는 페이지 단위의 번호이고, 0부터 시작된다. 페이지 단위는 보통 4K를 사용하며, ARM64의 경우 대단위 데이터 베이스등의 운영을 목적으로 16K 및 64K로 설정되어 운영되는 시스템들도 있다.

• 예) 4K Page 기준: 0x0000_0000
  • PFN 값은 0이다.
• 예) 4K Page 기준: 0x1234_5678
  • PFN 값은 0x12345이다.

 

mem_map

• mem_map은 모든 물리 메모리 페이지 프레임에 대한 정보를 담아둔 page 구조체 배열이다.
  • 처음 리눅스에서는 unsigned short 타입의 참조 카운터 배열로 시작하다가 점점 필요 멤버가 늘어나 오늘날의 page 구조체가 되었다.
• NUMA 시스템과 UMA 시스템에서의 접근 방법이 다르고 물리 메모리 모델별로도 접근 방법이 다르다.
• mem_map의 초기화 함수 경로는 아키텍처 및 커널 설정마다 다르다.
  • arm with flatmem
    • setup_arch() → paging_init() → bootmem_init()  → zone_sizes_init() → free_area_init_node()
  • arm/arm64 with sparsemem
    • setup_arch() → bootmem_init() → sparse_init()

 

PFN vs page 변환 API

리눅스 커널은 PFN 값으로 page 구조체를 접근하는 변환과, 그 반대의 변환이 매우 빈번하게 사용한다. 이에 대응하는 API는 다음과 같다.

• pfn_to_page()
  • pfn 번호로 page 구조체 포인터를 반환한다.
• page_to_pfn()
  • page 구조체 포인터로 pfn 번호를 반환한다.

 

---

Flat Memory with mem_map

• NEED_MULTIPLE_NODES 커널 옵션이 사용되지 않을 때 *mem_map 포인터 변수는 하나의 page[] 구조체 배열을 가리킨다.
• FLAT_NODE_MEM_MAP 커널 옵션을 사용하는 경우 contig_page_data.node_mem_map를 통해서 page[] 구조체 배열을 가리킨다.

 

---

Discontiguous Memory with mem_map

• node_data[].node_mem_map를 통해서 page[] 구조체 배열을 가리킨다.
• x86_32에서는 섹션 to 노드 매핑을 하는 테이블을 별도로 구현하여 사용한다.
• 실제 사용하는 메모리에 대해서만 관리하고 hole 영역에 대해서는 전혀 관리하지 않는다.
• 커널 메인라인에서 이 모델은 더 이상 사용하지 않게 완전히 제거하였다.
  • mm: remove CONFIG_DISCONTIGMEM (2021, v5.14-rc1)

 

---

Sparse Memory with mem_map

• mem_map을 여러 개의 섹션을 통해 관리하며, 하나의 섹션을 관리하기 위해 mem_section 구조체를 사용한다.
• 한 개의 섹션의 크기는 수십MB ~ 수GB 크기를 사용한다.
  • 주의: 페이지 테이블에서 사용하는 섹션 용어와 혼동하면 안된다.
  • arm64 시스템의 경우 최초 1G를 사용하였지만 조금 더 작은 단위인 128M로 변경하였다.
    • 참고: arm64/sparsemem: reduce SECTION_SIZE_BITS (2021, v5.12-rc1)
• 하나의 mem_section 구조체는 PAGES_PER_SECTION 개수 만큼의 page[] 배열을 가리키고 관리한다.
• 메모리 할당 관리를 위해 섹션을 관리하는 mem_section 구조체의 구현이 두 개로 나뉘어 있다.
  •  SPARSEMEM_STATIC
    • 32비트 시스템등 물리 메모리 크기가 작은 시스템에서 mem_secton 구조체를 한꺼번에 컴파일 타임에 생성한다.
    • mem_section[][1] 이중 배열이지만 두 번째 인덱스는 사용하지 않는다.
  •  SPARSEMEM_EXTREME
    • 64비트 시스템등 물리 메모리 크기가 큰 시스템에서 mem_secton 구조체를 필요할 때 런타임에 생성하여 사용한다.
      • hole size가 매우 큰 경우를 대비하여 메모리 낭비를 줄일 수 있도록 설계되었다.
    • **mem_section 이중 포인터를 사용하고, mem_section[SECTIONS_PER_ROOT][SECTIONS_PER_ROOT] 형태로 접근하여 사용하고, 다음과 같이 사용된다.
      • 첫 번째 배열 인덱스의 경우 섹션 루트를 의미
        • NR_SECTION_ROOTS(섹션 루트 수) = NR_MEM_SECTIONS(전체 메모리에 사용할 섹션 수) / SECTIONS_PER_ROOT(1 페이지 프레임에 들어갈 수 있는 mem_section 구조체 수)
      • 두 번째 배열 인덱스는 루트 섹션 내에서의 mem_section 인덱스를 의미
        • SECTIONS_PER_ROOT(1 페이지 프레임에 들어갈 수 있는 mem_section 구조체 수)

 

다음 그림은 SPARSEMEM_EXTREME을 사용하지 않는 것으로 32bit arm – Realview-PBX 보드의 사용예이다.

 

다음 그림은 SPARSEMEM_EXTREME을 사용하는 것으로 arm64 아키텍처에서 4G DRAM을 사용한 예이다.

• 아래에서 섹션 사이즈는 1G를 사용한 예를 보였지만, 최근 128M로 변경하였으므로 커널 버전에 따라 이를 고려하여야 한다.
  • 참고: arm64/sparsemem: reduce SECTION_SIZE_BITS (2021, v5.12-rc1)

 

---

page 디스크립터

 

모든 물리 메모리 페이지마다 하나의 페이지 디스크립터가 할당된다. 모든 메모리 페이지마다 생성되므로 사이즈에 민감하다. 따라서 사이즈를 최대한 줄이기위해 페이지 디스크립터내에서 관리되는 멤버들을 유니온 타입으로 묶어 사용하도록 설계되었다.

 

다음은 32bit 시스템에서 동작하는 page 디스크립터를 보여준다. (모든 옵션을 제외한 최소 구성으로 32바이트를 사용한다.)

 

다음은 64bit 시스템에서 동작하는 page 디스크립터를 보여준다. (디폴트 옵션을 사용 시 64바이트이다.)

 

struct page

include/linux/mm_types.h -1/4-

/*
 * Each physical page in the system has a struct page associated with
 * it to keep track of whatever it is we are using the page for at the
 * moment. Note that we have no way to track which tasks are using
 * a page, though if it is a pagecache page, rmap structures can tell us
 * who is mapping it.
 *
 * If you allocate the page using alloc_pages(), you can use some of the
 * space in struct page for your own purposes.  The five words in the main
 * union are available, except for bit 0 of the first word which must be
 * kept clear.  Many users use this word to store a pointer to an object
 * which is guaranteed to be aligned.  If you use the same storage as
 * page->mapping, you must restore it to NULL before freeing the page.
 *
 * If your page will not be mapped to userspace, you can also use the four
 * bytes in the mapcount union, but you must call page_mapcount_reset()
 * before freeing it.
 *
 * If you want to use the refcount field, it must be used in such a way
 * that other CPUs temporarily incrementing and then decrementing the
 * refcount does not cause problems.  On receiving the page from
 * alloc_pages(), the refcount will be positive.
 *
 * If you allocate pages of order > 0, you can use some of the fields
 * in each subpage, but you may need to restore some of their values
 * afterwards.
 *
 * SLUB uses cmpxchg_double() to atomically update its freelist and
 * counters.  That requires that freelist & counters be adjacent and
 * double-word aligned.  We align all struct pages to double-word
 * boundaries, and ensure that 'freelist' is aligned within the
 * struct.
 */

struct page {
        unsigned long flags;            /* Atomic flags, some possibly
                                         * updated asynchronously */
        /*
         * Five words (20/40 bytes) are available in this union.
         * WARNING: bit 0 of the first word is used for PageTail(). That
         * means the other users of this union MUST NOT use the bit to
         * avoid collision and false-positive PageTail().
         */
        union {
                struct {        /* Page cache and anonymous pages */
                        /**
                         * @lru: Pageout list, eg. active_list protected by
                         * lruvec->lru_lock.  Sometimes used as a generic list
                         * by the page owner.
                         */
                        struct list_head lru;
                        /* See page-flags.h for PAGE_MAPPING_FLAGS */
                        struct address_space *mapping;
                        pgoff_t index;          /* Our offset within mapping. */
                        /**
                         * @private: Mapping-private opaque data.
                         * Usually used for buffer_heads if PagePrivate.
                         * Used for swp_entry_t if PageSwapCache.
                         * Indicates order in the buddy system if PageBuddy.
                         */
                        unsigned long private;
                };
                struct {        /* page_pool used by netstack */
                        /**
                         * @pp_magic: magic value to avoid recycling non
                         * page_pool allocated pages.
                         */
                        unsigned long pp_magic;
                        struct page_pool *pp;
                        unsigned long _pp_mapping_pad;
                        unsigned long dma_addr;
                        union {
                                /**
                                 * dma_addr_upper: might require a 64-bit
                                 * value on 32-bit architectures.
                                 */
                                unsigned long dma_addr_upper;
                                /**
                                 * For frag page support, not supported in
                                 * 32-bit architectures with 64-bit DMA.
                                 */
                                atomic_long_t pp_frag_count;
                        };
                };

First 워드

• flags
  • 페이지 플래그

 

1) 페이지 캐시 또는 anonymous 페이지

• _lru
  • LRU 리스트에 연결될 때 사용한다.
• *mapping
  • 유저 매핑 관련 포인터가 담기며 하위 2비트는 이의 용도를 구분하는 플래그로 사용한다.
    • 페이지 캐시로 사용되는 경우 address_space 구조체를 가리킨다.
      • non-lru movable 페이지들은 address_space 구조체 포인터에 PAGE_MAPPING_MOVABLE 플래그를 추가하여 관리한다.
        • 예) zram, balloon 드라이버
    • 유저용 가상 메모리 페이지(anonymous page)인 경우 CONFIG_KSM 커널 옵션 사용 여부에 따라 달라진다.
      • KSM 커널 옵션 사용하지 않을 때에는 PAGE_MAPPING_ANON(1) 플래그만 추가되고 anon 매핑 영역인 anon_vma 구조체 포인터를 가리킨다.
      • KSM 커널 옵션을 사용하는 경우에는 PAGE_MAPPING_ANON(1) 및 PAGE_MAPPING_MOVABLE(2) 플래그를 추가하고, KSM용 private 구조체 포인터를 가리킨다.
• index
  • 매핑 영역안의 offset 값이 담긴다.
• private
  • 매핑에 사용하는 private 데이터가 담긴다.
    • Private 페이지에서 buffer_heads를 위해 사용된다.
    • 스웝 페이지 캐시의 swp_entry_t를 위해 사용된다.
    • 버디 페이지의 order가 담긴다.

 

2) netstack에서 사용하는 page_pool 페이지

• pp_magic
  • 네트워크 page_pool에서 사용하였음을 식별할 목적이다.
• *pp
  • page_pool 구조체를 가리키는 포인터이다.
• _pp_mapping_pad
  • padding 용도이며 실제 사용되지 않는다.
• dma_addr
  • dma 주소
• dma_addr_upper
  • 32비트 시스템에서 64비트 DMA를 사용할 때 dma 주소의 하위 32비트는 위의 dma_addr에 저장하고, 상위 32비트는 이 멤버에 저장한다.
• pp_frag_count
  • atomic 으로 관리되는 frag 카운터이다.
  • 64비트 DMA를 사용하는 32비트 시스템에서는 지원하지 않는다.

 

include/linux/mm_types.h -2/3-

                struct {        /* slab, slob and slub */
                        union {
                                struct list_head slab_list;     /* uses lru */
                                struct {        /* Partial pages */
                                        struct page *next;
#ifdef CONFIG_64BIT
                                        int pages;      /* Nr of pages left */
                                        int pobjects;   /* Approximate count */
#else
                                        short int pages;
                                        short int pobjects;
#endif
                                };
                        };
                        struct kmem_cache *slab_cache; /* not slob */
                        /* Double-word boundary */
                        void *freelist;         /* first free object */
                        union {
                                void *s_mem;    /* slab: first object */
                                unsigned long counters;         /* SLUB */
                                struct {                        /* SLUB */
                                        unsigned inuse:16;
                                        unsigned objects:15;
                                        unsigned frozen:1;
                                };
                        };
                };
                struct {        /* Tail pages of compound page */
                        unsigned long compound_head;    /* Bit zero is set */

                        /* First tail page only */
                        unsigned char compound_dtor;
                        unsigned char compound_order;
                        atomic_t compound_mapcount;
                        unsigned int compound_nr; /* 1 << compound_order */
                };
                struct {        /* Second tail page of compound page */
                        unsigned long _compound_pad_1;  /* compound_head */
                        atomic_t hpage_pinned_refcount;
                        /* For both global and memcg */
                        struct list_head deferred_list;
                };

3) 슬랩(slab, slob, slub) 페이지

• slab_list
  • LRU 리스트에 연결될 때 사용한다.
• *next
  • partial 페이지를 관리한다.
• pages
  • partial 페이지 수가 담긴다.
    • 자신을 포함하여 뒤(next)로 연결되어 있는 slub page들의 수가 담긴다.
• pobjects
  • 대략적인 object 수
    • 정확하지는 않지만 대략적으로 내 slub page를 포함한 다음(next) slub page들의 총 free object 수가 담긴다.
    • 이 카운터는 종종 free 되는 object들로 인해 정확히 산출되지 않는다
• *slab_cache
  • 연결된 슬랩 캐시를 가리킨다.
• *freelist
  • free 오브젝트들이 대기하는 리스트이다.
• *s_mem
  • slab:의 first object를 가리킨다.
• counters
  • 아래 32바이트를 한꺼번에 access할 때 사용한다.
  • inuse:16
    • 사용 중인 object 수.
  • objects:15
    • 슬랩이 관리하는 object 수
  • frozen:1
    • per-cpu로 관리하고 있는 슬랩 페이지 여부를 가리킨다.

 

4) Compound  tail 페이지들

참고로 Compound 페이지의 헤드 페이지(page[0])에는 PG_head 플래그가 설정된다.

• compound_head
  • compound 페이지의 헤더가 아닌 모든 tail 페이지에서 compound 헤더 페이지  디스크립터 포인터를 담고, bit0를 1로 설정한다.
• compound_dtor
  • 첫 번째 tail 페이지(page[1])에 compound 페이지 소멸자 구분 id를 담는다.
  • 다음과 같은 compound 페이지 소멸자 id들 중 하나를 담는다.
    • NULL_COMPOUND_DTOR
    • COMPOUND_PAGE_DTOR
    • HUGETLB_PAGE_DTOR
    • TRANSHUGE_PAGE_DTOR
• compound_order
  • 첫 번째 tail 페이지(page[1])에 compound 페이지의 order가 담긴다.
• compound_mapcount
  • 첫 번째 tail 페이지(page[1])에 매핑 카운트 수가 담긴다.

• _compound_pad_1
  • 사용하지 않는다.
• _compound_pad_2
  • 사용하지 않는다.
• deferred_list
  • 두 번째 tail 페이지(page[2])에서 huge 페이지를 분리시킬 때 곧바로 unmap하지 않고 잠시 유예시킬 때 사용한다.
  • 참고: thp: introduce deferred_split_huge_page()

 

include/linux/mm_types.h -3/4-

                struct {        /* Page table pages */
                        unsigned long _pt_pad_1;        /* compound_head */
                        pgtable_t pmd_huge_pte; /* protected by page->ptl */
                        unsigned long _pt_pad_2;        /* mapping */
                        union {
                                struct mm_struct *pt_mm; /* x86 pgds only */
                                atomic_t pt_frag_refcount; /* powerpc */
                        };
#if ALLOC_SPLIT_PTLOCKS
                        spinlock_t *ptl;
#else
                        spinlock_t ptl;
#endif
                };
                struct {        /* ZONE_DEVICE pages */
                        /** @pgmap: Points to the hosting device page map. */
                        struct dev_pagemap *pgmap;
                        void *zone_device_data;
                        /*
                         * ZONE_DEVICE private pages are counted as being
                         * mapped so the next 3 words hold the mapping, index,
                         * and private fields from the source anonymous or
                         * page cache page while the page is migrated to device
                         * private memory.
                         * ZONE_DEVICE MEMORY_DEVICE_FS_DAX pages also
                         * use the mapping, index, and private fields when
                         * pmem backed DAX files are mapped.
                         */
                };

                /** @rcu_head: You can use this to free a page by RCU. */
                struct rcu_head rcu_head;
        };

5) 페이지 테이블(pgd, pud, pmd, pte)용 페이지

• _pt_pad_1
  • 사용하지 않는다.
• pmd_huge_pte
  • huge용 pte 테이블을 가리키는 page 디스크립터 포인터가 담긴다.
• _pt_pad_2
  • 사용하지 않는다.
• *pt_mm
  • x86 pgds only
• *pt_frag_refcount
  • powerpc only
• *ptl or ptl
  • 페이지 테이블 spinlock이다.
  • spinlock_t 사이즈가 unsigned long 단위에 포함되는 경우 ptl을 사용하고 그렇지 않은 경우 spinlock_t를 할당하고 이를 가리킬 때 *ptl을 사용한다.

 

6) 존 디바이스 페이지

• *pgmap
  • 존 디바이스를 위한 dev_pagemap 구조체 포인터가 담긴다.
• hmm_data
  • hmm 디바이스 메모리용 드라이버 데이터가 담긴다.
• _zd_pad_1
  • 사용하지 않는다.

 

include/linux/mm_types.h -4/4-

        union {         /* This union is 4 bytes in size. */
                /*
                 * If the page can be mapped to userspace, encodes the number
                 * of times this page is referenced by a page table.
                 */
                atomic_t _mapcount;

                /*
                 * If the page is neither PageSlab nor mappable to userspace,
                 * the value stored here may help determine what this page
                 * is used for.  See page-flags.h for a list of page types
                 * which are currently stored here.
                 */
                unsigned int page_type;

                unsigned int active;            /* SLAB */
                int units;                      /* SLOB */
        };

        /* Usage count. *DO NOT USE DIRECTLY*. See page_ref.h */
        atomic_t _refcount;

#ifdef CONFIG_MEMCG
        unsigned long memcg_data;
#endif

        /*
         * On machines where all RAM is mapped into kernel address space,
         * we can simply calculate the virtual address. On machines with
         * highmem some memory is mapped into kernel virtual memory
         * dynamically, so we need a place to store that address.
         * Note that this field could be 16 bits on x86 ... 😉
         *
         * Architectures with slow multiplication can define
         * WANT_PAGE_VIRTUAL in asm/page.h
         */
#if defined(WANT_PAGE_VIRTUAL)
        void *virtual;                  /* Kernel virtual address (NULL if
                                           not kmapped, ie. highmem) */
#endif /* WANT_PAGE_VIRTUAL */

#ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
        int _last_cpupid;
#endif
} _struct_page_alignment;

기타-1

아래 _mapcount, page_type, active, units는 페이지 유형에 따라 선택되어 사용되는 union 타입으로 정의되어 있다.

•  _mapcount
  • 유저에서 사용하는 매핑 카운트
  • 여러 개의 유저 공간에 매핑될 때마다 카운터가 증가된다.
    • 공유 페이지를 여러 유저 프로세스에서 공유하는 경우 다중 매핑되어 그 수만큼 매핑 카운터가 증가한다.
• page_type
  • 유저 매핑 페이지 및 슬랩 페이지를 제외한 나머지 커널 페이지에서 페이지 타입을 지정하여 다음과 같은 플래그를 저장하여 사용한다.
    • PG_buddy
    • PG_ballon
    • PG_kmemcg
    • PG_table
• active
  • slab: 할당자에서 사용된다.
• units
  • slob: 할당자에서 사용된다.

기타-2

• _refcount
  • 참조 카운터로 사용자가 직접 액세스하면 안된다.
• memcg_data
  • CONFIG_MEMCG 커널 옵션이 사용된 시스템에서 메모리 cgroup을 사용할 때 사용할 obj_cgroup 구조체 포인터가 담기는데 할당 형태에 따라 다음과 같은 2 가지 플래그를 같이 사용한다.
    • MEMCG_DATA_OBJCGS
    • MEMCG_DATA_KMEM
• *virtual
  • WANT_PAGE_VIRTUAL 커널 옵션을 사용하는 경우 highmem을 사용하는 일부 32비트 아키텍처에서 highmem 페이지가 커널 주소 공간에 매핑된 경우 매핑된 커널 가상 주소가 담긴다.
  • ARM32의 경우 HASHED_PAGE_VIRTUAL을 사용한다.
    • highmem 페이지를 매핑 시 page_address_map 구조체를 별도로 할당하여 사용하므로 이 멤버를 사용하지 않는다.
  • 64비트 시스템들은 highmem을 사용하므로 이 멤버를 사용할 필요 없다.
• _last_cpupid
  • 페이지의 flags 멤버에 cpu 및 pid를 담아야 하는데 32비트 시스템에서 32비트에 모두 포함시킬 수 없는 경우가 있다. 이러한 경우 LAST_CPUPID_NOT_IN_PAGE_FLAGS 커널 옵션을 사용하여 이 멤버에 마지막 사용한 cpu 및 pid를 담는다. 이들은 NUMA 밸런싱을 위해 사용된다.
  • 64비트 시스템들은 flags 멤버를 사용하여 last cpu 및 pid 정보를 저장하므로 이 멤버를 사용할 필요 없다.

 

참고

• Memory Model -1- (Basic) | 문c
• Memory Model -2- (mem_map) | 문c – 현재 글
• Memory Model -3- (Sparse Memory) | 문c
• Memory Model -4- (APIs) | 문c
• ZONE 타입 | 문c
• bootmem_init | 문c
• zone_sizes_init() | 문c
• NUMA -1- (ARM64 초기화) | 문c
• build_all_zonelists() | 문c

 

• Memory: the flat, the discontiguous, and the sparse(2019) | LWN.net
• Generic page-pool recycle facility? (2016) | Jesper Dangaard Brouer – 다운로드 pdf

<kernel v5.10>

Fixmap 주요 용도

고정 매핑 영역(이하 fixmap 영역)은 컴파일 타임에 가상 주소가 결정(fix)되는 공간이다. 따라서 주로 다이나믹 매핑 서브 시스템(vmap 등)이 활성화되기 전에 매핑이 필요할 때 fixmap을 사용한다. 예를 들어, 콘솔 디바이스를 정식 초기화하기 전에 우선 사용하기 위해 이 공간에 임시 매핑한다. 런타임 시에도 커널 코드를 변경하거나 페이지 테이블의 갱신이 필요할 때 등의 용도로 사용한다.
fixmap은 용도별로 여러 블록으로 나뉜다. 가상 주소는 컴파일 타임에 결정되고, 물리 주소는 fixmap용 API를 사용하여 런타임 시에(부팅 타임 포함) 매핑하여 사용한다. 가상 주소 매핑(vmap)이 활성화되기 전에 소규모의 특정 자원들이 이러한 고정 매핑 주소 공간을 사용한다.

 

아키텍처 및 커널 버전에 따라 용도가 조금씩 다르지만 주로 사용하는 용도는 다음과 같다. 그 외의 용도는 Fixmap 슬롯 분류에서 추가 설명한다.

1) io 디바이스 early 매핑

• ioremap() 함수를 사용할 수 없는 이른 부트업 타임에 디바이스를 매핑할 수 있도록 아래와 같이 두 가지 방법으로 지원한다.
  • 컴파일 타임에 static하게 설정한 디바이스를 고정 매핑 시 사용한다. (early console 등)
  • 정규 디바이스 매핑(ioremap)을 사용할 수 없는 부트업 초반 러닝 타임에 early_ioremap() 함수를 통해 디바이스를 fixmap 가상 주소 영역에 임시로 매핑하여 사용할 수 있다.
    • 총 7회, 각각 256K 매핑 가능

2) highmem 물리 메모리의 커널 매핑

• ARM32 커널의 경우 물리 영역의 highmem 페이지를 cpu id 별로 할당된 fixmap 가상 주소 영역에 매핑하여 사용한다.
  • stack based kmap_atomic
    • 초기 매핑할 수 있는 index slot은 기존에는 cpu id와 사용 타입에 따라 고정되었는데 현재는 cpu id에 KM_TYPE_NR(ARM=20) 수 만큼 스택과 같은 방법으로 push/pop을 이용하여 운영된다.
      • 즉 cpu 마다 20개의 매핑 슬롯이 배정된다.
    • 참고: mm: stack based kmap_atomic()
  • kmap_atomic() 함수를 사용하여 highmem 페이지를 현재 cpu에 해당하는 fixmap 영역을 사용하여 매핑을 한다. 이미 kmap 영역에 매핑이 된 경우 해당 가상 주소를 리턴한다.
  • ZONE_HIGHMEM은 커널에서 몇 가지 매핑 방법을 사용하여 항상 매핑과 언매핑을 반복 사용하며 사용하기 때문에 access 속도가 매핑을 위한 overhead가 발생하여 항상 pre 매핑된 ZONE_NORMAL에 비해  느린 성능을 보여준다. 물론 kernel과 다르게 user level 에서는 각 task 마다 매우 방대한 user address space(설정에 따라 1G, 2G 또는 3G)의 공간에 매핑하여 사용한다.
• 64비트 시스템은 가상 주소 공간이 무척 크므로 시스템 내의 모든 물리 메모리를 모두 매핑할 수 있다. 따라서 이러한 경우에는 highmem을 운용할 필요가 없다.

3) 커널 코드 변경

• Read only 설정된 커널 코드를 변경할 때 fixmap 가상 주소 영역을 임시로 사용한다.

 

다른 매핑  방법과 간단한 비교

• vmap
  • 장시간 여러 페이지를 매핑하여 사용할 수 있고 꽤 큰 vmalloc address space에 매핑을 한다.
    • ARM32
      • 240M 공간
    • ARM64
      • CONFIG_VM_BITS 크기 마다 다르며 VM 공간의 절반에서 일부 vmemmap, pci io, fixmap, kimage, module image 영역등을 제외한 공간으로 거의 VM 공간의 절반이라고 생가하면 된다.
      • 예를 들어 CONFIG_VM_BITS=39를 사용하는 경우 VM 크기는 512G이다. 이 중 vmalloc 공간은 약 246G 정도된다.
• kmap
  • kmap address space에 일정 시간 동안 매핑을 하여 사용한다. 매핑이 완료되면 스케쥴되어 다른 태스크로 바뀌더라도 매핑을 유지한다.
    • ARM32
      • 2M 공간
• fixmap
  • highmem 페이지에 대해 아주 극히 짧은 시간 매핑하여 사용할 수 있고 fixmap address space에 매핑을 한다. sleep 되지 않아 interrupt context에서 사용될 수 있다.
    • 스케쥴되어 다른 태스크로 바뀌기 전에 unmap 되어야 한다.
  • 다른 io 영역 등을 부트업 타임에 고정매핑하여 사용한다.
  • ARM32
    • 기존 2M -> 3M 공간으로 커졌다.
  • ARM64
    • 커널 버전과 커널 옵션마다 다르지만 현재 약 6M 공간

 

---

Fixmap 가상 주소 영역

• fixmap 가상 주소 영역은 아키텍처마다 위치가 다르고 크기도 다르다.
  • ARM32
    • 현재 3M의 가상 주소 공간을 사용하여 768개의 페이지에 높은 주소부터 아래로 인덱스 슬롯(0 ~ 767)을 붙여 사용한다.
    • FIXADDR_START(0xffc0_0000) ~ FIXADDR_END(0xfff0_0000) 까지 3M 영역을 사용한다.
      • 기존에는 0xffc0_0000 ~ 0xffe0_0000 까지 2M 영역을 사용했었다.
      • 참고: ARM: expand fixmap region to 3MB
    • FIXADDR_TOP 영역은 FIXADDR_END – PAGE_SIZE(4K ) 이다.
      • 인덱스 지정은 FIXADDR_TOP(0xffef_f000)이 0번 인덱스로 아래 방향으로 인덱스 번호가 증가된다.
      • 인덱스 번호는 0부터 최대 0x2ff (767)을 지정할 수 있다.
  • ARM64
    • 약 6M의 가상 주소 공간을 사용하고 높은 주소부터 아래로 인덱스 슬롯을 붙여 사용한다.

 

커널 버전별 커널 주소 공간 Layout

다음 그림은 커널 v5.17~ 커널 주소 공간 layout을 보여준다. (VA_BITS=48)

• 128M로 제한되었던 bpf 영역의 제한이 풀리면서 vmalloc 공간을 사용할 수 있게 되었다.
  • arm64/bpf: Remove 128MB limit for BPF JIT programs (2021, v5.17-rc1)

 

다음 그림은 커널 v5.11~ 커널 주소 공간 layout을 보여준다. (VA_BITS=48)

• vmemmap, pci, fixmap 영역이 일부 조정되었다.
  • arm64: mm: make vmemmap region a projection of the linear region (2020, v5.11-rc1)
  • arm64: mm: tidy up top of kernel VA space (2020, v5.11-rc1)

 

다음 그림은 커널 v5.4 부터 v5.10 까지의 커널 주소 공간 layout을 보여준다. (VA_BITS=48)

• 커널 v5.4부터 커널 영역의 절반이 flip된 것을 확인할 수 있다. VA_START 대신 PAGE_END로 이름을 변경하였다.
  • 참고: arm64: memory: rename VA_START to PAGE_END (2019, v5.4-rc1)
• 커널 v5.4부터 부트 타임에 KASAN의 shadow 사이즈를 변경할 수 있도록 1:1 매핑 영역을 아래로 내렸다.
  • 참고: arm64: mm: Flip kernel VA space (2019, v5.4-rc1)
• 32T 크기의 KASAN 영역은 생략하였으나 이 옵션을 사용하는 경우 bpf, module 및 vmalloc 시작이 그 만큼 위로 올라간다. (vmalloc의 끝은 동일하다)
• 커널 옵션에 따라 fixmap의 위치가 페이지 단위로 다를 수 있다.

 

다음 그림은 커널 ~v5.3까지의 커널 주소 공간 layout을 보여준다. (VA_BITS=48)

• vmemmap 공간은 컴파일 옵션에 따라 달라지는 page 디스크립터(struct page) 사이즈에 따라 크기가 달라진다
  • 64 바이트 이하인 경우 2T 영역을 사용한다.
  • 64 바이트를 초과하는 경우 4T 영역을 사용한다.

 

---

Fixmap 인덱스 슬롯

• fixmap 인덱스 슬롯 번호에 따라 가상 주소가 고정되어 있다.
  • 예) ARM32
    • index=0 -> vaddr=0xffef_f000 (FIXADDR_TOP)
    • index=1 -> vaddr=0xffef_e000
    • …
    • index=767 -> vaddr=0xffc0_0000 (FIXADDR_START)

 

특정 페이지 매핑 예)

물리 주소 0x4000_0000로 시작하는 1 페이지를 fixmap 1번 슬롯 인덱스에 매핑한다.

• set_fixmap(1, 0x4000_0000)

 

Fixmap 슬롯 분류

Fixmap은 아키텍처 및 커널 버전에 따라 여러 가지 용도로 슬롯을 나누어 제공된다.

• HOLE
  • ARM32의 경우 사용하지 않는다.
  • ARM64의 경우 디버깅 목적으로 1 개의 슬롯이 제공되며, 예비 엔트리 페이지로 현재 사용하지 않는다.
  • 커널 v3.19-rc1에서 추가되었다.
    • 참고: arm64: Add FIX_HOLE to permanent fixed addresses
• FDT
  • ARM32의 경우 사용하지 않는다.
  • ARM64의 경우 4M의 디바이스 트리(FDT)를 커버하는 슬롯을 제공한다.
    • FDT는 최대 2M이지만 2M 단위의 align을 사용하기 때문에 최대 4M의 영역이 필요하다.
  • 커널 v4.2-rc1에서 추가되었다.
    • 참고: arm64: use fixmap region for permanent FDT mapping
•  EARLYCON
  • 시리얼 디바이스를 콘솔로 사용할 목적으로 정규 매핑하기 전 입출력을 위해 1개의 인덱스 슬롯을 사용한다. (early console)
  • 이 영역은 2015년 8월 kernel v4.3-rc1에 추가되었다.
    • 참고: ARM: 8415/1: early fixmap support for earlycon
• KMAP
  • 32비트 시스템에서만 사용되는 highmem 물리 메모리 영역을 매핑할 때 사용되는 공간으로 cpu 수(NR_CPUS)에 따라 사용되는 인덱스 슬롯이 다르다.
    • Fixmap이 처음 소개되었을 때 사용하였다.
  • ARM32의 경우 cpu 수에 따라 20개씩 인덱스 슬롯이 주어진다.
    • 기존 16개에서 20개로 증가하였다.
  • x86_32의 경우 cpu 수에 따라 41개씩 인덱스 슬롯이 주어진다.
• TEXT_POKE
  • 커널 코드, kprobes, static key 등을 사용 시 read only 커널 코드가 변경되는데 이러한 코드를 이곳 한 두개의 슬롯을 사용하여 잠시 매핑 후 변경한다.
  • ARM32의 경우 2개의 슬롯을 사용한다.
  • ARM64의 경우 1개의 슬롯을 사용한다.
• APEI_GHES
  • 현재 ARM64 및 X86_64에서 GHES 드라이버를 사용하는 경우 2 개의 슬롯이 주어진다.
  • GHES 드라이버가 ioremap_page_range() 함수가 sleep될 수 있으므로 irq context에서 사용할 목적으로 sleep 되지 않도록 fixmap을 이용하여 사용한다.
  • 커널 v4.15-rc에서 추가되었다.
    • 참고: ACPI / APEI: Replace ioremap_page_range() with fixmap
  • 커널 v5.1에서 추가된내용이다.
    • 참고: firmware: arm_sdei: Add ACPI GHES registration helper
• ENTRY_TRAMP
  • 보안을 위해 유저 스페이스에서 커널 위치를 감추는 KASLR(Kernel Address Sanitizer Location Randomization) 기술이 채용되었다. 또한 유저 스페이스에서 커널 영역을 접근하지 못하도록 커널 페이지 테이블을 별도로 준비하여 운영되는 KPTI(Kernel Page Table Isolation, aka KAISER)를 위한 별도의 최상위 페이지 테이블(pgd)이 이 ENTRY_TRAMP 페이지에서 사용된다. 이러한 옵션을 사용하는 커널은 커널과 유저 전환 시마다 TLB 플러시를 해야 하므로 약 5%의 성능이 다운된다. 미래에 나올 cpu 들은 유저 스페이스에서 커널 스페이의 액세스를 완전히 분리하는 기술을 사용하여 이 옵션을 사용하지 않고도 성능을 저하시키지 않게 설계된다고 한다.
  • 커널 v4.16-rc1에서 추가되었다.
    • KAISER: hiding the kernel from user space | LWN.net
    • The current state of kernel page-table isolation | LWN.net
    • arm64: mm: Map entry trampoline into trampoline and kernel page tables
    • arm64: kaslr: Put kernel vectors address in separate data page
• BTMAPS
  • 정규 ioremap()을 사용할 수 없는 이른 부트업 타임에 early_ioremap()을 통해 디바이스들을 임시 매핑하여 사용하는 곳이다.
  • 최대 7 번의 매핑을 할 수 있으며, 각각은 256K를 사용할 수 있다.
  • 커널 v3.15-rc1에서 추가되었다.
    • 참고: arm64: add early_ioremap support
• FIX_PTE, FIX_PMD, FIX_PUD, FIX_PGD
  • 런타임에 커널 페이지 테이블을 생성 시 TLB에 문제 없이 적용할 목적으로 atomic하게 처리하기 위해 사용되며 각각 1개씩 총 4개의 인덱스 슬롯을 사용한다.
  • 커널 페이지 테이블은 읽기 전용으로 변경하였고, 페이지 테이블 엔트리를 수정할 때마다 이 영역을 사용하여 엔트리를 수정한다.
  • 커널 v.4.6-rc1에서 추가되었다.
    • 참고: arm64: mm: add functions to walk tables in fixmap

 

fixed_address – ARM64

arch/arm64/include/asm/fixmap.h

/*
 * Here we define all the compile-time 'special' virtual
 * addresses. The point is to have a constant address at
 * compile time, but to set the physical address only
 * in the boot process.
 *
 * Each enum increment in these 'compile-time allocated'
 * memory buffers is page-sized. Use set_fixmap(idx,phys)
 * to associate physical memory with a fixmap index.
 */

enum fixed_addresses {
        FIX_HOLE,

        /*
         * Reserve a virtual window for the FDT that is 2 MB larger than the
         * maximum supported size, and put it at the top of the fixmap region.
         * The additional space ensures that any FDT that does not exceed
         * MAX_FDT_SIZE can be mapped regardless of whether it crosses any
         * 2 MB alignment boundaries.
         *
         * Keep this at the top so it remains 2 MB aligned.
         */
#define FIX_FDT_SIZE            (MAX_FDT_SIZE + SZ_2M)
        FIX_FDT_END,
        FIX_FDT = FIX_FDT_END + FIX_FDT_SIZE / PAGE_SIZE - 1,

        FIX_EARLYCON_MEM_BASE,
        FIX_TEXT_POKE0,

#ifdef CONFIG_ACPI_APEI_GHES
        /* Used for GHES mapping from assorted contexts */
        FIX_APEI_GHES_IRQ,
        FIX_APEI_GHES_SEA,
#ifdef CONFIG_ARM_SDE_INTERFACE
        FIX_APEI_GHES_SDEI_NORMAL,
        FIX_APEI_GHES_SDEI_CRITICAL,
#endif
#endif /* CONFIG_ACPI_APEI_GHES */

#ifdef CONFIG_UNMAP_KERNEL_AT_EL0
        FIX_ENTRY_TRAMP_DATA,
        FIX_ENTRY_TRAMP_TEXT,
#define TRAMP_VALIAS            (__fix_to_virt(FIX_ENTRY_TRAMP_TEXT))
#endif /* CONFIG_UNMAP_KERNEL_AT_EL0 */
        __end_of_permanent_fixed_addresses,

        /*
         * Temporary boot-time mappings, used by early_ioremap(),
         * before ioremap() is functional.
         */
#define NR_FIX_BTMAPS           (SZ_256K / PAGE_SIZE)
#define FIX_BTMAPS_SLOTS        7
#define TOTAL_FIX_BTMAPS        (NR_FIX_BTMAPS * FIX_BTMAPS_SLOTS)

        FIX_BTMAP_END = __end_of_permanent_fixed_addresses,
        FIX_BTMAP_BEGIN = FIX_BTMAP_END + TOTAL_FIX_BTMAPS - 1,

        /*
         * Used for kernel page table creation, so unmapped memory may be used
         * for tables.
         */
        FIX_PTE,
        FIX_PMD,
        FIX_PUD,
        FIX_PGD,

        __end_of_fixed_addresses
};

fixmap은 크게 두 영역으로 나뉘어 사용하고, 다음과 같은 특징을 가진다.

• __end_of_permanent_fixed_addresses
  • 부팅 후 매핑을 해제하지 않는 영구 매핑 공간이다.
• __end_of_fixed_addresses
  • fixmap의 마지막이며, __end_of_permanent_fixed_addresses 이후의 영역은 매핑과 언매핑이 가능한 공간이다.

 

다음 그림은 ARM64 fixmap 블럭들을 보여준다.

 

fixed_address – ARM32

arch/arm/include/asm/fixmap.h

enum fixed_addresses {
        FIX_EARLYCON_MEM_BASE,
        __end_of_permanent_fixed_addresses,

        FIX_KMAP_BEGIN = __end_of_permanent_fixed_addresses,
        FIX_KMAP_END = FIX_KMAP_BEGIN + (KM_TYPE_NR * NR_CPUS) - 1,

        /* Support writing RO kernel text via kprobes, jump labels, etc. */
        FIX_TEXT_POKE0,
        FIX_TEXT_POKE1,

        __end_of_fixmap_region,

        /*
         * Share the kmap() region with early_ioremap(): this is guaranteed
         * not to clash since early_ioremap() is only available before
         * paging_init(), and kmap() only after.
         */
#define NR_FIX_BTMAPS           32
#define FIX_BTMAPS_SLOTS        7
#define TOTAL_FIX_BTMAPS        (NR_FIX_BTMAPS * FIX_BTMAPS_SLOTS)

        FIX_BTMAP_END = __end_of_permanent_fixed_addresses,
        FIX_BTMAP_BEGIN = FIX_BTMAP_END + TOTAL_FIX_BTMAPS - 1,
        __end_of_early_ioremap_region
};

 

다음 그림은 ARM32 fixmap 블럭들을 보여준다.

 

---

초기화

early_fixmap_init() – ARM64

dynamic 매핑이 활성화되기 이전에 일부 고정된 가상 주소 영역에 특정 물리 주소를 매핑 시켜 사용할 수 있는 fixmap 가상 주소 영역을 먼저(early) 사용하려 한다. 이러한 fixmap 가상 주소 영역을 지원하기 위해 pgd 테이블의 fixmap 가상 주소에 해당하는 엔트리에 3개의 static 페이지 테이블 bm_pud[], bm_pmd[] 및 bm_pte[]를 연결 구성하여 fixmap 가상 주소 영역을 사용할 수 있는 완전한 매핑 테이블을 준비한다. 정규 매핑 함수 및 정규 메모리 할당자를 사용할 수 없으므로 3개의 페이지 테이블은 컴파일 타임에 static하게 생성하여 활용한다. 참고로 early_fixmap_init() 함수에서는 전체 fixmap 영역 중 FDT를 제외한 아랫 부분 2M를 먼저 커버하기 위해 매핑합니다.

 

arch/arm64/mm/mmu.c

/*
 * The p*d_populate functions call virt_to_phys implicitly so they can't be used
 * directly on kernel symbols (bm_p*d). This function is called too early to use
 * lm_alias so __p*d_populate functions must be used to populate with the
 * physical address from __pa_symbol.
 */

void __init early_fixmap_init(void)
{
        pgd_t *pgdp;
        p4d_t *p4dp, p4d;
        pud_t *pudp;
        pmd_t *pmdp;
        unsigned long addr = FIXADDR_START;

        pgdp = pgd_offset_k(addr);
        p4dp = p4d_offset(pgdp, addr);
        p4d = READ_ONCE(*p4dp);
        if (CONFIG_PGTABLE_LEVELS > 3 &&
            !(p4d_none(p4d) || p4d_page_paddr(p4d) == __pa_symbol(bm_pud))) {
                /*
                 * We only end up here if the kernel mapping and the fixmap
                 * share the top level pgd entry, which should only happen on
                 * 16k/4 levels configurations.
                 */
                BUG_ON(!IS_ENABLED(CONFIG_ARM64_16K_PAGES));
                pudp = pud_offset_kimg(p4dp, addr);
        } else {
                if (p4d_none(p4d))
                        __p4d_populate(p4dp, __pa_symbol(bm_pud), PUD_TYPE_TABLE);
                pudp = fixmap_pud(addr);
        }
        if (pud_none(READ_ONCE(*pudp)))
                __pud_populate(pudp, __pa_symbol(bm_pmd), PMD_TYPE_TABLE);
        pmdp = fixmap_pmd(addr);
        __pmd_populate(pmdp, __pa_symbol(bm_pte), PMD_TYPE_TABLE);

        /*
         * The boot-ioremap range spans multiple pmds, for which
         * we are not prepared:
         */
        BUILD_BUG_ON((__fix_to_virt(FIX_BTMAP_BEGIN) >> PMD_SHIFT)
                     != (__fix_to_virt(FIX_BTMAP_END) >> PMD_SHIFT));

        if ((pmdp != fixmap_pmd(fix_to_virt(FIX_BTMAP_BEGIN)))
             || pmdp != fixmap_pmd(fix_to_virt(FIX_BTMAP_END))) {
                WARN_ON(1);
                pr_warn("pmdp %p != %p, %p\n",
                        pmdp, fixmap_pmd(fix_to_virt(FIX_BTMAP_BEGIN)),
                        fixmap_pmd(fix_to_virt(FIX_BTMAP_END)));
                pr_warn("fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
                        fix_to_virt(FIX_BTMAP_BEGIN));
                pr_warn("fix_to_virt(FIX_BTMAP_END):   %08lx\n",
                        fix_to_virt(FIX_BTMAP_END));

                pr_warn("FIX_BTMAP_END:       %d\n", FIX_BTMAP_END);
                pr_warn("FIX_BTMAP_BEGIN:     %d\n", FIX_BTMAP_BEGIN);
        }
}

fixmap 가상 주소 영역을 활성화한다.

• 코드 라인 7에서 fixmap 영역의 가장 낮은 가상 주소를 addr에 대입한다.
  • arm32와 달리 arm64에서는 fixmap의 상위 주소에 4M에 해당하는 DTB가 위치하고 처음에 사용하려고 하는 대부분의 항목들은 fixmap 영역의 아래에 위치하므로 주소가 낮은 부분을 먼저 활성화할 계획이다.
• 코드 라인 9~11에서 가상 주소 addr에 해당하는 p4d 엔트리 값을 읽어온다.
  • pgd 테이블에서 pgd 엔트리 포인터인 pgdp를 알아오고, 이어서 다음 레벨인 p4dp를 알아온다음, 이 포인터를 통해 p4d 엔트리 값을 읽어 p4d에 대입한다.
• 코드 라인 12~20에서 페이지 테이블 변환 레벨이 4단계 이상이고, 페이지 크기로 16K를 사용하는 커널인 경우 p4d 엔트리가 최대 2개 밖에 존재하지 않는다. 그중 하나는 커널 메모리용 가상 주소 공간이고, 나머지 하나는 커널에서 여러 용도로 사용되는 몇 가지 공간 주소를 모두 포함하여 사용되며 그중에는 커널 이미지 영역이나 fixmap 영역도 포함된다. 즉, 커널 이미지와 fixmap 영역은 1개의 bm_pud[ ] 테이블에 존재하게 된다. 이러한 경우 bm_pud[ ] 페이지 테이블이 커널 이미지 용도로 이미 활성화되어 사용 중이므로 fixmap을 위해 다시 활성화할 필요가 없어진다. 따라서 곧바로 fixmap 시작 주소에 해당하는 pud 엔트리 포인터를 구한다.
  • 이 조건은 4단계 + 16K 페이지를 사용하는 것만 허용하므로 그 외의 경우 버그 메시지를 출력한다.
• 코드 라인 21~25에서 그 외의 경우 bm_pud[ ] 테이블은 fixmap 영역 및 커널 이미지 영역과 같이 공유하지 않고 fixmap 영역 위주로 사용한다. 그래서 fixmap 영역을 사용하기 위해 bm_pud[ ] 테이블을 pgd 엔트리와 연결하여 활성화한 후에 fixmap 시작 주소에 해당하는 pud 엔트리 포인터를 구한다.
  • 4 단계 + 4K 페이지 및 3단계의 모든 페이지(4K, 16K, 64K)를 포함한다.
• 코드 라인 26~27에서 pud에 연결된 pmd 테이블이 없는 경우 bm_pmd[] 테이블을 사용하여 연결한다.
• 코드 라인 28에서 addr 주소에 해당하는 pmd 엔트리 포인터를 알아온다.
• 코드 라인 29에서 pmd에 연결된 pte 테이블이 없는 경우 bm_pte[] 테이블을 사용하여 연결한다.
  • 전체 fixmap 영역 중 FDT를 제외한 아랫부분 2M에 해당하는 부분을 매핑하여 커버합니다.
• 코드 라인 38~51에서 early_ioremap() 함수에서 사용하는 btmap 영역의 시작과 끝에 해당하는 pud 테이블의 pmd 엔트리 주소 값들이 위에서 읽어온 pmd 엔트리 주소 값과 다른 경우 경고 메시지를 출력한다.

 

bm_pte, bm_pmd, bm_pud는 fixmap에 대한 페이지 테이블로 별도의 페이지 할당 없이 커널 빌드 시 생성되는 static 배열을 이용한다

arch/arm64/mm/mmu.c

static pte_t bm_pte[PTRS_PER_PTE] __page_aligned_bss;
static pmd_t bm_pmd[PTRS_PER_PMD] __page_aligned_bss __maybe_unused;
static pud_t bm_pud[PTRS_PER_PUD] __page_aligned_bss __maybe_unused;

 

커널 이미지의 두 가상 공간 매핑

• 커널 이미지(kimage)는 부트업 타임에 두 개의 가상 공간에 매핑된다.
  • 1) linear mapping 가상 공간
    • 커널이 로드되어 있는 DRAM 전체가 매핑되는 공간이다.
    • 예) 0xfff_0000_0000_0000~ (4K, 4레벨 페이지)
  • 2) kimage 가상 공간
    • 커널 이미지만 매핑된 공간이다.
    • 예) 0xffff_8000_1000_0000~ (4K, 4레벨 페이지, KASLR=n)

 

가상 주소와 물리 주소의 변환 APIs

• 다음 API는 1)번의 lm(linear mapping) 가상 주소와 물리 주소의 변환에 사용한다.
  • 사용 제한
    • paging_init() 함수를 통해 리니어 매핑이 완료된 후 사용 가능하다.
    • CONFIG_DEBUG_VIRTUAL  커널 옵션을 사용하여 lm 가상 주소를 사용하지 않는 경우에 경고 메시지를 출력한다.
  • virt_to_phys(), __virt_to_phys(), __va()
  • phys_to_virt(), __phys_to_virt(), __pa()
  • lm_alias()
    • 커널 심볼에 대한 lm 가상 주소로 변환한다.
• 다음 API는 2)번의 커널 심볼 가상 주소와 물리 주소의 변환에 사용한다.
  • 사용 제한
    • 없음
  • __kimg_to_phys()
  • __phys_to_kimg()
  • __pa_symbol()
    • 커널 심볼 가상 주소를 물리 주소로 변환한다.
• 다음 API는 1)번의 lm(linear mapping) 가상 주소와 페이지의 변환에 사용한다.
  • 사용 제한
    • 페이지 디스크립터 배열로 구성된 vmemmap이 활성화된 후 사용 가능하다.
  • virt_to_page()
  • page_to_virt()

 

__p*d_populate() 함수 사용

early_fixmap_init() 함수에서 p*d_populate() 함수 대신 __p*d_populate() 함수를 사용하는 이유를 알아본다.

• p*d_populate() 함수는 세 번째 인자로 연결할 테이블의 가상 주소를 사용한다.
  • p*d_populate() 함수는 내부에서 __pa() 함수를 사용하여 리니어용 가상 주소를 물리 주소로 변환한다. 그런데 __pa() 함수는 아직은 부트 업 초반 시점이라 리니어 매핑이 완료되지 않아서 사용할 수 없다. 따라서 bm_pud[] 등의 커널 심볼을 가상 주소 인자로 사용할 수 없어 이 함수를 사용하지 못한다.
• __p*d_populate() 함수는 두 번째 인자로 연결할 테이블의 물리 주소를 사용한다.
  • 커널 심볼에 한하여 물리 주소로 바꿔주는 별도의 함수가 있다. __pa_symbol() 함수를 사용하여 커널 심볼 가상 주소를 물리 주소로 변환할 수 있다. 이렇게 변환한 물리 주소를 사용하여 __p*d_populate() 함수를 사용한다.
  • 참고
    • arm64: mm: restrict virt_to_page() to the linear mapping (2016, v4.7-rc1)
    • arm64: Use __pa_symbol for kernel symbols (2017, v4.11-rc1)
    • arm64: Add support for CONFIG_DEBUG_VIRTUAL (2017, v4.11-rc1)
    • mm: Introduce lm_alias (2017, v4.11-rc1)

 

다음 그림은 fixmap을 위해 각 단계의 페이지 테이블이 활성화되는 모습을 보여준다.

• 4K 페이지, VA_BITS=48을 사용하면 4단계의 페이지 테이블을 사용하였고, pgd 다음의 p4d 테이블은 ARM64에서 pgd를 그대로 사용한다.

 

early_fixmap_init() – ARM32

arch/arm/mm/mmu.c

void __init early_fixmap_init(void)
{
        pmd_t *pmd;

        /*
         * The early fixmap range spans multiple pmds, for which
         * we are not prepared:
         */
        BUILD_BUG_ON((__fix_to_virt(__end_of_early_ioremap_region) >> PMD_SHIFT)
                     != FIXADDR_TOP >> PMD_SHIFT);

        pmd = fixmap_pmd(FIXADDR_TOP);
        pmd_populate_kernel(&init_mm, pmd, bm_pte);

        pte_offset_fixmap = pte_offset_early_fixmap;
}

fixmap 영역을 활성화한다.

• 코드 라인 12에서 fixmap 가상 주소의 top 영역에 해당하는 pmd 엔트리를 알아온다.
• 코드 라인 13에서 컴파일 타임에 준비된 static bm_pte 페이지를 사용하여 fixmap을 운용할 pte 테이블을 연결하여 활성화한다.
  • pte 테이블 하나당 2M를 커버한다. pte 영역이 4M라 두 개의 pte 테이블이 필요하지만 처음에는 최상위 영역만 활성화한다.

 

---

주요 Fixmap API

set_fixmap()

include/asm-generic/fixmap.h

#define set_fixmap(idx, phys)                           \
        __set_fixmap(idx, phys, FIXMAP_PAGE_NORMAL)

fixmap의 요청 인덱스 @idx 에 물리 주소@phys에 해당하는 페이지 하나를 매핑하는데 normal 커널 페이지 매핑 속성으로 한다.

• ARM32
  • L_PTE_YOUNG | L_PTE_PRESENT | L_PTE_XN | L_PTE_DIRTY | L_PTE_MT_WRITEBACK
• ARM64
  • FIXMAP_PAGE_NORMAL -> PAGE_KERNEL -> __pgprot(PROT_NORMAL) 속성 사용
    • PTE_TYPE_PAGE | PTE_AF | PTE_SHARED | PTE_MAYBE_NG | PTE_PXN | PTE_UXN | PTE_WRITE | PTE_ATTRINDX(MT_NORMAL)

 

clear_fixmap()

include/asm-generic/fixmap.h

#define clear_fixmap(idx)                       \
        __set_fixmap(idx, 0, FIXMAP_PAGE_CLEAR)

fixmap의 요청 인덱스 @idx 영역에 매핑된 물리 주소 1개 페이지를 언매핑하는데 속성은 CLEAR(0)로 설정한다.

• PTE_DIRTY  -> __pgprot(0)

 

set_fixmap_nocache()

include/asm-generic/fixmap.h

#define set_fixmap_nocache(idx, phys) \
        __set_fixmap(idx, phys, FIXMAP_PAGE_NOCACHE)

fixmap의 요청 인덱스 @idx 영역에 물리 주소 @phys에 해당하는 1개 페이지를 캐시 없이 매핑하는데 속성은 FIXMAP_PAGE_NOCACHE로 설정한다.

• ARM32
  • L_PTE_YOUNG | L_PTE_PRESENT | L_PTE_XN | L_PTE_DIRTY | L_PTE_MT_DEV_SHARED | L_PTE_SHARE
• ARM64
  • FIXMAP_PAGE_NOCACHE -> PAGE_KERNEL_NOCACHE -> __pgprot(PROT_NORMAL_NC) 속성 사용
    • PTE_TYPE_PAGE | PTE_AF | PTE_SHARED | PTE_MAYBE_NG | PTE_PXN | PTE_UXN | PTE_WRITE | PTE_ATTRINDX(MT_NORMAL_NC)

 

set_fixmap_io()

include/asm-generic/fixmap.h

#define set_fixmap_io(idx, phys) \
        __set_fixmap(idx, phys, FIXMAP_PAGE_IO)

fixmap의 요청 인덱스 @idx 영역에 물리 주소 @phys에 해당하는 1개 페이지를 매핑하는데 속성은 FIXMAP_PAGE_IO로 설정한다.

• ARM32
  • nocache와 동일한 속성 사용
• ARM64
  • FIXMAP_PAGE_IO -> PAGE_KERNEL_IO -> __pgprot(PROT_DEVICE_nGnRE) 속성 사용
    • PTE_TYPE_PAGE | PTE_AF | PTE_SHARED | PTE_MAYBE_NG | PTE_PXN | PTE_UXN | PTE_WRITE | PTE_ATTRINDX(MT_DEVICE_nGnRE)

 

__set_fixmap() – ARM32

arch/arm/mm/mmu.c

/*
 * To avoid TLB flush broadcasts, this uses local_flush_tlb_kernel_range().
 * As a result, this can only be called with preemption disabled, as under
 * stop_machine().
 */

void __set_fixmap(enum fixed_addresses idx, phys_addr_t phys, pgprot_t prot)
{
        unsigned long vaddr = __fix_to_virt(idx);
        pte_t *pte = pte_offset_kernel(pmd_off_k(vaddr), vaddr);

        /* Make sure fixmap region does not exceed available allocation. */
        BUILD_BUG_ON(FIXADDR_START + (__end_of_fixed_addresses * PAGE_SIZE) >
                     FIXADDR_END);
        BUG_ON(idx >= __end_of_fixed_addresses);

        if (pgprot_val(prot))
                set_pte_at(NULL, vaddr, pte,
                        pfn_pte(phys >> PAGE_SHIFT, prot));
        else
                pte_clear(NULL, vaddr, pte);
        local_flush_tlb_kernel_range(vaddr, vaddr + PAGE_SIZE);
}

물리 주소 @phys에 해당하는 페이지 1개를 fixmap 인덱스 @idx 번호 영역에 @prot 속성으로 매핑한다. 이 함수를 언매핑 용도로 사용할 수도 있는데, 이러한 경우에는 phys 물리 주소 및 flags 속성을 0으로 사용한다.

• 코드 라인 3에서 인덱스 번호 @idx에 매치되는 fixmap 영역의 가상 주소를 알아온다.
• 코드 라인 4에서 가상 주소에 해당하는 페이지 테이블의 엔트리 포인터를 알아온다.
• 코드 라인 11~13에서 매핑을 요청한 경우 플래그를 사용하여 fixmap 엔트리를 물리 주소 @phys에 매핑한다.
• 코드 라인 14~15에서 언매핑을 요청한 경우 fixmap 슬롯 인덱스에 해당하는 pte 엔트리를 클리어한다.
• 코드 라인 16에서 해당 가상 주소 페이지 영역에 대한 tlb 플러시를 수행한다.

 

__set_fixmap() – ARM64

arch/arm64/mm/mmu.c

/*
 * Unusually, this is also called in IRQ context (ghes_iounmap_irq) so if we
 * ever need to use IPIs for TLB broadcasting, then we're in trouble here.
 */

void __set_fixmap(enum fixed_addresses idx,
                               phys_addr_t phys, pgprot_t flags)
{
        unsigned long addr = __fix_to_virt(idx);
        pte_t *ptep;

        BUG_ON(idx <= FIX_HOLE || idx >= __end_of_fixed_addresses);

        ptep = fixmap_pte(addr);

        if (pgprot_val(flags)) {
                set_pte(ptep, pfn_pte(phys >> PAGE_SHIFT, flags));
        } else {
                pte_clear(&init_mm, addr, ptep);
                flush_tlb_kernel_range(addr, addr+PAGE_SIZE);
        }
}

@idx에 해당하는 슬롯 위치의 fixmap 가상 주소 공간에 @phys 물리 주소를 @flags 속성으로 매핑한다. 이 함수를 언매핑 용도로 사용할 수도 있는데, 이러한 경우에는 phys 물리 주소 및 flags 속성을 0으로 사용한다.

• 코드 라인 4에서 인덱스 번호 @idx에 매치되는 fixmap 영역의 가상 주소를 알아온다.
• 코드 라인 9에서 가상 주소에 해당하는 페이지 테이블의 엔트리 포인터를 알아온다.
• 코드 라인 11~12에서 매핑을 요청한 경우 플래그를 사용하여 fixmap 엔트리를 물리 주소 @phys에 매핑한다.
• 코드 라인 13~16에서 언매핑을 요청한 경우 fixmap 슬롯 인덱스에 해당하는 pte 엔트리를 클리어한 후 해당 가상 주소 1개 페이지 영역에 대한 tlb 플러시를 수행한다.

 

fix_to_virt()

include/asm-generic/fixmap.h

/*
 * 'index to address' translation. If anyone tries to use the idx
 * directly without translation, we catch the bug with a NULL-deference
 * kernel oops. Illegal ranges of incoming indices are caught too.
 */

static __always_inline unsigned long fix_to_virt(const unsigned int idx)
{
        BUILD_BUG_ON(idx >= __end_of_fixed_addresses);
        return __fix_to_virt(idx);
}

fixmap 영역에 대한 인덱스로 가상 주소를 알아온다.

#define __fix_to_virt(x)        (FIXADDR_TOP - ((x) << PAGE_SHIFT))

 

virt_to_fix()

include/asm-generic/fixmap.h

static inline unsigned long virt_to_fix(const unsigned long vaddr)
{
        BUG_ON(vaddr >= FIXADDR_TOP || vaddr < FIXADDR_START);
        return __virt_to_fix(vaddr);
}

fixmap area에 매치되는 fixmap 인덱스를 리턴한다.

 

__virt_to_fix()

include/asm-generic/fixmap.h

#define __virt_to_fix(x)        ((FIXADDR_TOP - ((x)&PAGE_MASK)) >> PAGE_SHIFT)

 

---

Highmem 페이지 매핑

다음 그림은 fixmap 영역에서 highmem 페이지 매핑에 사용되는 FIX_KMAP 블럭을 보여준다.

 

highmem 매핑 예)

highmem 페이지를 fixmap의 kmap 블럭에 매핑한다. cpu id별로 할당된 수 만큼의 영역에서 스택처럼 push/pull로 운영하여 사용한다.

• kmap_atomic(page)

 

다음 그림은 highmem 물리 메모리 페이지를 fixmap 공간의 kmap 블럭에 매핑하여 사용하는 모습을 보여준다.

 

다음 그림은 ARM32에서 highmem 물리 페이지를 fixmap 영역에 매핑할 때 페이지 디스크립터와 페이지 테이블간의 관계를 보여준다.

• mem_map에 포함된 page 디스크립터들, pgd 및 pte 페이지 테이블 등이 어우러져 복잡한 모습이다.

 

highmem 페이지 할당 & 해제

kmap_atomic() – ARM32

arch/arm/mm/highmem.c

void *kmap_atomic(struct page *page)
{
        unsigned int idx;
        unsigned long vaddr;
        void *kmap;
        int type;

        preempt_disable();
        pagefault_disable();
        if (!PageHighMem(page))
                return page_address(page);

#ifdef CONFIG_DEBUG_HIGHMEM
        /*
         * There is no cache coherency issue when non VIVT, so force the
         * dedicated kmap usage for better debugging purposes in that case.
         */
        if (!cache_is_vivt())
                kmap = NULL;
        else
#endif
                kmap = kmap_high_get(page);
        if (kmap)
                return kmap;

        type = kmap_atomic_idx_push();

        idx = type + KM_TYPE_NR * smp_processor_id();
        vaddr = __fix_to_virt(idx);
#ifdef CONFIG_DEBUG_HIGHMEM
        /*
         * With debugging enabled, kunmap_atomic forces that entry to 0.
         * Make sure it was indeed properly unmapped.
         */
        BUG_ON(!pte_none(get_fixmap_pte(vaddr)));
#endif
        /*
         * When debugging is off, kunmap_atomic leaves the previous mapping
         * in place, so the contained TLB flush ensures the TLB is updated
         * with the new mapping.
         */
        set_fixmap_pte(idx, mk_pte(page, kmap_prot));

        return (void *)vaddr;
}
EXPORT_SYMBOL(kmap_atomic);

highmem page를 atomic하게 fixmap 영역에 매핑한다. 이미 kmap 영역에 매핑된 경우 매핑된 가상 주소를 리턴한다.

• pagefault_disable()
  • preemption 카운터를 증가시켜 preemption을 disable하고 barrier()를 수행한다.
• if (!PageHighMem(page))
  • page 주소가 highmem 영역이 아니면
• return page_address(page);
  • kmap에 이미 매핑되어 있는 경우 page에 해당하는 가상 주소를 리턴한다.
• kmap = kmap_high_get(page);
  • pkmap 참조 카운터를 증가시키고 highmem page에 해당하는 가상 주소를 리턴한다.
•  if (kmap)
  • 만일 kmap이 이미 발견된 경우 리턴한다.
• type = kmap_atomic_idx_push();
  • __kmap_atomic_idx 증가 시키고 이전 값을 알아온다.
• idx = type + KM_TYPE_NR * smp_processor_id();
  • type 값 + KM_TYPE_NR(20) * cpu id
• vaddr = __fix_to_virt(idx);
  • fixmap에서 해당 idx 번호로 가상 주소를 알아온다.
  • fixmap은 idx 0번이 FIXADDR_TOP을 가리킨다.
    • FIXADDR_TOP
      • 0xffef_f000= (FIXADDR_END(0xfff00000UL) – PAGE_SIZE)
  • 인덱스 번호는 0부터 최대 0x2ff (767)번 까지 가능하며 매핑 되는 가상 주소는 0xffc0_0000 ~ 0xffef_ffff까지 총 3M이다.
    • 실제 허용 가능한 슬롯 인덱스 번호는 해당 cpu별로 KM_TYPE_NR(ARM=20) 개로 제한된다.
• set_fixmap_pte(idx, mk_pte(page, kmap_prot));
  • mk_pte()
    • page 주소와 kmap_prot 속성 값을 합쳐서 pte 엔트리를 만든다.
  • idx 번호에 해당하는 fixmap 영역에 pte 엔트리를 매핑한다.

 

__fix_to_virt()

include/asm-generic/fixmap.h

#define __fix_to_virt(x)        (FIXADDR_TOP - ((x) << PAGE_SHIFT))

 

mk_pte() – ARM & ARM64

arch/arm64/include/asm/pgtable.h

#define mk_pte(page,prot)       pfn_pte(page_to_pfn(page), prot)

 

set_fixmap_pte() – ARM32

arch/arm/mm/highmem.c

static inline void set_fixmap_pte(int idx, pte_t pte)
{
        unsigned long vaddr = __fix_to_virt(idx);
        pte_t *ptep = pte_offset_kernel(pmd_off_k(vaddr), vaddr);

        set_pte_ext(ptep, pte, 0); 
        local_flush_tlb_kernel_page(vaddr);
}

idx 번호에 해당하는 fixmap 영역에 pte 엔트리를 매핑한다.

• unsigned long vaddr = __fix_to_virt(idx);
  • idx 번호에 해당하는 fixmap 영역의 가상 주소를 알아온다.
• pte_t *ptep = pte_offset_kernel(pmd_off_k(vaddr), vaddr);
  • pmd_off_k()
    • 가상 주소값으로 pmd 엔트리 주소 값을 알아온다.
  • pte_offset_kernel()
    • pmd 엔트리 주소 값과 vaddr 값을 사용하여 pte 엔트리 주소를 알아온다.
• set_pte_ext(ptep, pte, 0);
  • pte 엔트리 주소에 pte 값을 저장한다.
    • rpi2: cpu_v7_set_pte_ext() 호출
• local_flush_tlb_kernel_page(vaddr);
  • vaddr에 해당하는 tlb 캐시를 flush한다.

 

local_flush_tlb_kernel_page() – ARM32

arch/arm/include/asm/tlbflush.h

static inline void local_flush_tlb_kernel_page(unsigned long kaddr)
{
        const unsigned int __tlb_flag = __cpu_tlb_flags;

        kaddr &= PAGE_MASK;

        if (tlb_flag(TLB_WB))
                dsb(nshst);

        __local_flush_tlb_kernel_page(kaddr);
        tlb_op(TLB_V7_UIS_PAGE, "c8, c7, 1", kaddr);

        if (tlb_flag(TLB_BARRIER)) {
                dsb(nsh);
                isb();
        }   
}

 

__local_flush_tlb_kernel_page() – ARM32

arch/arm/include/asm/tlbflush.h

static inline void __local_flush_tlb_kernel_page(unsigned long kaddr)
{
        const int zero = 0;
        const unsigned int __tlb_flag = __cpu_tlb_flags;

        tlb_op(TLB_V4_U_PAGE, "c8, c7, 1", kaddr);
        tlb_op(TLB_V4_D_PAGE, "c8, c6, 1", kaddr);
        tlb_op(TLB_V4_I_PAGE, "c8, c5, 1", kaddr);
        if (!tlb_flag(TLB_V4_I_PAGE) && tlb_flag(TLB_V4_I_FULL))
                asm("mcr p15, 0, %0, c8, c5, 0" : : "r" (zero) : "cc");

        tlb_op(TLB_V6_U_PAGE, "c8, c7, 1", kaddr);
        tlb_op(TLB_V6_D_PAGE, "c8, c6, 1", kaddr);
        tlb_op(TLB_V6_I_PAGE, "c8, c5, 1", kaddr);
}

 

tlb_op() – ARM32

arch/arm/include/asm/tlbflush.h

#define tlb_op(f, regs, arg)    __tlb_op(f, "p15, 0, %0, " regs, arg)

 

__tlb_op() – ARM32

arch/arm/include/asm/tlbflush.h

#define __tlb_op(f, insnarg, arg)                                       \
        do {                                                            \
                if (always_tlb_flags & (f))                             \
                        asm("mcr " insnarg                              \
                            : : "r" (arg) : "cc");                      \
                else if (possible_tlb_flags & (f))                      \
                        asm("tst %1, %2\n\t"                            \
                            "mcrne " insnarg                            \
                            : : "r" (arg), "r" (__tlb_flag), "Ir" (f)   \
                            : "cc");                                    \
        } while (0)

 

 

kmap_atomic_idx_push() – 32bit

include/linux/highmem.h

static inline int kmap_atomic_idx_push(void)
{
        int idx = __this_cpu_inc_return(__kmap_atomic_idx) - 1;

#ifdef CONFIG_DEBUG_HIGHMEM
        WARN_ON_ONCE(in_irq() && !irqs_disabled());
        BUG_ON(idx >= KM_TYPE_NR);
#endif
        return idx;
}

해당 cpu에서 사용할 fixmap용 슬롯 인덱스를 리턴하고 그 값은 증가 시킨다.

• CONFIG_DEBUG_HIGHMEM 옵션을 사용하는 경우 fixmap 인덱스 슬롯이 KM_TYPE_NR(ARM=20)을 초과하는 경우 버그에 대한 메시지를 출력하고 멈춘다.

• int idx = __this_cpu_inc_return(__kmap_atomic_idx);
  • __kmap_atomic_idx per-cpu 데이터를 1 증가
  • idx 에는 증가전 값을 담아 리턴한다.

 

__this_cpu_inc_return()

#define __this_cpu_inc_return(pcp)      __this_cpu_add_return(pcp, 1)

• pcp에 1을 더한 값을 리턴

 

__this_cpu_add_return()

#define __this_cpu_add_return(pcp, val)                                 \
({                                                                      \
        __this_cpu_preempt_check("add_return");                         \
        raw_cpu_add_return(pcp, val);                                   \
})

• preemption이 disable되어 있지  않거나 irq가 disable되어 있지 않으면 stack dump
• __kmap_atomic_idx per-cpu 데이터를 1 증가

 

raw_cpu_add_return()

#define raw_cpu_add_return(pcp, val)    __pcpu_size_call_return2(raw_cpu_add_return_, pcp, val)

• scalar 데이터 타입 pcp의 사이즈에 따른 최적화된 덧셈 함수를 분류하기 위해 매크로 함수 호출

 

__pcpu_size_call_return2()

#define __pcpu_size_call_return2(stem, variable, ...)                   \
({                                                                      \
        typeof(variable) pscr2_ret__;                                   \
        __verify_pcpu_ptr(&(variable));                                 \
        switch(sizeof(variable)) {                                      \
        case 1: pscr2_ret__ = stem##1(variable, __VA_ARGS__); break;    \
        case 2: pscr2_ret__ = stem##2(variable, __VA_ARGS__); break;    \
        case 4: pscr2_ret__ = stem##4(variable, __VA_ARGS__); break;    \
        case 8: pscr2_ret__ = stem##8(variable, __VA_ARGS__); break;    \
        default:                                                        \
                __bad_size_call_parameter(); break;                     \
        }                                                               \
        pscr2_ret__;                                                    \
})

• variable의 사이즈에 따라 stem(함수명 인수)+1/2/4/8 숫자를 붙여 호출

 

this_cpu_add_return_4()

#define this_cpu_add_return_4(pcp, val) this_cpu_generic_add_return(pcp, val)

• ARM 아키텍처는 사이즈와 관계 없이 generic 코드를 호출한다.

 

this_cpu_generic_add_return()

#define this_cpu_generic_add_return(pcp, val)                           \
({                                                                      \
        typeof(pcp) __ret;                                              \
        unsigned long __flags;                                          \
        raw_local_irq_save(__flags);                                    \
        raw_cpu_add(pcp, val);                                          \
        __ret = raw_cpu_read(pcp);                                      \
        raw_local_irq_restore(__flags);                                 \
        __ret;                                                          \
})

• per-cpu 변수에 val 값을 더하고 다시 읽어 리턴한다.

 

raw_cpu_add()

#define raw_cpu_add(pcp, val)           __pcpu_size_call(raw_cpu_add_, pcp, val)

• scalar 데이터 타입 pcp의 사이즈에 따른 최적화된 덧셈 함수를 분류하기 위해 매크로 함수 호출

 

__pcpu_size_call()

#define __pcpu_size_call(stem, variable, ...)                           \
do {                                                                    \
        __verify_pcpu_ptr(&(variable));                                 \
        switch(sizeof(variable)) {                                      \
                case 1: stem##1(variable, __VA_ARGS__);break;           \
                case 2: stem##2(variable, __VA_ARGS__);break;           \
                case 4: stem##4(variable, __VA_ARGS__);break;           \
                case 8: stem##8(variable, __VA_ARGS__);break;           \
                default:                                                \
                        __bad_size_call_parameter();break;              \
        }                                                               \
} while (0)

• variable의 사이즈에 따라 stem(함수명 인수)+1/2/4/8 숫자를 붙여 호출

 

raw_cpu_add_4()

#define raw_cpu_add_4(pcp, val)         raw_cpu_generic_to_op(pcp, val, +=)

• ARM 아키텍처는 사이즈와 관계 없이 generic 코드를 호출한다.

 

raw_cpu_generic_to_op()

#define raw_cpu_generic_to_op(pcp, val, op)                             \
do {                                                                    \
        *raw_cpu_ptr(&(pcp)) op val;                                    \
} while (0)

• 예) pcp=__kmap_atomic_idx, val=1, op= +=
  • per-cpu int 데이터인 __kmap_atomic_idx += 1

 

kunmap_atomic() – 32bit

include/linux/highmem.h

/*
 * Prevent people trying to call kunmap_atomic() as if it were kunmap()
 * kunmap_atomic() should get the return value of kmap_atomic, not the page.
 */
#define kunmap_atomic(addr)                                     \
do {                                                            \
        BUILD_BUG_ON(__same_type((addr), struct page *));       \
        __kunmap_atomic(addr);                                  \
} while (0)

kmap_atomic()을 사용하여 fixmap 영역에 매핑되어 있는 highmem 영역을 해제한다.

 

__kunmap_atomic() – 32bit

arch/arm/mm/highmem.c

void __kunmap_atomic(void *kvaddr)
{
        unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
        int idx, type;

        if (kvaddr >= (void *)FIXADDR_START) {
                type = kmap_atomic_idx();
                idx = type + KM_TYPE_NR * smp_processor_id();

                if (cache_is_vivt())
                        __cpuc_flush_dcache_area((void *)vaddr, PAGE_SIZE);
#ifdef CONFIG_DEBUG_HIGHMEM
                BUG_ON(vaddr != __fix_to_virt(idx));
                set_fixmap_pte(idx, __pte(0));
#else
                (void) idx;  /* to kill a warning */
#endif
                kmap_atomic_idx_pop();
        } else if (vaddr >= PKMAP_ADDR(0) && vaddr < PKMAP_ADDR(LAST_PKMAP)) {
                /* this address was obtained through kmap_high_get() */
                kunmap_high(pte_page(pkmap_page_table[PKMAP_NR(vaddr)]));
        }
        pagefault_enable();
}
EXPORT_SYMBOL(__kunmap_atomic);

kmap_atomic()을 사용하여 fixmap 또는 kmap 영역에 매핑되어 있는 highmem 영역을 해제한다.

• if (kvaddr >= (void *)FIXADDR_START) {
  • 주소가 fixmap 영역인 경우
•  type = kmap_atomic_idx();
  • __kmap_atomic_idx per-cpu 데이터값에서 1을 뺀 인덱스 값
• idx = type + KM_TYPE_NR * smp_processor_id();
  • KM_TYPE_NR=20
• if (cache_is_vivt())
  • L1 d-cache 타입이 VIVT인 경우
  • rpi2:
    • L1 d-cache는 CACHEID_VIPT_NONALIASING
    • L1 i-cache는 CACHEID_VIPT_I_ALIASING
• __cpuc_flush_dcache_area((void *)vaddr, PAGE_SIZE);
  • 해당 주소의 1 페이지 영역의 d-cache를 flush 한다.
• kmap_atomic_idx_pop();
  • __kmap_atomic_idx per-cpu 데이터를 1 감소시킨다.
• } else if (vaddr >= PKMAP_ADDR(0) && vaddr < PKMAP_ADDR(LAST_PKMAP)) {
  • 가상 주소가 pkmap 매핑 영역인 경우
• kunmap_high(pte_page(pkmap_page_table[PKMAP_NR(vaddr)]));
  • kmap 영역에 매핑된 highmem page 주소를 매핑 해제한다.
• pagefault_enable();
  • preemption을 enable 한다.

 

참고

• page_address_init() | 문c
• Kmap(Pkmap) | 문c
• Early ioremap | 문c
• Fixing kmap_atomic() | LWN.net