per-cpu 동적 할당

 

Per-cpu 동적 할당

alloc_percpu-1

 

alloc_percpu()

include/linux/percpu.h

#define alloc_percpu(type)                                              \
        (typeof(type) __percpu *)__alloc_percpu(sizeof(type),           \
                                                __alignof__(type))

요청 타입의 per-cpu 메모리를  할당한다.

 

__alloc_percpu()

mm/percpu.c

/**
 * __alloc_percpu - allocate dynamic percpu area
 * @size: size of area to allocate in bytes
 * @align: alignment of area (max PAGE_SIZE)
 *
 * Equivalent to __alloc_percpu_gfp(size, align, %GFP_KERNEL).
 */
void __percpu *__alloc_percpu(size_t size, size_t align)
{
        return pcpu_alloc(size, align, false, GFP_KERNEL);
}
EXPORT_SYMBOL_GPL(__alloc_percpu);

요청 size 및 align 값으로 per-cpu 메모리를  할당한다.

 

alloc_percpu_gfp()

include/linux/percpu.h

#define alloc_percpu_gfp(type, gfp)                                     \
        (typeof(type) __percpu *)__alloc_percpu_gfp(sizeof(type),       \
                                                __alignof__(type), gfp)

요청 타입 및 gfp 플래그를 사용하여 per-cpu 메모리를  할당한다.

 

__alloc_percpu_gfp()

mm/percpu.c

/**
 * __alloc_percpu_gfp - allocate dynamic percpu area
 * @size: size of area to allocate in bytes
 * @align: alignment of area (max PAGE_SIZE)
 * @gfp: allocation flags
 *
 * Allocate zero-filled percpu area of @size bytes aligned at @align.  If
 * @gfp doesn't contain %GFP_KERNEL, the allocation doesn't block and can
 * be called from any context but is a lot more likely to fail.
 *
 * RETURNS:
 * Percpu pointer to the allocated area on success, NULL on failure.
 */
void __percpu *__alloc_percpu_gfp(size_t size, size_t align, gfp_t gfp)
{
        return pcpu_alloc(size, align, false, gfp);
}
EXPORT_SYMBOL_GPL(__alloc_percpu_gfp);

요청 size, align 및 gfp 플래그 값으로 per-cpu 메모리를  할당한다.

 

__alloc_reserved_percpu()

mm/percpu.c

/**
 * __alloc_reserved_percpu - allocate reserved percpu area
 * @size: size of area to allocate in bytes
 * @align: alignment of area (max PAGE_SIZE)
 *
 * Allocate zero-filled percpu area of @size bytes aligned at @align
 * from reserved percpu area if arch has set it up; otherwise,
 * allocation is served from the same dynamic area.  Might sleep.
 * Might trigger writeouts.
 *
 * CONTEXT:
 * Does GFP_KERNEL allocation.
 *
 * RETURNS:
 * Percpu pointer to the allocated area on success, NULL on failure.
 */
void __percpu *__alloc_reserved_percpu(size_t size, size_t align)
{
        return pcpu_alloc(size, align, true, GFP_KERNEL);
}

요청 size 및 align 값으로 reserved per-cpu 영역의 메모리를  할당한다.

 

pcpu 동적 할당  메인

pcpu_alloc-1

pcpu_alloc()

mm/percpu.c

/**
 * pcpu_alloc - the percpu allocator
 * @size: size of area to allocate in bytes
 * @align: alignment of area (max PAGE_SIZE)
 * @reserved: allocate from the reserved chunk if available
 * @gfp: allocation flags
 *
 * Allocate percpu area of @size bytes aligned at @align.  If @gfp doesn't
 * contain %GFP_KERNEL, the allocation is atomic.
 *
 * RETURNS:
 * Percpu pointer to the allocated area on success, NULL on failure.
 */
static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
                                 gfp_t gfp)
{
        static int warn_limit = 10;
        struct pcpu_chunk *chunk;
        const char *err;
        bool is_atomic = (gfp & GFP_KERNEL) != GFP_KERNEL;
        int occ_pages = 0;
        int slot, off, new_alloc, cpu, ret;
        unsigned long flags;
        void __percpu *ptr;

        /*
         * We want the lowest bit of offset available for in-use/free
         * indicator, so force >= 16bit alignment and make size even.
         */
        if (unlikely(align < 2)) 
                align = 2; 

        size = ALIGN(size, 2); 

        if (unlikely(!size || size > PCPU_MIN_UNIT_SIZE || align > PAGE_SIZE)) {
                WARN(true, "illegal size (%zu) or align (%zu) for "
                     "percpu allocation\n", size, align);
                return NULL;
        }

        spin_lock_irqsave(&pcpu_lock, flags);

요청 size와 align 값으로 per-cpu 메모리를 동적으로 할당한다. 모듈에서 호출하는 경우 reserved를 true로 호출하여 reserved per-cpu 영역에서 할당하게 한다. 할당 받을 공간이 부족한 경우 chunk를 새로 추가하는데, 만일 atomic 요청인 경우에는 확장하지 않고 실패 처리한다.

  • bool is_atomic = (gfp & GFP_KERNEL) != GFP_KERNEL;
    • GFP_KERNEL
      • define GFP_KERNEL      (__GFP_WAIT | __GFP_IO | __GFP_FS)
    • GFP_KERNEL 옵션을 사용하지 않는 경우 할당은 atomic이다.
    • alloc_percpu() 함수 등을 사용하여 호출하는 경우 항상 GFP_KERNEL 옵션을 사용하므로 atomic 조건을 사용하지 않는다.
    • 현재 커널에서 alloc_percpu_gfp() 함수를 사용하는 경우에는 gfp 옵션을 바꿀 수 있는데 실제 적용된 코드에는 아직까지 GFP_KERNEL 옵션 이외의 gfp 옵션을 사용한 사례가 없다. 향후 atomic 조건을 사용하려고 미리 준비해둔 함수이다.
    • atomic 조건으로 이 함수를 동작시키는 경우 populate된 페이지에서만 per-cpu 데이터를 할당할 수 있게 제한한다. atomic 조건이 아닌 경우는 chunk가 부족한 경우 chunk도 생성할 수 있고 unpopulate된 페이지들을 population 과정을 통해 사용할 수 있게한다.
  • if (unlikely(align < 2))
    • 낮은 확률로 align 인수가 2보다 작으면 최소 2로 설정한다. (최소 2 byte align)
  • if (unlikely(!size || …
    • 낮은 확률로 size가 0이거나 PCPU_MIN_UNIT_SIZE(32K)보다 크거나 또는 align이 PAGE_SIZE(4K) 보다 큰 경우 경고 출력 후 함수를 빠져나간다.
  • spin_lock_irqsave(&pcpu_lock, flags);
    • 할당 준비를 하는동안 interrupt를 막는다.
        /* serve reserved allocations from the reserved chunk if available */
        if (reserved && pcpu_reserved_chunk) {
                chunk = pcpu_reserved_chunk;

                if (size > chunk->contig_hint) {
                        err = "alloc from reserved chunk failed";
                        goto fail_unlock;
                }

                while ((new_alloc = pcpu_need_to_extend(chunk, is_atomic))) {
                        spin_unlock_irqrestore(&pcpu_lock, flags);
                        if (is_atomic ||
                            pcpu_extend_area_map(chunk, new_alloc) < 0) { 
                                err = "failed to extend area map of reserved chunk"; 
                                goto fail; 
                        } 
                        spin_lock_irqsave(&pcpu_lock, flags); 
                }

                off = pcpu_alloc_area(chunk, size, align, is_atomic, 
                                      &occ_pages); 
                if (off >= 0)
                        goto area_found;

                err = "alloc from reserved chunk failed";
                goto fail_unlock;
        }

module per-cpu 데이터를 위해 reserved allocation을 수행한다.

 

  • if (reserved && pcpu_reserved_chunk) {
    • 인수 reserved를 true로 호출하여 reserved 영역을 요청하면서 별도 옵션인 pcpu_reserved_chunk 구조체가 설정된 경우 reserved chunk에 할당을 한다.
    • 그렇지 않은 경우 normal chunk에 할당을 하기 위해 조건을 빠져나간다.
  • if (size > chunk->contig_hint) {
    • 요청 사이즈가 reserved chunk의 contig_hint 보다 큰 경우 할당이 불가능하여 실패하고 빠져나간다.
  • while ((new_alloc = pcpu_need_to_extend(chunk, is_atomic))) {
    • 현재 reserved chunk가 확장이 필요한 경우 루프를 수행한다.
    • pcpu_need_to_extend()
      • 현 chunk 영역 맵을 확장해야 하는지 결정하는데 맵 확장이 필요한 경우 필요 사이즈를 리턴한다.
        • 확장 시킬 맵 사이즈는 먼저 PCPU_DFL_MAP_ALLOC(16) 부터 시작하여 map_used와 margin을 비교하여 더 필요한 만큼 배수로 리턴한다.
          • first chunk를 만들 때에는 PERCPU_DYNAMIC_EARLY_SLOTS(128)개부터 시작하고 추가되는 dynamic chunk는 PCPU_DFL_MAP_ALLOC(16)개부터 시작한다.
    • pcpu_extend_area_map()
      • 요청 받은 new_alloc 사이즈만큼 맵을 확장하는데 PAGE_SIZE 보다 큰 경우 vzalloc()으로 할당하고 작은 경우 kzmalloc()으로 할당한다.
      • 맵 확장은 slub memory allocator가 동작할 경우에만 허용된다.
    • 맵 확장이 실패하면 함수를 빠져나간다.
  • pcpu_alloc_area()
    • chunk내에 영역을 할당한다.
    • 할당 후 chunk->contig_hint 에는 남은 공간 중 최대 할당 가능한 사이즈를 저장한다.
    • 이 함수 수행 후 chunk 멤버 변수인 map[], free_size, first_free, map_used 등이 영향을 받는다.
  • 영역 할당을 받은 경우 area_found: 레이블로 이동한다.

 

restart:
        /* search through normal chunks */
        for (slot = pcpu_size_to_slot(size); slot < pcpu_nr_slots; slot++) {
                list_for_each_entry(chunk, &pcpu_slot[slot], list) { 
                        if (size > chunk->contig_hint)
                                continue;

                        new_alloc = pcpu_need_to_extend(chunk, is_atomic);
                        if (new_alloc) {
                                if (is_atomic)
                                        continue;
                                spin_unlock_irqrestore(&pcpu_lock, flags);
                                if (pcpu_extend_area_map(chunk,
                                                         new_alloc) < 0) { 
                                        err = "failed to extend area map"; 
                                        goto fail; 
                                } 
                                spin_lock_irqsave(&pcpu_lock, flags); 
                                /* 
                                 * pcpu_lock has been dropped, need to 
                                 * restart cpu_slot list walking. 
                                 */ 
                                goto restart; 
                        } 

                        off = pcpu_alloc_area(chunk, size, align, is_atomic,
                                              &occ_pages); 
                        if (off >= 0)
                                goto area_found;
                }
        }

        spin_unlock_irqrestore(&pcpu_lock, flags);

reserved_chunk로 할당하지 않는 경우 dynamic 영역을 사용한다.

  •  for (slot = pcpu_size_to_slot(size); …
    • 요청 size가 있는 slot 부터 마지막 슬롯까지 루프를 돈다.
    • pcpu_size_to_slot()
      • 각 slot에는 size 범위가 있는데 해당되는 slot 번호를 리턴한다.
        • 예) 44K -> 13번 슬롯
    • 적합한 size를 찾을 때 free_size가 작은 슬롯부터 검색을 한다.
  •  list_for_each_entry(chunk, &pcpu_slot[slot], list) {
    • pcpu_slot[해당 slot].list 수 만큼 루프를 돈다.
  • if (size > chunk->contig_hint)
    • 요청 사이즈가 리스트에 담긴 chunk의 contig_hint(남은 최대 할당 가능 사이즈)보다 큰 경우 할당을 할 수 없으므로 다음 리스트 엔트리로 진행한다.
  • new_alloc = pcpu_need_to_extend()
    • size 할당 가능한 영역인 경우 이 루틴에 진입하여 pcpu_need_to_extend() 함수를 호출하여 이 chunk에서 맵을 확장할 필요가 있는지 확인 요청한다.
    • atomic하게 할당해야 하는 경우 map 배열에 최소 3개의 항목이 남아 있어야 한다.
      • 할당 시 align 및 size가 남아 추가한 맵 엔트리의 앞 뒤로 엔트리가 추가될 수 있다.
    • atomic하게 할당할 때 32개 이하의 엔트리가 남은 경우 맵 확장 함수를 스케쥴한다.
    • atomic하게 할당하는 경우가 아닌 경우 64개 이하의 맵 엔트리가 남은 경우 확장이 필요한 갯 수를 산출하여 반환하게 한다.
  • if (new_alloc) {
    • 맵을 확장해야 하는 경우 new_alloc가 0이 아닌 map size값을 담는다.
    • pcpu_extend_area_map() 함수를 사용하여 맵을 확장한다.
    • 실패한 경우 fail: 루틴으로 이동하고 성공한 경우 restart: 부터 다시 시작한다.
  •  off = pcpu_alloc_area()
    • 맵을 확장하지 않아도 되는 경우에 이 루틴에 진입하며 해당 chunk에 할당을 한다.
    • 할당 후 chunk->contig_hint 에는 남은 공간 중 최대 할당 가능한 사이즈를 저장한다.
    • 이 함수 수행 후 chunk 멤버 변수인 map[], free_size, first_free, map_used 등이 영향을 받는다.
  • if (off >= 0)
    • 영역 할당이 정상(-1이 아닌 값) 완료되면 area_found: 레이블로 이동한다.

 

        /*
         * No space left.  Create a new chunk.  We don't want multiple
         * tasks to create chunks simultaneously.  Serialize and create iff
         * there's still no empty chunk after grabbing the mutex.
         */
        if (is_atomic)
                goto fail;

        mutex_lock(&pcpu_alloc_mutex);

        if (list_empty(&pcpu_slot[pcpu_nr_slots - 1])) {
                chunk = pcpu_create_chunk();
                if (!chunk) {
                        mutex_unlock(&pcpu_alloc_mutex);
                        err = "failed to allocate new chunk";
                        goto fail;
                }

                spin_lock_irqsave(&pcpu_lock, flags);
                pcpu_chunk_relocate(chunk, -1);
        } else {
                spin_lock_irqsave(&pcpu_lock, flags);
        }

        mutex_unlock(&pcpu_alloc_mutex);
        goto restart;

할당을 못하고 이 루틴에 진입하게 되면 여기서 새로운 chunk를 만들어야 한다.

  • if (is_atomic)
    • atomic 할당을 요청한 경우라면 새로운 chunk를 만들 수 없어 fail: 레이블로 이동한다.
  •  mutex_lock(&pcpu_alloc_mutex);
    • chunk를 새로 할당 받는 동안 mutex로 보호받는다.
  • if (list_empty(&pcpu_slot[pcpu_nr_slots – 1])) {
    • 시간이 지났으므로 정확한 동기화를 위해  다시 현재 시점에서 pcpu_slot[]의 마지막 슬롯이 비어있는지 체크한다.
    • 역시 비어 있는 경우 chunk를 만들 계획이며 그렇지 않은 경우 spin_lock_irqsave() 함수를 호출하고 다시 restart: 레이블로 이동한다.
  • chunk = pcpu_create_chunk();
    • chunk를 새로 만들고 성공 시 chunk에는 0이 아닌 값이 들어간다.
    • 만들어진 새로운 chunk는 관리 구조체만 새로 할당 받아 초기화하고 실제 vmalloc 공간에 배치하지만 물리 페이지의 할당 및 매핑은 하지 않는다.
    • 당연히 populated 비트맵은 0으로 초기화된다.
  • if (!chunk) {
    • 실패 시 fail: 레이블로 이동한다.
  • pcpu_chunk_relocate(chunk, -1);
    • 새로 chunk가 만들어졌으므로 슬롯을 재 정비한 후 restart:로 이동하여 영역 할당을 다시 시도한다.

 

area_found:
        spin_unlock_irqrestore(&pcpu_lock, flags);

        /* populate if not all pages are already there */
        if (!is_atomic) {
                int page_start, page_end, rs, re;

                mutex_lock(&pcpu_alloc_mutex);

                page_start = PFN_DOWN(off);
                page_end = PFN_UP(off + size);

                pcpu_for_each_unpop_region(chunk, rs, re, page_start, page_end) {
                        WARN_ON(chunk->immutable);

                        ret = pcpu_populate_chunk(chunk, rs, re);

                        spin_lock_irqsave(&pcpu_lock, flags);
                        if (ret) {
                                mutex_unlock(&pcpu_alloc_mutex);
                                pcpu_free_area(chunk, off, &occ_pages);
                                err = "failed to populate";
                                goto fail_unlock;
                        }
                        pcpu_chunk_populated(chunk, rs, re);
                        spin_unlock_irqrestore(&pcpu_lock, flags);
                }

                mutex_unlock(&pcpu_alloc_mutex);
        }

        if (chunk != pcpu_reserved_chunk)
                pcpu_nr_empty_pop_pages -= occ_pages;

        if (pcpu_nr_empty_pop_pages < PCPU_EMPTY_POP_PAGES_LOW)
                pcpu_schedule_balance_work(); 

        /* clear the areas and return address relative to base address */
        for_each_possible_cpu(cpu) 
                memset((void *)pcpu_chunk_addr(chunk, cpu, 0) + off, 0, size); 

        ptr = __addr_to_pcpu_ptr(chunk->base_addr + off);
        kmemleak_alloc_percpu(ptr, size);
        return ptr;

atomic 할당 요청 중이 아니고 사용하려는 공간의 페이지가 unpopulate된 페이지의 경우 면 populate 처리를 진행한다.

  • 요청된 size의 할당을 위해 필요한 size 만큼의 페이지를 order-0 단위의 물리 페이지들을 할당 받아 vmalloc 공간에 매핑하게 한다.

 

  • if (!is_atomic) {
    • atomic 할당 요청 중이 아니면
  • page_start
    • 할당 받은 페이지의 시작 pfn
  • page_end
    • 할당 받은 페이지의 끝 pfn
  • pcpu_for_each_unpop_region()
    • chunk내 기준 시작 페이지부터 끝 페이지까지 un-populated 영역의 시작(rs)주소와 끝(re) 주소를 알아온다.
    • 페이지 번호들은 모두 물리 페이지 기준의 PFN이 아니고 chunk의 첫 유닛을 기준으로한다.
  • pcpu_populate_chunk()
    • 해당 chunk의 지정된 영역을 populate 시킨다.
    • 실제 물리 페이지를 할당받아 지정된 vmalloc 공간에 매핑한다.
  • pcpu_chunk_populated()
    • chunk에 해당 영역이 populate되었다는 정보를 기록한다.
      • chunk의 멤버변수 populated의 비트맵을 설정한다.
      • chunk의 멤버변수 nr_populated 및 pcpu_nr_empty_pop_pages 전역변수에 populated된 페이지 수를 추가한다.
  •  if (chunk != pcpu_reserved_chunk)
    • chunk가 reserved chunk가 아니면 pcpu_nr_empty_pop_pages 에서 occ_pages(영역이 점유된 페이지 수) 만큼 뺀다.
  • if (pcpu_nr_empty_pop_pages < PCPU_EMPTY_POP_PAGES_LOW)
    • 빈 populated 페이지 수가 2개 미만이면
  • pcpu_schedule_balance_work()
    • populate를 하기 위해 밸런스 워크를 수행한다.
    • pcpu_balance_workfn()
      • 이 함수에서는 하나의 빈 chunk에 atomic allocation이 가능하도록  populated free pages를 PCPU_EMPTY_POP_PAGES_LOW(2) ~ HIGH(4)까지 확보한다.
      • atomic operation을 위해 미리 populate된 페이지를 확보해 둔다.
  • memset(…)
    • 할당된 영역의 cpu 수만큼 offset를 벌려서 깨끗이 청소한다.
  • __addr_to_pcpu_ptr()
    • 주어진 주소로 per-cpu 포인터 주소로의 변환을 위해 사용되는 매크로이다.
    • per-cpu 포인터 주소는 unit 0에 해당하는 실제 데이터의 주소가 아니라 그 주소에서 delta를 뺀 주소를 가리킨다. 실제 사용시에는 이 값에  해당 cpu가 저장하고 있는 TPIDRPRW 값을 더해 사용한다.
      • TPIRDRPRW에는 first chunk를 처음 설정 시 cpu에 해당하는 유닛 offset + delta 값이 보관되어 있으며 이 값은 향후 바뀌지 않는다.
      • delta 값은 first chunk를 처음 설정 시 산출된 가장 낮은 노드(그룹)의 base offset 에서 per-cpu 섹션의 시작 주소를 뺀 가상의 주소이다.
        • 실제 static 변수의 경우 per-cpu 섹션에 컴파일 타임에 만들어진 주소를 가지며, dynamic 할당에서는 그 delta 값을 고려하여 미리 감소 시킨 값을 가리킨다. 따라서 어떠한 경우에도 per-cpu 포인터 값을 access하면 안된다.
        • static per-cpu 데이터이든 dynamic 하게 할당되어 사용하는 per-cpu 데이터이든 동일한 this_cpu_ptr()등의 API 함수를 사용하게 하기 위해 고려되었다.
  • kmemleak_alloc_percpu()
    • 메모리 leak 감시를 위해 오브젝트를 등록한다.
  • 성공하였으므로 함수를 빠져나간다.
fail_unlock:
        spin_unlock_irqrestore(&pcpu_lock, flags);
fail:
        if (!is_atomic && warn_limit) {
                pr_warning("PERCPU: allocation failed, size=%zu align=%zu atomic=%d, %s\n",
                           size, align, is_atomic, err);
                dump_stack();
                if (!--warn_limit)
                        pr_info("PERCPU: limit reached, disable warning\n");
        }
        if (is_atomic) {
                /* see the flag handling in pcpu_blance_workfn() */
                pcpu_atomic_alloc_failed = true;
                pcpu_schedule_balance_work();
        }
        return NULL;
}

할당에 실패한 경우 이 루틴으로 진입한다.

  • atomic 할당 요청을 받은 경우가 아니면 경고를 출력하고 return 한다.
  • atomic 할당 요청을 받은 경우 pcpu_schedule_balance_work() 루틴을 호출하여 별도로 스케쥴 할당을 받아 populated된 free 페이지의 할당을 준비한다.

 

pcpu_need_to_extend()

/**
 * pcpu_need_to_extend - determine whether chunk area map needs to be extended
 * @chunk: chunk of interest
 * @is_atomic: the allocation context
 *
 * Determine whether area map of @chunk needs to be extended.  If
 * @is_atomic, only the amount necessary for a new allocation is
 * considered; however, async extension is scheduled if the left amount is
 * low.  If !@is_atomic, it aims for more empty space.  Combined, this
 * ensures that the map is likely to have enough available space to
 * accomodate atomic allocations which can't extend maps directly.
 *
 * CONTEXT:
 * pcpu_lock.
 *
 * RETURNS:
 * New target map allocation length if extension is necessary, 0
 * otherwise.
 */
static int pcpu_need_to_extend(struct pcpu_chunk *chunk, bool is_atomic)
{
        int margin, new_alloc;

        if (is_atomic) {
                margin = 3; 

                if (chunk->map_alloc <
                    chunk->map_used + PCPU_ATOMIC_MAP_MARGIN_LOW &&
                    pcpu_async_enabled)
                        schedule_work(&chunk->map_extend_work);
        } else {
                margin = PCPU_ATOMIC_MAP_MARGIN_HIGH;
        }

        if (chunk->map_alloc >= chunk->map_used + margin)
                return 0;

        new_alloc = PCPU_DFL_MAP_ALLOC;
        while (new_alloc < chunk->map_used + margin)
                new_alloc *= 2;

        return new_alloc;
}

맵 배열이 부족한지 확인하고 필요한 배열 수를 리턴한다.

  • PCPU_ATOMIC_MAP_MARGIN_LOW, PCPU_ATOMIC_MAP_MARGIN_HIGH
    • 32, 64
  • if (is_atomic) {
    • is_atomic으로 요청 받은 경우 margin에 3을 대입한다. 할당 시 최소 3개의 엔트리는 있어야 한다.
      • 1개는 마지막 주소가 담아있고, 2개는 맵 엔트리에 size를 추가 시 align 만큼 공간이 남는 경우 그 영역에 대한 맵 엔트리와 할당할 size 영역을 제외한 남는 공간에 대한 엔트리로 사용될 수 있다.
    • pcpu_async_enabled 플래그가 동작하면서 맵이 사용된 수 + PCPU_ATOMIC_MAP_MARGIN_LOW(32)가 현재 맵 사용된 수보다 큰 경우
  • schedule_work(&chunk->map_extend_work);
    • schedule_work() 함수를 호출하여 스케쥴러를 통해 pcpu_map_extend_workfn() 함수를 동작시킨다.
    • 결국 32개 이하의 엔트리가 남는 경우 atomic 요청이 있는 경우는 미리 백그라운드로 맵 확장 함수를 스케쥴하여 둔다.
  • margin = PCPU_ATOMIC_MAP_MARGIN_HIGH;
    • is_atomic으로 요청 받은 경우가 아니면 더 큰 배열 수를 확보하기 위해 64를 margin으로 대입한다.
  • if (chunk->map_alloc >= chunk->map_used + margin)
    • 맵이 사용된 수 + margin 보다 맵 관리 갯수(map_alloc)가 더 커서 여유가 있으면 함수를 빠져나간다.
    • 겱국 atomic  요청이 아닌 경우 64개 이하의 엔트리가 남는 경우 확장해야 할 갯수를 구하게 한다.
  • new_alloc = PCPU_DFL_MAP_ALLOC;
    • 맵 배열 초기 갯수로 16을 new_alloc에 우선 대입한다.
  • while (new_alloc < chunk->map_used + margin)
    • 맵이 사용된 수 + margin 보다 맵 관리 갯수(map_alloc)가 작은 동안
  • new_alloc *= 2;
    • 할당할 사이즈를 두 배로 키운다.
      • 16, 32, 64, 128, …

 

pcpu_extend_area_map()

/**
 * pcpu_extend_area_map - extend area map of a chunk
 * @chunk: chunk of interest
 * @new_alloc: new target allocation length of the area map
 *
 * Extend area map of @chunk to have @new_alloc entries.
 *
 * CONTEXT:
 * Does GFP_KERNEL allocation.  Grabs and releases pcpu_lock.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
static int pcpu_extend_area_map(struct pcpu_chunk *chunk, int new_alloc)
{
        int *old = NULL, *new = NULL;
        size_t old_size = 0, new_size = new_alloc * sizeof(new[0]);
        unsigned long flags;

        new = pcpu_mem_zalloc(new_size);
        if (!new)
                return -ENOMEM;

        /* acquire pcpu_lock and switch to new area map */
        spin_lock_irqsave(&pcpu_lock, flags);

        if (new_alloc <= chunk->map_alloc)
                goto out_unlock;

        old_size = chunk->map_alloc * sizeof(chunk->map[0]);
        old = chunk->map;

        memcpy(new, old, old_size);

        chunk->map_alloc = new_alloc;
        chunk->map = new;
        new = NULL;

out_unlock:
        spin_unlock_irqrestore(&pcpu_lock, flags);

        /*
         * pcpu_mem_free() might end up calling vfree() which uses
         * IRQ-unsafe lock and thus can't be called under pcpu_lock.
         */
        pcpu_mem_free(old, old_size);
        pcpu_mem_free(new, new_size);

        return 0;
}

chunk 내의 맵을 확장하고 기존 맵을 복사한 후 기존 맵은 해제한다.

 

pcpu_map_extend_workfn()

static void pcpu_map_extend_workfn(struct work_struct *work)
{
        struct pcpu_chunk *chunk = container_of(work, struct pcpu_chunk,
                                                map_extend_work);
        int new_alloc;

        spin_lock_irq(&pcpu_lock);
        new_alloc = pcpu_need_to_extend(chunk, false);
        spin_unlock_irq(&pcpu_lock);

        if (new_alloc)
                pcpu_extend_area_map(chunk, new_alloc);
}
  • chunk 스케쥴러를 통해 호출된다.
  • pcpu_need_to_extend() 함수를 통해 맵이 부족한가 파악하여 맵이 부족한 경우 pcpu_extend_area_map() 함수를 호출하여 맵을 확장한다.

 

pcpu_alloc_area()

mm/percpu.c

/**
 * pcpu_alloc_area - allocate area from a pcpu_chunk
 * @chunk: chunk of interest
 * @size: wanted size in bytes
 * @align: wanted align
 * @pop_only: allocate only from the populated area
 * @occ_pages_p: out param for the number of pages the area occupies
 *
 * Try to allocate @size bytes area aligned at @align from @chunk.
 * Note that this function only allocates the offset.  It doesn't
 * populate or map the area.
 *
 * @chunk->map must have at least two free slots.
 *
 * CONTEXT:
 * pcpu_lock.
 *
 * RETURNS:
 * Allocated offset in @chunk on success, -1 if no matching area is
 * found.
 */
static int pcpu_alloc_area(struct pcpu_chunk *chunk, int size, int align,
                           bool pop_only, int *occ_pages_p)
{
        int oslot = pcpu_chunk_slot(chunk);
        int max_contig = 0;
        int i, off;
        bool seen_free = false;
        int *p;

        for (i = chunk->first_free, p = chunk->map + i; i < chunk->map_used; i++, p++) {
                int head, tail;
                int this_size;

                off = *p;
                if (off & 1)
                        continue;

                this_size = (p[1] & ~1) - off;

                head = pcpu_fit_in_area(chunk, off, this_size, size, align,
                                        pop_only);
                if (head < 0) {
                        if (!seen_free) {
                                chunk->first_free = i;
                                seen_free = true;
                        }
                        max_contig = max(this_size, max_contig);
                        continue;
                }

                /*
                 * If head is small or the previous block is free,
                 * merge'em.  Note that 'small' is defined as smaller
                 * than sizeof(int), which is very small but isn't too
                 * uncommon for percpu allocations.
                 */
                if (head && (head < sizeof(int) || !(p[-1] & 1))) {
                        *p = off += head;
                        if (p[-1] & 1)
                                chunk->free_size -= head;
                        else
                                max_contig = max(*p - p[-1], max_contig);
                        this_size -= head;
                        head = 0;
                }

                /* if tail is small, just keep it around */
                tail = this_size - head - size;
                if (tail < sizeof(int)) {
                        tail = 0;
                        size = this_size - head;
                }

                /* split if warranted */
                if (head || tail) {
                        int nr_extra = !!head + !!tail;

                        /* insert new subblocks */
                        memmove(p + nr_extra + 1, p + 1,
                                sizeof(chunk->map[0]) * (chunk->map_used - i));
                        chunk->map_used += nr_extra;

                        if (head) {
                                if (!seen_free) {
                                        chunk->first_free = i;
                                        seen_free = true;
                                }
                                *++p = off += head;
                                ++i;
                                max_contig = max(head, max_contig);
                        }
                        if (tail) {
                                p[1] = off + size;
                                max_contig = max(tail, max_contig);
                        }
                }

                if (!seen_free)
                        chunk->first_free = i + 1;

                /* update hint and mark allocated */
                if (i + 1 == chunk->map_used)
                        chunk->contig_hint = max_contig; /* fully scanned */
                else
                        chunk->contig_hint = max(chunk->contig_hint,
                                                 max_contig);

                chunk->free_size -= size;
                *p |= 1;

                *occ_pages_p = pcpu_count_occupied_pages(chunk, i);
                pcpu_chunk_relocate(chunk, oslot);
                return off;
        }

        chunk->contig_hint = max_contig;        /* fully scanned */
        pcpu_chunk_relocate(chunk, oslot);

        /* tell the upper layer that this chunk has no matching area */
        return -1;
}

per-cpu chunk로부터 영역을 할당해온다.

  • int oslot = pcpu_chunk_slot(chunk);
    • 요청 chunk가 있는 슬롯을 가져온다.
  • for (i = chunk->first_free, p = chunk->map + i; i < chunk->map_used; i++, p++) {
    • chunk의 맵에서 첫 free 엔트리부터 마지막 맵 엔트리까지 루프를 돈다.
  • head = pcpu_fit_in_area(chunk, off, this_size, size, align, pop_only);
    • 맵에서 사용 가능한 공간을 찾는다. 결과 값이 -1인 경우 다음 맵을 찾는다. (head=정렬로 인해 할당할 공간 앞에 생긴 자투리 영역)
  • if (head && (head < sizeof(int) || !(p[-1] & 1))) {
    • 할당할 영역이 정렬을 이유로 앞에 head 만큼의 공간이 발생하였고 이 공간이 정수형 하나 들어갈 수 없이 작거나 이전 엔트리가 사용 중인 경우 현재 엔트리에 head 만큼의 공간을 더한다. 이렇게 자투리 공간은 무시하고 사용하지 못하게 한다.
  • tail = this_size – head – size;   if (tail < sizeof(int)) {
    • 할당할 영역의 뒷 부분의 공간 역시 정수형 하나 들어갈 수 없이 작으면 그 영역을 제거한다.
  • if (head || tail) {
    • 찾은 map 공간에 align으로 인해 발생한 head 영역과 배치하고 남은 tail 영역에 대해 map 엔트리를 최대 2개만큼 추가한다.
    • 각각의 head와 tail 영역이 sizeof(int)보다 적을 경우에는 해당 엔트리를 만들지 않도록 한다
  • if (i + 1 == chunk->map_used) chunk->contig_hint = max_contig; else chunk->contig_hint = max(chunk->contig_hint, max_contig);
    • contig_hint를 갱신한다.
  • chunk->free_size -= size; *p |= 1;
    • free_size를 줄이고, 해당 맵을 사용중으로 표기한다.
  • *occ_pages_p = pcpu_count_occupied_pages(chunk, i);
    • 현재의 map 영역에서 온전한 페이지 수를 알아온다. 다만 이전 map 영역이나 이후 map 영역이 1페이지 이상의 free 영역인 경우 partial 영역도 포함시킨다)
  • pcpu_chunk_relocate(chunk, oslot);
    • 할당 후 free_size가 변했으므로 이에 따라 적절한 slot을 찾아 이동한다

 

pcpu_fit_in_area()

mm/percpu.c

/**
 * pcpu_fit_in_area - try to fit the requested allocation in a candidate area
 * @chunk: chunk the candidate area belongs to
 * @off: the offset to the start of the candidate area
 * @this_size: the size of the candidate area
 * @size: the size of the target allocation
 * @align: the alignment of the target allocation
 * @pop_only: only allocate from already populated region
 *
 * We're trying to allocate @size bytes aligned at @align.  @chunk's area
 * at @off sized @this_size is a candidate.  This function determines
 * whether the target allocation fits in the candidate area and returns the
 * number of bytes to pad after @off.  If the target area doesn't fit, -1
 * is returned.
 *
 * If @pop_only is %true, this function only considers the already
 * populated part of the candidate area.
 */
static int pcpu_fit_in_area(struct pcpu_chunk *chunk, int off, int this_size,
                            int size, int align, bool pop_only)
{
        int cand_off = off;

        while (true) {
                int head = ALIGN(cand_off, align) - off;
                int page_start, page_end, rs, re;

                if (this_size < head + size)
                        return -1;

                if (!pop_only)
                        return head;

                /*
                 * If the first unpopulated page is beyond the end of the
                 * allocation, the whole allocation is populated;
                 * otherwise, retry from the end of the unpopulated area.
                 */
                page_start = PFN_DOWN(head + off);
                page_end = PFN_UP(head + off + size);

                rs = page_start;
                pcpu_next_unpop(chunk, &rs, &re, PFN_UP(off + this_size));
                if (rs >= page_end)
                        return head;
                cand_off = re * PAGE_SIZE;
        }
}

찾은 빈 공간의 위치를 바로 사용하는 것이 아니라 align 시켜 재조정된 위치를 찾는다. 만일 pop_only가 true인 경우 활성화된 페이지내에서만 공간을 잡는다. -1은 적당한 공간이 없음. 0은 찾은 공간이 fit 됨. 양수 값은 찾은 공간 앞에 정렬로 인해 해당 양수 값 만큼의 자투리 공간이 발생함.

  • 참고로 현재 버전의 커널 코드에서는 pop_only가 항상 false로 진입되는 상태이다.

 

할당 페이지 범위 활성화

pcpu_populate_chunk()

mm/percpu-vm.c

/**
 * pcpu_populate_chunk - populate and map an area of a pcpu_chunk
 * @chunk: chunk of interest
 * @page_start: the start page
 * @page_end: the end page
 *
 * For each cpu, populate and map pages [@page_start,@page_end) into
 * @chunk.
 *
 * CONTEXT:
 * pcpu_alloc_mutex, does GFP_KERNEL allocation.
 */
static int pcpu_populate_chunk(struct pcpu_chunk *chunk, 
                               int page_start, int page_end)
{
        struct page **pages;

        pages = pcpu_get_pages(chunk);
        if (!pages)
                return -ENOMEM;

        if (pcpu_alloc_pages(chunk, pages, page_start, page_end))
                return -ENOMEM;

        if (pcpu_map_pages(chunk, pages, page_start, page_end)) {
                pcpu_free_pages(chunk, pages, page_start, page_end);
                return -ENOMEM;
        }
        pcpu_post_map_flush(chunk, page_start, page_end);

        return 0;
}

chunk의 요청 페이지 범위에 대해 활성화(population)한다.

  • pages = pcpu_get_pages(chunk); if (!pages) return -ENOMEM;
    • 필요 page descriptor 만큼 할당을 받는다. 할당 실패시 -ENOMEM으로 반환한다.
  • if (pcpu_alloc_pages(chunk, pages, page_start, page_end)) return -ENOMEM;
    • 필요 페이지 범위를 cpu 수 만큼 할당 받는다. 할당 실패시 -ENOMEM으로 반환한다.
  • if (pcpu_map_pages(chunk, pages, page_start, page_end)) { pcpu_free_pages(chunk, pages, page_start, page_end); return -ENOMEM; }
    • 할당받은 영역 페이지들을 vmalloc 공간에 매핑시킨다.
  • pcpu_post_map_flush(chunk, page_start, page_end);
    • 매핑이 완료되면 TLB 캐시를 flush 한다.

 

pcpu_get_pages()

mm/percpu-vm.c

/**
 * pcpu_get_pages - get temp pages array
 * @chunk: chunk of interest
 *
 * Returns pointer to array of pointers to struct page which can be indexed
 * with pcpu_page_idx().  Note that there is only one array and accesses
 * should be serialized by pcpu_alloc_mutex.
 *
 * RETURNS:
 * Pointer to temp pages array on success.
 */
static struct page **pcpu_get_pages(struct pcpu_chunk *chunk_alloc)
{
        static struct page **pages;
        size_t pages_size = pcpu_nr_units * pcpu_unit_pages * sizeof(pages[0]);

        lockdep_assert_held(&pcpu_alloc_mutex);

        if (!pages)
                pages = pcpu_mem_zalloc(pages_size);
        return pages;
}

chunk 할당을 위해 전체 per-cpu 유닛에 필요한 page descriptor 사이즈 만큼 메모리 할당을 받아온다.

 

pcpu_map_pages()

mm/percpu-vm.c

/**
 * pcpu_map_pages - map pages into a pcpu_chunk
 * @chunk: chunk of interest
 * @pages: pages array containing pages to be mapped
 * @page_start: page index of the first page to map
 * @page_end: page index of the last page to map + 1
 *
 * For each cpu, map pages [@page_start,@page_end) into @chunk.  The
 * caller is responsible for calling pcpu_post_map_flush() after all
 * mappings are complete.
 *
 * This function is responsible for setting up whatever is necessary for
 * reverse lookup (addr -> chunk).
 */
static int pcpu_map_pages(struct pcpu_chunk *chunk,
                          struct page **pages, int page_start, int page_end)
{
        unsigned int cpu, tcpu;
        int i, err;

        for_each_possible_cpu(cpu) {
                err = __pcpu_map_pages(pcpu_chunk_addr(chunk, cpu, page_start),
                                       &pages[pcpu_page_idx(cpu, page_start)],
                                       page_end - page_start);
                if (err < 0)
                        goto err;

                for (i = page_start; i < page_end; i++)
                        pcpu_set_page_chunk(pages[pcpu_page_idx(cpu, i)],
                                            chunk);
        }
        return 0;
err:
        for_each_possible_cpu(tcpu) {
                if (tcpu == cpu)
                        break;
                __pcpu_unmap_pages(pcpu_chunk_addr(chunk, tcpu, page_start),
                                   page_end - page_start);
        }
        pcpu_post_unmap_tlb_flush(chunk, page_start, page_end);
        return err;
}

할당받은 영역 페이지들을 vmalloc 공간에 매핑시킨다

  • for_each_possible_cpu(cpu) { err = __pcpu_map_pages(pcpu_chunk_addr(chunk, cpu, page_start), &pages[pcpu_page_idx(cpu, page_start)], page_end – page_start);
    • possible cpu 수 만큼 루프를 돌며 per-cpu chunk를 vmalloc 공간에 매핑한다.
  • for (i = page_start; i < page_end; i++) pcpu_set_page_chunk(pages[pcpu_page_idx(cpu, i)], chunk);
    • 각 페이지(page->index)들이 pcpu_chunk를 가리키도록 설정한다.

 

__pcpu_map_pages()

mm/percpu-vm.c

static int __pcpu_map_pages(unsigned long addr, struct page **pages,
                            int nr_pages)
{
        return map_kernel_range_noflush(addr, nr_pages << PAGE_SHIFT,
                                        PAGE_KERNEL, pages);
}

할당받은 영역 페이지들을 요청 vmalloc 가상 주소 공간에 매핑시킨다

 

map_kernel_range_noflush()

mm/vmalloc.c

/**
 * map_kernel_range_noflush - map kernel VM area with the specified pages
 * @addr: start of the VM area to map
 * @size: size of the VM area to map
 * @prot: page protection flags to use
 * @pages: pages to map
 *
 * Map PFN_UP(@size) pages at @addr.  The VM area @addr and @size
 * specify should have been allocated using get_vm_area() and its
 * friends.
 *                          
 * NOTE:                                
 * This function does NOT do any cache flushing.  The caller is
 * responsible for calling flush_cache_vmap() on to-be-mapped areas
 * before calling this function.
 *
 * RETURNS:
 * The number of pages mapped on success, -errno on failure.
 */
int map_kernel_range_noflush(unsigned long addr, unsigned long size,
                             pgprot_t prot, struct page **pages)
{
        return vmap_page_range_noflush(addr, addr + size, prot, pages);
}

할당받은 영역 페이지들을 요청 vmalloc 가상 주소 공간에 vmap 매핑시킨다

 

참고

답글 남기기

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