문c 블로그

디버그 메모리 -3- (Page Owner 추적)

2019-07-192019-07-22 문영일 Leave a comment

디버그 메모리 -3- (Page Owner 추적)

사용 조건

CONFIG_PAGE_EXTENSION 커널 옵션
CONFIG_PAGE_OWNER 커널 옵션
“page_owner=on” 커널 파라미터

“/sys/kernel/debug/page_owner” 파일을 출력하여 모든 페이지들의 onwer 추적을 수행할 수 있다.
커널 v3.19-rc1에서 추가되었다.
- 참고: mm/page_owner: keep track of page owners

early_page_owner_param()

mm/page_owner.c

01static int early_page_owner_param(char *buf)
02{
03        if (!buf)
04                return -EINVAL;
05 
06        if (strcmp(buf, "on") == 0)
07                page_owner_disabled = false;
08 
09        return 0;
10}               
11early_param("page_owner", early_page_owner_param);

“page_owner=on” early 커널 파라메터를 사용하는 경우 페이지 owner 추적 기능을 사용한다.

need_page_owner()

mm/page_owner.c

1static bool need_page_owner(void)
2{
3        if (page_owner_disabled)
4                return false;
5 
6        return true;
7}

page owner 추적 기능이 필요한지 여부를 반환한다.

mm/page_owner.c

`1`	`static` `bool` `page_owner_disabled =` `true;`

init_page_owner()

mm/page_owner.c

1static void init_page_owner(void)
2{
3        if (page_owner_disabled)
4                return;
5 
6        page_owner_inited = true;
7        init_early_allocated_pages();
8}

page owner 추적 기능이 사용되는 경우 할당 페이지를 초기화한다.

mm/page_owner.c

`1`	`bool` `page_owner_inited __read_mostly;`

init_early_allocated_pages()

mm/page_owner.c

1static void init_early_allocated_pages(void)
2{
3        pg_data_t *pgdat;
4 
5        drain_all_pages(NULL);
6        for_each_online_pgdat(pgdat)
7                init_zones_in_node(pgdat);
8}

Per-CPU Page Frame Cache를 버디 할당자로 다시 돌려보내고 노드안에 있는 zone을 초기화한다.

참고: Per-CPU Page Frame Cache (zone->pageset) | 문c

init_zones_in_node()

mm/page_owner.c

01static void init_zones_in_node(pg_data_t *pgdat)
02{
03        struct zone *zone;
04        struct zone *node_zones = pgdat->node_zones;
05        unsigned long flags;
06         
07        for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
08                if (!populated_zone(zone))
09                        continue;
10 
11                spin_lock_irqsave(&zone->lock, flags);
12                init_pages_in_zone(pgdat, zone);
13                spin_unlock_irqrestore(&zone->lock, flags);
14        }       
15}

해당 노드에 대해 populate zone에 속한 페이지를 초기화한다.

init_pages_in_zone()

mm/page_owner.c

01static void init_pages_in_zone(pg_data_t *pgdat, struct zone *zone)
02{
03        struct page *page;
04        struct page_ext *page_ext;
05        unsigned long pfn = zone->zone_start_pfn, block_end_pfn;
06        unsigned long end_pfn = pfn + zone->spanned_pages;
07        unsigned long count = 0;
08 
09        /* Scan block by block. First and last block may be incomplete */
10        pfn = zone->zone_start_pfn;
11 
12        /*
13         * Walk the zone in pageblock_nr_pages steps. If a page block spans
14         * a zone boundary, it will be double counted between zones. This does
15         * not matter as the mixed block count will still be correct
16         */
17        for (; pfn < end_pfn; ) {
18                if (!pfn_valid(pfn)) {
19                        pfn = ALIGN(pfn + 1, MAX_ORDER_NR_PAGES);
20                        continue;
21                }
22 
23                block_end_pfn = ALIGN(pfn + 1, pageblock_nr_pages);
24                block_end_pfn = min(block_end_pfn, end_pfn);
25 
26                page = pfn_to_page(pfn);
27 
28                for (; pfn < block_end_pfn; pfn++) {
29                        if (!pfn_valid_within(pfn))
30                                continue;
31 
32                        page = pfn_to_page(pfn);
33 
34                        /*
35                         * We are safe to check buddy flag and order, because
36                         * this is init stage and only single thread runs.
37                         */
38                        if (PageBuddy(page)) {
39                                pfn += (1UL << page_order(page)) - 1;
40                                continue;
41                        }
42 
43                        if (PageReserved(page))
44                                continue;
45 
46                        page_ext = lookup_page_ext(page);
47 
48                        /* Maybe overraping zone */
49                        if (test_bit(PAGE_EXT_OWNER, &page_ext->flags))
50                                continue;
51 
52                        /* Found early allocated page */
53                        set_page_owner(page, 0, 0);
54                        count++;
55                }
56        }
57 
58        pr_info("Node %d, zone %8s: page owner found early allocated %lu pages\n",
59                pgdat->node_id, zone->name, count);
60}

zone에 구성된 페이지 중 onwer 설정이 필요한 경우 page_ext[]에서 해당 페이지를 찾아 owner 비트를 설정한다.

set_page_owner()

include/linux/page_owner.h

1static inline void set_page_owner(struct page *page,
2                        unsigned int order, gfp_t gfp_mask)
3{
4        if (likely(!page_owner_inited))
5                return; 
6 
7        __set_page_owner(page, order, gfp_mask);
8}

page_ext[]의 해당 페이지에 owner 비트를 설정한다.

__set_page_owner()

mm/page_owner.c

01void __set_page_owner(struct page *page, unsigned int order, gfp_t gfp_mask)
02{
03        struct page_ext *page_ext = lookup_page_ext(page);
04        struct stack_trace trace = {
05                .nr_entries = 0,
06                .max_entries = ARRAY_SIZE(page_ext->trace_entries),
07                .entries = &page_ext->trace_entries[0],
08                .skip = 3,
09        };
10 
11        save_stack_trace(&trace);
12 
13        page_ext->order = order;
14        page_ext->gfp_mask = gfp_mask;
15        page_ext->nr_entries = trace.nr_entries;
16 
17        __set_bit(PAGE_EXT_OWNER, &page_ext->flags);
18}

page_ext에 owner를 설정한다.

reset_page_owner()

include/linux/page_owner.h

1static inline void reset_page_owner(struct page *page, unsigned int order)
2{
3        if (likely(!page_owner_inited))
4                return;
5 
6        __reset_page_owner(page, order);
7}

2^order 만큼의 페이지들에 대항하는 page_ext의 owner 비트를 clear한다.

__reset_page_owner()

mm/page_owner.c

01void __reset_page_owner(struct page *page, unsigned int order)
02{
03        int i;
04        struct page_ext *page_ext;
05 
06        for (i = 0; i < (1 << order); i++) {
07                page_ext = lookup_page_ext(page + i);
08                __clear_bit(PAGE_EXT_OWNER, &page_ext->flags);
09        }
10}

2^order 만큼의 페이지들에 대항하는 page_ext의 owner 비트를 clear한다.

page_owner 분석을 위한 덤프

01$ cat /sys/kernel/debug/page_owner
02Page allocated via order 0, mask 0x6212ca(GFP_HIGHUSER_MOVABLE|__GFP_NOWARN|__GFP_NORETRY)
03PFN 262144 type Movable Block 512 type Movable Flags 0xfffc00000020836(referenced|uptodate|lru|activ
04e|arch_1|mappedtodisk)
05 get_page_from_freelist+0x1050/0x1e68
06 __alloc_pages_nodemask+0x220/0xffc
07 alloc_pages_current+0xac/0xe8
08 __page_cache_alloc+0x130/0x138
09 __do_page_cache_readahead+0x118/0x2c4
10 filemap_fault+0x3d4/0x9a0
11 ext4_filemap_fault+0x44/0x60
12 __do_fault+0x7c/0x33c
13 __handle_mm_fault+0x112c/0x1cd0
14 handle_mm_fault+0x1b0/0x27c
15 do_page_fault+0x290/0x4d8
16 do_translation_fault+0x88/0x8c
17 do_mem_abort+0x58/0xe8
18 el0_da+0x20/0x24
19 
20Page allocated via order 0, mask 0x6212ca(GFP_HIGHUSER_MOVABLE|__GFP_NOWARN|__GFP_NORETRY)
21PFN 262148 type Movable Block 512 type Movable Flags 0xfffc00000020836(referenced|uptodate|lru|activ
22e|arch_1|mappedtodisk)
23 get_page_from_freelist+0x1050/0x1e68
24 __alloc_pages_nodemask+0x220/0xffc
25 alloc_pages_current+0xac/0xe8
26 __page_cache_alloc+0x130/0x138
27 __do_page_cache_readahead+0x118/0x2c4
28 filemap_fault+0x3d4/0x9a0
29 ext4_filemap_fault+0x44/0x60
30 __do_fault+0x7c/0x33c
31 __handle_mm_fault+0x112c/0x1cd0
32 handle_mm_fault+0x1b0/0x27c
33 do_page_fault+0x290/0x4d8
34 do_translation_fault+0x88/0x8c
35 do_mem_abort+0x58/0xe8
36 el0_da+0x20/0x24
37 
38...(생략)...

참고

Useful gadget: /proc/page_owner | LWN.net
page owner: Tracking about who allocated each page | Kernel.org
PAGE_OWNER | barrios kernel story

디버그 메모리 -2- (Page Poisoning)

2019-07-192019-07-19 문영일 Leave a comment

디버그 메모리 -2- (Page Poisoning)

free 페이지에 poison 표식을 한 후 페이지 할당 시마다 poison 표식을 확인하여 다음과 같이 오염된 경우 이에 대한 메시지 출력과 메모리 덤프 및 스택 트레이싱을 출력한다. 출력 내용은 rate limit이 걸려있으므로 5초 간격 이내에 10회까지로 출력을 제한한다.

비트 하나만 바뀐 경우
- “pagealloc: single bit error”
그 외
- “pagealloc: memory corruption”

사용 조건

CONFIG_PAGE_POISONING 커널 옵션
CONFIG_PAGE_POISONING_NO_SANITY 커널 옵션을 사용하는 경우 poison 체크는 skip 한다.
- CONFIG_HIBERNATION을 사용하면 항상 CONFIG_PAGE_POISONING_NO_SANITY 가 enable 된다. 따라서 poison check를 수행하려면 하이버네이션 기능을 꺼야한다.
“page_poison” 커널 파라미터

이 기능은 커널 v4.12-rc1에서 page_ext 구조체를 사용하다 부트업에서 처리하는 것으로 바뀌었다.
- 더 이상 CONFIG_PAGE_EXTENSION 을 사용하지 않는다.
- 참고: mm: enable page poisoning early at boot

Early 커널 파라메터로 설정

early_page_poison_param()

mm/page_poison.c

1static int __init early_page_poison_param(char *buf)
2{
3        if (!buf)
4                return -EINVAL;
5        return strtobool(buf, &want_page_poisoning);
6}
7early_param("page_poison", early_page_poison_param);

mm/page_poison.c

`1`	`static` `bool` `want_page_poisoning __read_mostly;`

kernel_poison_pages()

이 함수가 호출되는 곳은 다음과 같다.

페이지 할당 과정
- post_alloc_hook() 함수에서 kernel_poison_pages(page, 1 << order, 1);와 같이 호출된다.
페이지 회수 과정
- free_pages_prepare() 함수에서 kernel_poison_pages(page, 1 << order, 0);와 같이 호출된다.

mm/page_poison.c

01void kernel_poison_pages(struct page *page, int numpages, int enable)
02{
03        if (!page_poisoning_enabled())
04                return;
05 
06        if (enable)
07                unpoison_pages(page, numpages);
08        else
09                poison_pages(page, numpages);
10}

@page 부터 @numpages 수 만큼의 페이지 프레임을 대상으로 @enable 여부에 따라 poison 표식을 하거나 제거한다. 제거할 때에는 poison 체크를 수행하여 해당 페이지의 침범 등의 이상 여부를 알아낸다.

코드 라인 3~4에서 “page_poison” 커널 파라미터가 지정되지 않은 경우 함수를 빠져나간다.
코드 라인 6~7에서 페이지 할당 과정에서 @enable이 1로 요청되는데, 이 때 요청한 페이지 프레임 내용을 모두 poison 값으로 채운다.
코드 라인 8~9에서 페이지 회수 과정에서 @enable이 0으로 요청되는데, 이 때 요청한 페이지 프레임 내용을 조사하여 poison 값이 아닌 경우 해당 메모리 덤프 및 stack 트레이싱 출력을 수행한다.

메모리 할당 시 unpoison 과정에서 poison 표식 훼손 체크

unpoison_pages()

mm/page_poison.c

1static void unpoison_pages(struct page *page, int n)
2{
3        int i;
4 
5        for (i = 0; i < n; i++)
6                unpoison_page(page + i);
7}

@page 페이지 프레임부터 @n 개 페이지 프레임 내용을 조사하여 poison 표식이 훼손된 경우 해당 메모리 덤프 및 stack 트레이싱 출력을 수행한다.

unpoison_page()

mm/page_poison.c

01static void unpoison_page(struct page *page)
02{
03        void *addr;
04 
05        addr = kmap_atomic(page);
06        /*
07         * Page poisoning when enabled poisons each and every page
08         * that is freed to buddy. Thus no extra check is done to
09         * see if a page was posioned.
10         */
11        check_poison_mem(addr, PAGE_SIZE);
12        kunmap_atomic(addr);
13}

@page 페이지 프레임 내용을 조사하여 poison 표식이 훼손된 경우 해당 메모리 덤프 및 stack 트레이싱 출력을 수행한다.

check_poison_mem()

mm/page_poison.c

01static void check_poison_mem(unsigned char *mem, size_t bytes)
02{
03        static DEFINE_RATELIMIT_STATE(ratelimit, 5 * HZ, 10);
04        unsigned char *start;
05        unsigned char *end;
06 
07        if (IS_ENABLED(CONFIG_PAGE_POISONING_NO_SANITY))
08                return;
09 
10        start = memchr_inv(mem, PAGE_POISON, bytes);
11        if (!start)
12                return;
13 
14        for (end = mem + bytes - 1; end > start; end--) {
15                if (*end != PAGE_POISON)
16                        break;
17        }
18 
19        if (!__ratelimit(&ratelimit))
20                return;
21        else if (start == end && single_bit_flip(*start, PAGE_POISON))
22                pr_err("pagealloc: single bit error\n");
23        else
24                pr_err("pagealloc: memory corruption\n");
25 
26        print_hex_dump(KERN_ERR, "", DUMP_PREFIX_ADDRESS, 16, 1, start,
27                        end - start + 1, 1);
28        dump_stack();
29}

@mem 주소부터 @bytes 만큼 메모리 내용을 조사하여 poison 표식이 훼손된 경우 해당 메모리 덤프 및 stack 트레이싱 출력을 수행한다.

력 형태는 두 가지로 출력한다.
- 1 비트만 훼손된 경우 “pagealloc: single bit error” 메시지 출력
- 그 외의 경우 “pagealloc: memory corruption” 메시지 출력

single_bit_flip()

mm/page_poison.c

1static bool single_bit_flip(unsigned char a, unsigned char b)
2{
3        unsigned char error = a ^ b;
4 
5        return error && !(error & (error - 1));
6}

주어진 @a 와 @b 바이트에서 1개 비트만 다른 경우 1을 반환한다.

메모리 회수 시 poison 표식

poison_pages()

mm/page_poison.c

1static void poison_pages(struct page *page, int n)
2{
3        int i;
4 
5        for (i = 0; i < n; i++)
6                poison_page(page + i);
7}

@page에 해당하는 페이지 프레임부터 n개 페이지 프레임의 내용을 PAGE_POISON(0xaa) 값으로 표식한다.

poison_page()

mm/page_poison.c

1static void poison_page(struct page *page)
2{
3        void *addr = kmap_atomic(page);
4 
5        memset(addr, PAGE_POISON, PAGE_SIZE);
6        kunmap_atomic(addr);
7}

@page에 해당하는 한 페이지 프레임의 내용을 PAGE_POISON(0xaa) 값으로 표식한다.

CONFIG_PAGE_POISONING_ZERO 커널 옵션을 사용하는 경우 PAGE_POISON 값으로 0x00을 사용할 수도 있다.

참고

디버그 메모리 -1- (Page Alloc)

2019-07-192019-07-22 문영일 Leave a comment

디버그 메모리 -1- (Page Alloc)

minorder 미만의 페이지들 할당 시마다 별도의 가드 페이지를 준비하고, 이 페이지에 접근(R/W)하는 경우 예외를 발생시키기 위해 사용된다. 버디 시스템에서 minorder 미만의 페이지들에 대해 이에 대응하는 버디 페이지들을 별도의 가드 페이지들로 활용하기 위해 guard 플래그를 가진채로 free_list에서 제외된다. 이 guard 페이지들은 유저 가상 주소에 매핑하지 않으므로 접근할 수 없다.

사용 조건

CONFIG_PAGE_EXTENSION & CONFIG_DEBUG_PAGEALLOC 커널 옵션
- 커널 v5.3-rc1 부터는 CONFIG_PAGE_EXTENSION 없이도 동작한다.
CONFIG_HIBERNATION과 같이 사용할 수 없다.
“debug_pagealloc=on” 커널 파라미터
“debug_guardpage_minorder=<minorder>” 커널 파라미터
- minorder는 디폴트 값으로 가드 페이지가 동작하지 않는 0 이고, 최대 MAX_ORDER의 절반까지 지정될 수 있다.
- 이 값 이상의 페이지들은 가드 페이지들을 생성하지 않는다.
- 이 값이 크면 클 수록 메모리 낭비가 커진다.

이 기능은 커널 v5.3-rc1에서 page_ext 구조체를 사용하다 page 구조체로 이전시켰다.
- 참고: mm, debug_pagealloc: use a page type instead of page_ext flag

다음 그림은 가드 페이지를 사용하지 않는 보통 상태의 버디 시스템에서 페이지 할당을 보여준다.

다음 그림은 가드 페이지를 사용할 때 할당되는 페이지와 인접한 추가 가드 페이지들을 보여준다.

need_debug_guardpage()

mm/page_alloc.c

01static bool need_debug_guardpage(void)
02{
03        /* If we don't use debug_pagealloc, we don't need guard page */
04        if (!debug_pagealloc_enabled())
05                return false; 
06 
07        if (!debug_guardpage_minorder())
08                return false;
09        return true;
10}

가드 페이지 디버깅이 필요한지 여부를 반환한다.

디버그용 guard 페이지를 사용하지 않는 경우에도 false를 반환한다.

debug_pagealloc_enabled()

include/linux/mm.h

1static inline bool debug_pagealloc_enabled(void) 
2{       
3        return _debug_pagealloc_enabled;
4}

페이지 할당 디버깅 기능 사용 여부를 반환한다.

debug_guardpage_minorder()

include/linux/mm.h

1static inline unsigned int debug_guardpage_minorder(void)
2{
3        return _debug_guardpage_minorder;
4}

디버그용 guard 페이지로 설정된 최소 order 값을 반환한다.

“debug_guardpage_minorder=” 커널 파라메터 값은 1~MAX_ORDER의 절반까지 가능하다.
- MAX_ORDER가 11인 경우 1~5까지 설정 가능하다.

init_debug_guardpage()

mm/page_alloc.c

1static void init_debug_guardpage(void)
2{                           
3        if (!debug_pagealloc_enabled())
4                return;
5 
6        _debug_guardpage_enabled = true; 
7}

가드 페이지 디버깅 기능을 enable 한다.

page_is_guard()

include/linux/mm.h

01#ifdef CONFIG_DEBUG_PAGEALLOC
02static inline bool page_is_guard(struct page *page)
03{       
04        struct page_ext *page_ext;
05 
06        if (!debug_guardpage_enabled())
07                return false;
08 
09        page_ext = lookup_page_ext(page); 
10        return test_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags);
11}
12#endif

페이지에 대항하는 page_ext의 guard 플래그 비트가 설정되었는지 여부를 반환한다.

clear_page_guard()

mm/page_alloc.c

01static inline void clear_page_guard(struct zone *zone, struct page *page,
02                                unsigned int order, int migratetype)
03{
04        struct page_ext *page_ext;
05 
06        if (!debug_guardpage_enabled())
07                return;
08 
09        page_ext = lookup_page_ext(page);
10        __clear_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags);
11 
12        set_page_private(page, 0);
13        if (!is_migrate_isolate(migratetype))
14                __mod_zone_freepage_state(zone, (1 << order), migratetype);
15}

페이지에 대항하는 page_ext의 guard 플래그 비트를 clear 하고 _private에 0을 대입한다. zone에 대한 free page stat도 2^order 만큼 증가시킨다.

버디 페이지 expand 시 Guard 페이지로 사용

expand()

mm/page_alloc.c

01/*
02 * The order of subdivision here is critical for the IO subsystem.
03 * Please do not alter this order without good reasons and regression
04 * testing. Specifically, as large blocks of memory are subdivided,
05 * the order in which smaller blocks are delivered depends on the order
06 * they're subdivided in this function. This is the primary factor
07 * influencing the order in which pages are delivered to the IO
08 * subsystem according to empirical testing, and this is also justified
09 * by considering the behavior of a buddy system containing a single
10 * large block of memory acted on by a series of small allocations.
11 * This behavior is a critical factor in sglist merging's success.
12 *
13 * -- nyc
14 */

01static inline void expand(struct zone *zone, struct page *page,
02        int low, int high, struct free_area *area,
03        int migratetype)
04{
05        unsigned long size = 1 << high;
06 
07        while (high > low) {
08                area--;
09                high--;
10                size >>= 1;
11                VM_BUG_ON_PAGE(bad_range(zone, &page[size]), &page[size]);
12 
13                /*
14                 * Mark as guard pages (or page), that will allow to
15                 * merge back to allocator when buddy will be freed.
16                 * Corresponding page table entries will not be touched,
17                 * pages will stay not present in virtual address space
18                 */
19                if (set_page_guard(zone, &page[size], high, migratetype))
20                        continue;
21 
22                list_add(&page[size].lru, &area->free_list[migratetype]);
23                area->nr_free++;
24                set_page_order(&page[size], high);
25        }
26}

버디 시스템에서 요청한 order 페이지가 부족한 경우 더 큰 order 페이지를 확장하여 사용할 수 있는데 이 때 호출되어 동작하는 expand() 함수이다. 가드 페이지와 관련된 코드만을 잠시 살펴본다.

코드 라인 10에서 size에는 할당할 페이지의 다음 페이지인 버디 페이지를 가드 페이지로 사용하기 위해 얻어온다.
코드 라인 19~20에서 guard 페이지를 사용하는 경우 guard 페이지 플래그를 설정한다. 그 후 가드 페이지는 free_list에 추가하지 않기 위해 skip 한다.

page_is_guard()

mm/page_alloc.c

01static inline bool page_is_guard(struct page *page)
02{
03        struct page_ext *page_ext;
04 
05        if (!debug_guardpage_enabled())
06                return false;
07 
08        page_ext = lookup_page_ext(page);
09        if (unlikely(!page_ext))
10                return false;
11 
12        return test_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags);
13}

@page가 가드 페이지인지 여부를 알아온다.

가드 페이지 지정

set_page_guard()

mm/page_alloc.c

01static inline bool set_page_guard(struct zone *zone, struct page *page,
02                                unsigned int order, int migratetype)
03{
04        struct page_ext *page_ext;
05 
06        if (!debug_guardpage_enabled())
07                return false;
08 
09        if (order >= debug_guardpage_minorder())
10                return false;
11 
12        page_ext = lookup_page_ext(page);
13        if (unlikely(!page_ext))
14                return false;
15 
16        __set_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags);
17 
18        INIT_LIST_HEAD(&page->lru);
19        set_page_private(page, order);
20        /* Guard pages are not available for any usage */
21        __mod_zone_freepage_state(zone, -(1 << order), migratetype);
22 
23        return true;
24}

@page를 guard 페이지로 지정한다. 정상적으로 설정한 경우 true를 반환한다.

guard 페이지는 private 멤버에 order 값이 지정되고, 확장 페이지에 guard 플래그가 설정된다.

가드 페이지 지정 해제

clear_page_guard()

mm/page_alloc.c

01static inline void clear_page_guard(struct zone *zone, struct page *page,
02                                unsigned int order, int migratetype)
03{
04        struct page_ext *page_ext;
05 
06        if (!debug_guardpage_enabled())
07                return;
08 
09        page_ext = lookup_page_ext(page);
10        if (unlikely(!page_ext))
11                return;
12 
13        __clear_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags);
14 
15        set_page_private(page, 0);
16        if (!is_migrate_isolate(migratetype))
17                __mod_zone_freepage_state(zone, (1 << order), migratetype);
18}

@page가 guard 페이지인 경우 취소한다.

private 멤버에 0 값이 지정되고, 확장 페이지에 guard 플래그를 클리어한다.

Early 커널 파라메터

early_debug_pagealloc()

mm/page_alloc.c

01static int __init early_debug_pagealloc(char *buf)
02{
03        if (!buf)
04                return -EINVAL;
05 
06        if (strcmp(buf, "on") == 0)
07                _debug_pagealloc_enabled = true;
08         
09        return 0;
10}       
11early_param("debug_pagealloc", early_debug_pagealloc);

“debug_pagealloc=on” early 커널 파라메터를 사용하는 경우 페이지 할당 디버깅 기능을 사용한다.

커널 Tools

tools/vm에서 make를 사용하여 빌드하면 3개의 유틸리티가 생성된다.

page-types
- 참조하는 proc 인터페이스들
  - /proc/<pid>/pagemap
  - /proc/<pid>maps
  - /proc/self/pagemap
  - /proc/kpageflags
  - /proc/kpagecount
  - /proc/kpagecgroup
  - /sys/kernel/mm/page_idle/bitmap
page_owner_sort
slabinfo

page-types

이 유틸리티를 통해 페이지 타입 유형들을 알아볼 수 있다.

옵션을 사용하여 특정 가상 주소, 태스크, 파일에 관여된 페이지 타입들을 관찰할 수 있다.

$ tools/vm/page-types --help
page-types [options]
            -r|--raw                   Raw mode, for kernel developers
            -d|--describe flags        Describe flags
            -a|--addr    addr-spec     Walk a range of pages
            -b|--bits    bits-spec     Walk pages with specified bits
            -c|--cgroup  path|@inode   Walk pages within memory cgroup
            -p|--pid     pid           Walk process address space
            -f|--file    filename      Walk file address space
            -i|--mark-idle             Mark pages idle
            -l|--list                  Show page details in ranges
            -L|--list-each             Show page details one by one
            -C|--list-cgroup           Show cgroup inode for pages
            -M|--list-mapcnt           Show page map count
            -N|--no-summary            Don't show summary info
            -X|--hwpoison              hwpoison pages
            -x|--unpoison              unpoison pages
            -F|--kpageflags filename   kpageflags file to parse
            -h|--help                  Show this usage message
flags:
            0x10                       bitfield format, e.g.
            anon                       bit-name, e.g.
            0x10,anon                  comma-separated list, e.g.
addr-spec:
            N                          one page at offset N (unit: pages)
            N+M                        pages range from N to N+M-1
            N,M                        pages range from N to M-1
            N,                         pages range from N to end
            ,M                         pages range from 0 to M-1
bits-spec:
            bit1,bit2                  (flags & (bit1|bit2)) != 0
            bit1,bit2=bit1             (flags & (bit1|bit2)) == bit1
            bit1,~bit2                 (flags & (bit1|bit2)) == bit1
            =bit1,bit2                 flags == (bit1|bit2)
bit-names:
          locked              error         referenced           uptodate
           dirty                lru             active               slab
       writeback            reclaim              buddy               mmap
       anonymous          swapcache         swapbacked      compound_head
   compound_tail               huge        unevictable           hwpoison
          nopage                ksm                thp            balloon
       zero_page          idle_page            pgtable           reserved(r)
         mlocked(r)    mappedtodisk(r)         private(r)       private_2(r)
   owner_private(r)            arch(r)        uncached(r)       softdirty(r)
       readahead(o)       slob_free(o)     slub_frozen(o)      slub_debug(o)
            file(o)            swap(o)  mmap_exclusive(o)
                                   (r) raw mode bits  (o) overloaded bits

$ tools/vm/page-types
             flags      page-count       MB  symbolic-flags                     long-symbolic-flags
0x0000000000000000           92360      360  ___________________________________________
0x0000000000100000             512        2  ____________________n______________________        nopage
0x0000000001000000               1        0  ________________________z__________________        zero_page
0x0000000000000014              10        0  __R_D______________________________________        referenced,dirty
0x0000000000000020              18        0  _____l_____________________________________        lru
0x0000000000000024              16        0  __R__l_____________________________________        referenced,lru
0x0000000000000028          102116      398  ___U_l_____________________________________        uptodate,lru
0x0000000000004028            1536        6  ___U_l________b____________________________        uptodate,lru,swapbacked
0x000000000000002c           90364      352  __RU_l_____________________________________        referenced,uptodate,lru
0x0000000000004030           11454       44  ____Dl________b____________________________        dirty,lru,swapbacked
0x000000000000403c           15846       61  __RUDl________b____________________________        referenced,uptodate,dirty,lru,swapbacked
0x0000000000000040               1        0  ______A____________________________________        active
0x0000000000000060            7293       28  _____lA____________________________________        lru,active
0x0000000000000064           19994       78  __R__lA____________________________________        referenced,lru,active
0x0000000000000068          340912     1331  ___U_lA____________________________________        uptodate,lru,active
0x000000000000006c          233190      910  __RU_lA____________________________________        referenced,uptodate,lru,active
0x0000000000000074               4        0  __R_DlA____________________________________        referenced,dirty,lru,active
0x0000000000004078           16146       63  ___UDlA_______b____________________________        uptodate,dirty,lru,active,swapbacked
0x0000000000000078               1        0  ___UDlA____________________________________        uptodate,dirty,lru,active
0x000000000000407c              91        0  __RUDlA_______b____________________________        referenced,uptodate,dirty,lru,active,swapbacked
0x000000000000007c               1        0  __RUDlA____________________________________        referenced,uptodate,dirty,lru,active
0x0000000000000080           37452      146  _______S___________________________________        slab
0x0000000000000228            2202        8  ___U_l___I_________________________________        uptodate,lru,reclaim
0x0000000000000268              26        0  ___U_lA__I_________________________________        uptodate,lru,active,reclaim
0x0000000000000400             965        3  __________B________________________________        buddy
0x0000000000000800               1        0  ___________M_______________________________        mmap
0x0000000000000804               1        0  __R________M_______________________________        referenced,mmap
0x0000000000000828             232        0  ___U_l_____M_______________________________        uptodate,lru,mmap
0x0000000000004828               8        0  ___U_l_____M__b____________________________        uptodate,lru,mmap,swapbacked
0x0000000000004838            4600       17  ___UDl_____M__b____________________________        uptodate,dirty,lru,mmap,swapbacked
0x000000000000483c               2        0  __RUDl_____M__b____________________________        referenced,uptodate,dirty,lru,mmap,swapbacked
0x0000000000000868             173        0  ___U_lA____M_______________________________        uptodate,lru,active,mmap
0x000000000000086c            4925       19  __RU_lA____M_______________________________        referenced,uptodate,lru,active,mmap
0x0000000000004878               1        0  ___UDlA____M__b____________________________        uptodate,dirty,lru,active,mmap,swapbacked
0x0000000000005048               3        0  ___U__A_____a_b____________________________        uptodate,active,anonymous,swapbacked
0x0000000000005848               2        0  ___U__A____Ma_b____________________________        uptodate,active,mmap,anonymous,swapbacked
0x0000000000005868           33295      130  ___U_lA____Ma_b____________________________        uptodate,lru,active,mmap,anonymous,swapbacked
0x000000000000586c              54        0  __RU_lA____Ma_b____________________________        referenced,uptodate,lru,active,mmap,anonymous,swapbacked
             total         1015808     3968

특정 유저 태스크(–pid 옵션)가 사용한 페이지 타입들을 보여준다.

$ tools/vm/page-types --pid 959
             flags      page-count       MB  symbolic-flags                     long-symbolic-flags
0x0000000000000800               1        0  ___________M_______________________________        mmap
0x0000000000000804               1        0  __R________M_______________________________        referenced,mmap
0x000000000000086c            1271        4  __RU_lA____M_______________________________        referenced,uptodate,lru,active,mmap
0x0000000000005868             311        1  ___U_lA____Ma_b____________________________        uptodate,lru,active,mmap,anonymous,swapbacked
0x000000000000586c               1        0  __RU_lA____Ma_b____________________________        referenced,uptodate,lru,active,mmap,anonymous,swapbacked
             total            1585        6

특정 파일(–file 옵션)에 사용한 페이지 타입들을 보여준다.

$ tools/vm/page-types --file abc.txt
             flags      page-count       MB  symbolic-flags                     long-symbolic-flags
0x0000000000000068               1        0  ___U_lA____________________________________        uptodate,lru,active
             total               1        0

참고

copy_from_user()

2019-07-152020-03-17 문영일 2 Comments

프로세스 주소 공간(process address space)을 access하는 커널 API

가장 잘 알려진 다음 API 두 개를 알아본다.

copy_from_user()
copy_to_user()

그리고 유저 프로세스 공간으로의 안전한 접근이 가능한지 여부를 체크하는 다음 API를 알아본다.

access_ok()

유저 프로세스 공간으로 부터 커널로 데이터 복사

copy_from_user()

include/linux/uaccess.h

1static __always_inline unsigned long __must_check
2copy_from_user(void *to, const void __user *from, unsigned long n)
3{
4        if (likely(check_copy_size(to, n, false)))
5                n = _copy_from_user(to, from, n);
6        return n;
7}

유저 가상 주소 @from에서 @n 바이트만큼 커널 가상 주소 @to로 데이터를 복사한다.

_copy_from_user()

include/linux/uaccess.h

01#ifdef INLINE_COPY_FROM_USER
02static inline unsigned long
03_copy_from_user(void *to, const void __user *from, unsigned long n)
04{
05        unsigned long res = n;
06        might_fault();
07        if (likely(access_ok(from, n))) {
08                kasan_check_write(to, n);
09                res = raw_copy_from_user(to, from, n);
10        }
11        if (unlikely(res))
12                memset(to + (n - res), 0, res);
13        return res;
14}
15#endif

이 함수는 유저 application에서 사용될 때에는 INLINE_COPY_FROM_USER 옵션이 적용되어 인라인 함수로 제공된다. 그렇지 않고 커널을 통해 호출되는 경우 라이브러리를 통해 제공된다.

아키텍처별 raw_copy_from_user()

다음 아키텍처별로 권한 설정을 아키텍처 고유의 방법을 사용한다.

ARM32
- 도메인 접근 제어 레지스터를 사용하여 제어한다.
ARM64
- 커널에서의 유저 액세스 권한 제어 플래그를 사용하여 제어한다.

raw_copy_from_user() – ARM64

arch/arm64/include/asm/uaccess.h

1#define raw_copy_from_user(to, from, n)                                 \
2({                                                                      \
3        __arch_copy_from_user((to), __uaccess_mask_ptr(from), (n));     \
4})

유저 가상 주소 @from(x1)에서 @n 바이트(x2)만큼 커널 가상 주소 @to(x0)로 복사한다.

다음 그림은 ARM64 시스템에서 copy_from_user() 함수의 처리 흐름을 보여준다.

__arch_copy_from_user() – ARM64

arch/arm64/lib/copy_from_user.S

1ENTRY(__arch_copy_from_user)
2        uaccess_enable_not_uao x3, x4, x5
3        add     end, x0, x2
4#include "copy_template.S"
5        uaccess_disable_not_uao x3, x4
6        mov     x0, #0                          // Nothing to copy
7        ret
8ENDPROC(__arch_copy_from_user)
9EXPORT_SYMBOL(__arch_copy_from_user)

커널이 유저 데이터에 접근할 수 있도록 잠시 허용한 후 유저 가상 주소 src(x1)에서 n 바이트(x2)만큼 커널 가상 주소 dest(x0)로 복사한다. 그런 후 커널이 유저 데이터에 접근하지 못하게 막는다.

copy_template.S 에는 어셈블리로 복사 코드가 담겨있다.

raw_copy_from_user() – ARM32

arch/arm/include/asm/uaccess.h

01static inline unsigned long __must_check
02raw_copy_from_user(void *to, const void __user *from, unsigned long n)
03{
04        unsigned int __ua_flags;
05 
06        __ua_flags = uaccess_save_and_enable();
07        n = arm_copy_from_user(to, from, n);
08        uaccess_restore(__ua_flags);
09        return n;
10}

유저 가상 주소 @from(r1)에서 @n 바이트(r2)만큼 커널 가상 주소 @to(r0)로 복사한다.

다음 그림은 ARM32 시스템에서 copy_from_user() 함수의 처리 흐름을 보여준다.

arm_copy_from_user()

lib/copy_from_user.S

01ENTRY(arm_copy_from_user)
02#ifdef CONFIG_CPU_SPECTRE
03        get_thread_info r3
04        ldr     r3, [r3, #TI_ADDR_LIMIT]
05        uaccess_mask_range_ptr r1, r2, r3, ip
06#endif
07 
08#include "copy_template.S"
09 
10ENDPROC(arm_copy_from_user)

copy_template.S 에는 어셈블리로 복사 코드가 담겨있다.

유저 프로세스 공간으로 커널 데이터 복사

copy_to_user()

include/linux/uaccess.h

1static __always_inline unsigned long __must_check
2copy_to_user(void __user *to, const void *from, unsigned long n)
3{
4        if (likely(check_copy_size(from, n, true)))
5                n = _copy_to_user(to, from, n);
6        return n;
7}

커널 가상 주소 @from에서 @n 바이트만큼 유저 가상 주소 @to로 데이터를 복사한다.

_copy_to_user()

include/linux/uaccess.h

01#ifdef INLINE_COPY_TO_USER
02static inline unsigned long
03_copy_to_user(void __user *to, const void *from, unsigned long n)
04{
05        might_fault();
06        if (access_ok(to, n)) {
07                kasan_check_read(from, n);
08                n = raw_copy_to_user(to, from, n);
09        }
10        return n;
11}
12#endif

이 함수는 유저 application에서 사용될 때에는 INLINE_COPY_TO_USER 옵션이 적용되어 인라인 함수로 제공된다. 그렇지 않고 커널을 통해 호출되는 경우 라이브러리를 통해 제공된다.

아키텍처별 raw_copy_to_user()

다음 아키텍처별로 권한 설정을 아키텍처 고유의 방법을 사용한다.

ARM32
- 도메인 접근 제어 레지스터를 사용하여 제어한다.
ARM64
- 커널에서의 유저 액세스 권한 제어 플래그를 사용하여 제어한다.

raw_copy_to_user() – ARM64

arch/arm64/include/asm/uaccess.h

1#define raw_copy_to_user(to, from, n)                                   \
2({                                                                      \
3        __arch_copy_to_user(__uaccess_mask_ptr(to), (from), (n));       \
4})

커널 가상 주소 @from(x1)에서 @n 바이트(x2)만큼 유저 가상 주소 @to(x0)로 복사한다.

__arch_copy_to_user()

arch/arm64/lib/copy_to_user.S

1ENTRY(__arch_copy_to_user)
2        uaccess_enable_not_uao x3, x4, x5
3        add     end, x0, x2
4#include "copy_template.S"
5        uaccess_disable_not_uao x3, x4
6        mov     x0, #0
7        ret
8ENDPROC(__arch_copy_to_user)
9EXPORT_SYMBOL(__arch_copy_to_user)

커널이 유저 데이터에 접근할 수 있도록 잠시 허용한 후 커널 가상 주소 src(x1)에서 n 바이트(x2)만큼 유저 가상 주소 dest(x0)로 복사한다. 그런 후 커널이 유저 데이터에 접근하지 못하게 막는다.

copy_template.S 에는 어셈블리로 복사 코드가 담겨있다.

raw_copy_to_user() – ARM32

arch/arm/include/asm/uaccess.h

01static inline unsigned long __must_check
02raw_copy_to_user(void __user *to, const void *from, unsigned long n)
03{
04#ifndef CONFIG_UACCESS_WITH_MEMCPY
05        unsigned int __ua_flags;
06        __ua_flags = uaccess_save_and_enable();
07        n = arm_copy_to_user(to, from, n);
08        uaccess_restore(__ua_flags);
09        return n;
10#else
11        return arm_copy_to_user(to, from, n);
12#endif
13}

커널 가상 주소 @from(r1)에서 @n 바이트(r2)만큼 유저 가상 주소 @to(r0)로 복사한다.

arm_copy_to_user()

lib/copy_to_user.S

01ENTRY(__copy_to_user_std)
02WEAK(arm_copy_to_user)
03#ifdef CONFIG_CPU_SPECTRE
04        get_thread_info r3
05        ldr     r3, [r3, #TI_ADDR_LIMIT]
06        uaccess_mask_range_ptr r0, r2, r3, ip
07#endif
08 
09#include "copy_template.S"
10 
11ENDPROC(arm_copy_to_user)

copy_template.S 에는 어셈블리로 복사 코드가 담겨있다.

User 공간 접근 제어 – ARM64

보안을 향상시킬 목적으로 커널에서 유저 공간 액세스를 컨트롤하기 위해 다음 두 가지 방법 중 하나를 사용할 수 있다. 이러한 기능이 적용되지 않는 경우 기본적으로 커널에서 유저 공간의 접근이 언제나 허용된다.

ARMv8.1-PAN 기능을 사용한 제어 (HW 기법)
- 커널 옵션: CONFIG_ARM64_PAN
SW_TTBR0_PAN 기능을 사용한 제어 (SW 기법)
- TTBR0_EL1을 빈 페이지 테이블에 연결하고, TTBR1_EL1의 ASID를 클리어하는 SW 에뮬레이션 방법을 사용하여 커널에서 유저 접근을 금지시킬 수 있다.
- 커널 옵션:CONFIG_ARM64_SW_TTBR0_PAN

그 외 – UAO 기능을 사용한 커널에서의 유저 공간 접근 권한 Override

커널과 유저 데이터 교환 함수들(copy_from_user(), copy_to_user()…)에서 유저 공간에 접근할 때 ldr/str 대신 유저 페이지 테이블에 기록된 권한 설정들을 override 하여 사용하는 ldtr/sttr 명령을 사용할 수 있다.

ARMv8.2-UAO
- 커널에서 유저 주소에 접근할 때 ldr/str 명령으로 접근하는 경우 유저 페이지 테이블에 기록된 권한 설정들을 사용하지 못한다.
- 그러나 UAO 기능이 지원되는 아키텍처에서 ldtr/sttr 명령을 사용 시 유저 페이지 테이블에 기록된 권한 설정들을 Override 할 수 있다.
- 커널 옵션: CONFIG_ARM64_UAO

1) 유저 공간 접근 허용 – for ARM64 Assembly

uaccess_enable_not_uao() 매크로

arch/arm64/include/asm/asm-uaccess.h

1        .macro  uaccess_enable_not_uao, tmp1, tmp2, tmp3
2        uaccess_ttbr0_enable \tmp1, \tmp2, \tmp3
3alternative_if ARM64_ALT_PAN_NOT_UAO
4        SET_PSTATE_PAN(0)
5alternative_else_nop_endif
6        .endm

커널에서 유저 데이터에 접근할 수 있도록 허용한다.

코드 라인 2에서 ARMv8.1 아키텍처 이상에서 지원되는 PAN 기능이 지원되지 않는 경우 SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 허용하게 한다.
코드 라인 3~5에서 PAN 기능이 지원되면 ARMv8.2 아키텍처 이상에서만 지원하는 UAO 기능에 의지 하지 않고 PAN 기능을 disable하여 커널에서 유저 공간에 접근할 수 있도록 허용한다.

uaccess_ttbr0_enable() 매크로

arch/arm64/include/asm/asm-uaccess.h

1        .macro  uaccess_ttbr0_enable, tmp1, tmp2, tmp3
2alternative_if_not ARM64_HAS_PAN
3        save_and_disable_irq \tmp3              // avoid preemption
4        __uaccess_ttbr0_enable \tmp1, \tmp2
5        restore_irq \tmp3
6alternative_else_nop_endif
7        .endm

ARMv8.1 아키텍처 이상에서 지원되는 PAN 기능이 지원되지 않는 경우 SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 허용하게 한다.

__uaccess_ttbr0_enable() 매크로

01.macro  __uaccess_ttbr0_enable, tmp1, tmp2
02get_thread_info \tmp1
03ldr     \tmp1, [\tmp1, #TSK_TI_TTBR0]   // load saved TTBR0_EL1
04mrs     \tmp2, ttbr1_el1
05extr    \tmp2, \tmp2, \tmp1, #48
06ror     \tmp2, \tmp2, #16
07msr     ttbr1_el1, \tmp2                // set the active ASID
08isb
09msr     ttbr0_el1, \tmp1                // set the non-PAN TTBR0_EL1
10isb
11.endm

SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 허락하도록 ttbr을 설정한다.

유저 페이지 테이블을 위해 사용되는 TTBR0의 asid를 커널 페이지 테이블을 위해 사용되는 TTBR1에 복사하여 커널이 유저 액세스가 가능하도록 허용한다.
유저 페이지 테이블을 위해 사용되는 TTBR0의 asid를 읽어 커널 페이지 테이블을 위해 사용되는 TTBR1에 asid 필드만을 기록하여 커널에서 유저 영역에 접근할 수 있게 허용한다.

2) 유저 공간 접근 금지 – for ARM64 Assembly

uaccess_disable_not_uao() 매크로

arch/arm64/include/asm/asm-uaccess.h

1        .macro  uaccess_disable_not_uao, tmp1, tmp2
2        uaccess_ttbr0_disable \tmp1, \tmp2
3alternative_if ARM64_ALT_PAN_NOT_UAO
4        SET_PSTATE_PAN(1)
5alternative_else_nop_endif
6        .endm

커널에서 유저 데이터에 접근하지 못하게 금지한다.

코드 라인 2에서 ARMv8.1 아키텍처 이상에서 지원되는 PAN 기능이 지원되지 않는 경우 SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 금지하게 한다.
코드 라인 3~5에서 PAN 기능이 지원되면 ARMv8.2 아키텍처 이상에서만 지원하는 UAO 기능에 의지 하지 않고 PAN 기능을 enable하여 커널에서 유저 공간에 접근하지 못하게 금지한다.

uaccess_ttbr0_disable() 매크로

arch/arm64/include/asm/asm-uaccess.h

1        .macro  uaccess_ttbr0_enable, tmp1, tmp2, tmp3
2alternative_if_not ARM64_HAS_PAN
3        save_and_disable_irq \tmp3              // avoid preemption
4        __uaccess_ttbr0_enable \tmp1, \tmp2
5        restore_irq \tmp3
6alternative_else_nop_endif
7        .endm

ARMv8.1 아키텍처 이상에서 지원되는 PAN 기능이 지원되지 않는 경우 SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 금지하게 한다.

__uaccess_ttbr0_disable() 매크로

arch/arm64/include/asm/asm-uaccess.h

01.macro  __uaccess_ttbr0_disable, tmp1
02mrs     \tmp1, ttbr1_el1                        // swapper_pg_dir
03bic     \tmp1, \tmp1, #TTBR_ASID_MASK
04sub     \tmp1, \tmp1, #RESERVED_TTBR0_SIZE      // reserved_ttbr0 just before swapper_pg_dir
05msr     ttbr0_el1, \tmp1                        // set reserved TTBR0_EL1
06isb
07add     \tmp1, \tmp1, #RESERVED_TTBR0_SIZE
08msr     ttbr1_el1, \tmp1                // set reserved ASID
09isb
10.endm

SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 금지하도록 ttbr을 설정한다.

커널 페이지 테이블을 가리키는 TTBR1의 asid를 클리어한다.
유저 페이지 테이블을 가리키는 TTBR0에 reserved_ttbr0 라는 이름의 빈 페이지 테이블을 가리키게한다.
- CONFIG_ARM64_SW_TTBR0_PAN 커널 옵션을 사용하는 경우 swapper_pg_dir 이전에 reserved_ttbr0 라는 이름의 빈 페이지 테이블이 구성되어 있다.

Process State(PSTATE) 설정

01/*
02 * Instructions for modifying PSTATE fields.
03 * As per Arm ARM for v8-A, Section "C.5.1.3 op0 == 0b00, architectural hints,
04 * barriers and CLREX, and PSTATE access", ARM DDI 0487 C.a, system instructions
05 * for accessing PSTATE fields have the following encoding:
06 *      Op0 = 0, CRn = 4
07 *      Op1, Op2 encodes the PSTATE field modified and defines the constraints.
08 *      CRm = Imm4 for the instruction.
09 *      Rt = 0x1f
10 */

01#define pstate_field(op1, op2)          ((op1) << Op1_shift | (op2) << Op2_shift)
02#define PSTATE_Imm_shift                CRm_shift
03 
04#define PSTATE_PAN                      pstate_field(0, 4)
05#define PSTATE_UAO                      pstate_field(0, 3)
06#define PSTATE_SSBS                     pstate_field(3, 1)
07 
08#define SET_PSTATE_PAN(x)               __emit_inst(0xd500401f | PSTATE_PAN | ((!!x) << PSTATE_Imm_ss
09hift))
10#define SET_PSTATE_UAO(x)               __emit_inst(0xd500401f | PSTATE_UAO | ((!!x) << PSTATE_Imm_ss
11hift))
12#define SET_PSTATE_SSBS(x)              __emit_inst(0xd500401f | PSTATE_SSBS | ((!!x) << PSTATE_Imm__
13shift))

MSR을 사용하고 immediate 접근을 통해 PSTATE 필드 들 중 다음의 필드들을 설정할 수 있다.

SET_PSTATE_PAN()
- PSTATE 중 PAN(Privileged Access Never) 비트를 설정한다.
- ARMv8.1-PAN 이 구현된 아키텍처만 사용가능하다.
SET_PSTATE_UAO()
- PSTATE 중 UAO(User Access Override) 비트를 설정한다.
- ARMv8.2-UAO가 구현된 아키텍처만 사용가능하다.

다음 그림은 MSR의 immediate 접근을 통해 PSTATE 관련 몇 개의 플래그를 설정하기 위해 사용되는 op1, CRm, op2의 위치를 보여준다.

CRm 값을 지정하기 위해 필요한 CRm_shift 값은 8이다.
op1 값을 지정하기 위해 필요한 op1_shift 값은 16이다.
op2 값을 지정하기 위해 필요한 op2_shift 값은 5이다.

3) 유저 공간 접근 허용 – for ARM64 C

uaccess_enable_not_uao()

arch/arm64/include/asm/uaccess.h

1static inline void uaccess_enable_not_uao(void)
2{
3        __uaccess_enable(ARM64_ALT_PAN_NOT_UAO);
4}

커널에서 유저 데이터에 접근할 수 있도록 잠시 허용한다.

__uaccess_enable()

arch/arm64/include/asm/uaccess.h

1#define __uaccess_enable(alt)                                           \
2do {                                                                    \
3        if (!uaccess_ttbr0_enable())                                    \
4                asm(ALTERNATIVE("nop", SET_PSTATE_PAN(0), alt,          \
5                                CONFIG_ARM64_PAN));                     \
6} while (0)

커널에서 유저 액세스가 가능하도록 허용한다.

코드 라인 3에서 ARMv8.1 아키텍처 이상에서 지원되는 PAN 기능이 지원되지 않는 경우 SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 허용하게 한다.
코드 라인 4~5에서 PAN 기능 지원 여부에 따라 ARMv8.2 아키텍처 이상에서만 지원하는 UAO 기능에 의지 하지 않고 PAN 기능을 disable하여 커널에서 유저 공간에 접근할 수 있도록 허용한다.

uaccess_ttbr0_enable() – ARM64

arch/arm64/include/asm/uaccess.h

1static inline bool uaccess_ttbr0_enable(void)
2{
3        if (!system_uses_ttbr0_pan())
4                return false;
5        __uaccess_ttbr0_enable();
6        return true;
7}

커널에서 유저 데이터에 접근할 수 있도록 허용한다.

코드 라인 2에서 ARMv8.1 아키텍처 이상에서 지원되는 PAN 기능이 지원되지 않는 경우 SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 허용하게 한다.
코드 라인 3~5에서 PAN 기능이 지원되면 ARMv8.2 아키텍처 이상에서만 지원하는 UAO 기능에 의지 하지 않고 PAN 기능을 enable하여 커널에서 유저 공간에 접근할 수 있도록 허용한다.

system_uses_ttbr0_pan() – ARM64

arch/arm64/include/asm/cpufeature.h

1static inline bool system_uses_ttbr0_pan(void)
2{
3        return IS_ENABLED(CONFIG_ARM64_SW_TTBR0_PAN) &&
4                !cpus_have_const_cap(ARM64_HAS_PAN);
5}

현재 동작 중인 ARM64 커널에 CONFIG_ARM64_SW_TTBR0_PAN 커널 옵션이 설정되어 있지만 아키텍처가 PAN(Previlidge Access Never) 기능을 가지고 있지 않으면 TTBR0을 사용하여 PAN을 에뮬레이션을 하기 위해 1을 반환한다.

__uaccess_ttbr0_enable() – ARM64

arch/arm64/include/asm/uaccess.h

01static inline void __uaccess_ttbr0_enable(void)
02{
03        unsigned long flags, ttbr0, ttbr1;
04 
05        /*
06         * Disable interrupts to avoid preemption between reading the 'ttbr0'
07         * variable and the MSR. A context switch could trigger an ASID
08         * roll-over and an update of 'ttbr0'.
09         */
10        local_irq_save(flags);
11        ttbr0 = READ_ONCE(current_thread_info()->ttbr0);
12 
13        /* Restore active ASID */
14        ttbr1 = read_sysreg(ttbr1_el1);
15        ttbr1 &= ~TTBR_ASID_MASK;               /* safety measure */
16        ttbr1 |= ttbr0 & TTBR_ASID_MASK;
17        write_sysreg(ttbr1, ttbr1_el1);
18        isb();
19 
20        /* Restore user page table */
21        write_sysreg(ttbr0, ttbr0_el1);
22        isb();
23        local_irq_restore(flags);
24}

SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 허락하도록 ttbr을 설정한다.

TTBR0의 asid를 TTBR1에 복사하여 커널이 유저 액세스가 가능하도록 허용한다.
유저 페이지 테이블을 위해 사용되는 ttbr0의 asid를 읽어 커널 페이지 테이블을 위해 사용되는 ttbr1에 asid 필드만을 기록하여 커널에서 유저 영역에 접근할 수 있게 허용한다.

4) 유저 공간 접근 금지 – for ARM64 C

uaccess_disable_not_uao()

arch/arm64/include/asm/uaccess.h

1static inline void uaccess_disable_not_uao(void)
2{
3        __uaccess_disable(ARM64_ALT_PAN_NOT_UAO);
4}

다시 커널에서 유저 데이터에 접근하지 못하게 한다.

__uaccess_disable()

arch/arm64/include/asm/uaccess.h

1#define __uaccess_disable(alt)                                          \
2do {                                                                    \
3        if (!uaccess_ttbr0_disable())                                   \
4                asm(ALTERNATIVE("nop", SET_PSTATE_PAN(1), alt,          \
5                                CONFIG_ARM64_PAN));                     \
6} while (0)

커널에서 유저 데이터에 접근하지 못하게 금지한다.

코드 라인 3에서 ARMv8.1 아키텍처 이상에서 지원되는 PAN 기능이 지원되지 않는 경우 SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 금지하게 한다.
코드 라인 4~6에서 PAN 기능이 지원되면 ARMv8.2 아키텍처 이상에서만 지원하는 UAO 기능에 의지 하지 않고 PAN 기능을 enable하여 커널에서 유저 공간에 접근하지 못하게 금지한다.

uaccess_ttbr0_disable()

arch/arm64/include/asm/uaccess.h

1static inline bool uaccess_ttbr0_disable(void)
2{
3        if (!system_uses_ttbr0_pan())
4                return false;
5        __uaccess_ttbr0_disable();
6        return true;
7}

커널에서 유저 데이터에 접근할 수 없도록 금지한다.

코드 라인 2에서 ARMv8.1 아키텍처 이상에서 지원되는 PAN 기능이 지원되지 않는 경우 SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 금지하게 한다.
코드 라인 3~5에서 PAN 기능이 지원되면 ARMv8.2 아키텍처 이상에서만 지원하는 UAO 기능에 의지 하지 않고 PAN 기능을 enable하여 커널에서 유저 공간에 접근하지 못하게 금지한다.

__uaccess_ttbr0_disable()

arch/arm64/include/asm/uaccess.h

01static inline void __uaccess_ttbr0_disable(void)
02{
03        unsigned long flags, ttbr;
04 
05        local_irq_save(flags);
06        ttbr = read_sysreg(ttbr1_el1);
07        ttbr &= ~TTBR_ASID_MASK;
08        /* reserved_ttbr0 placed before swapper_pg_dir */
09        write_sysreg(ttbr - RESERVED_TTBR0_SIZE, ttbr0_el1);
10        isb();
11        /* Set reserved ASID */
12        write_sysreg(ttbr, ttbr1_el1);
13        isb();
14        local_irq_restore(flags);
15}

SW_TTBR0_PAN 기능을 통해 커널에서 유저 공간의 접근을 금지하도록 ttbr을 설정한다.

TTBR1의 asid를 클리어하여 다시 TTBR1에 기록한다.
TTBR0에 reserved_ttbr0 라는 이름의 빈 페이지 테이블을 가리키게한다.
- CONFIG_ARM64_SW_TTBR0_PAN 커널 옵션을 사용하는 경우 swapper_pg_dir 이전에 reserved_ttbr0 라는 이름의 빈 페이지 테이블이 구성되어 있다.

유저 도메인의 권한 설정 및 복원 – ARM32

uaccess_save_and_enable()

arch/arm/include/asm/uaccess.h

1/*
2 * These two functions allow hooking accesses to userspace to increase
3 * system integrity by ensuring that the kernel can not inadvertantly
4 * perform such accesses (eg, via list poison values) which could then
5 * be exploited for priviledge escalation.
6 */

01static inline unsigned int uaccess_save_and_enable(void)
02{
03#ifdef CONFIG_CPU_SW_DOMAIN_PAN
04        unsigned int old_domain = get_domain();
05 
06        /* Set the current domain access to permit user accesses */
07        set_domain((old_domain & ~domain_mask(DOMAIN_USER)) |
08                   domain_val(DOMAIN_USER, DOMAIN_CLIENT));
09 
10        return old_domain;
11#else
12        return 0;
13#endif
14}

유저 도메인의 값을 반환하고, 클라이언트 권한(페이지 테이블에 설정된 permission 대로 동작하기)을 부여한다.

uaccess_restore()

arch/arm/include/asm/uaccess.h

1static inline void uaccess_restore(unsigned int flags)
2{
3#ifdef CONFIG_CPU_SW_DOMAIN_PAN
4        /* Restore the user access mask */
5        set_domain(flags);
6#endif
7}

유저 도메인의 값을 원래 값(flags)으로 복구한다.

도메인별 permission 권한 설정하기

set_domain()

arch/arm/include/asm/domain.h

1static inline void set_domain(unsigned val)
2{
3        asm volatile(
4        "mcr    p15, 0, %0, c3, c0      @ set domain"
5          : : "r" (val) : "memory");
6        isb();
7}

DACR(Domain Access Control Register)을 사용하여 16개의 도메인을 지정한다.

ARM32 커널은 16개의 도메인 중 커널, 유저, IO 및 벡터 도메인을 지정하여 총 4개의 도메인을 사용한다.
각 도메인 마다 2비트를 사용하여 다음과 같은 permission 사용 여부를 지정할 수 있다.
- 0=no access
  - 항상 permission 에러가 발생한다.
- 1=client
  - 페이지 변환 테이블에 지정된 permission 비트에 해당하는 체크를 수행한다.
- 2=reserved
- 3=manager
  - 페이지 변환 테이블에 지정된 permission 비트를 무시한다.

uaccess_mask_range_ptr() 매크로

include/asm/assembler.h

01        .macro uaccess_mask_range_ptr, addr:req, size:req, limit:req, tmp:req
02#ifdef CONFIG_CPU_SPECTRE
03        sub     \tmp, \limit, #1
04        subs    \tmp, \tmp, \addr       @ tmp = limit - 1 - addr
05        addhs   \tmp, \tmp, #1          @ if (tmp >= 0) {
06        subhss  \tmp, \tmp, \size       @ tmp = limit - (addr + size) }
07        movlo   \addr, #0               @ if (tmp < 0) addr = NULL
08        csdb
09#endif
10        .endm

uaccess_save 매크로

arch/arm/include/asm/assembler.h

1        .macro  uaccess_save, tmp
2#ifdef CONFIG_CPU_SW_DOMAIN_PAN
3        mrc     p15, 0, \tmp, c3, c0, 0
4        str     \tmp, [sp, #SVC_DACR]
5#endif
6        .endm

보안을 위해 커널에서 user 영역에 접근을 하지 못하게 제한한다. 그리고 이전 유저 도메인에 대한 도메인 타입을 스택이 가리키고 있는 pt_regs의 멤버 dacr에 백업한다.

uaccess_restore 매크로

arch/arm/include/asm/assembler.h

1        .macro  uaccess_restore
2#ifdef CONFIG_CPU_SW_DOMAIN_PAN
3        ldr     r0, [sp, #SVC_DACR]
4        mcr     p15, 0, r0, c3, c0, 0
5#endif
6        .endm

보안을 위해 커널에서 user 영역에 접근에 대한 여부를 기록하는데, 백업해 두었던 스택에 위치한 pt_regs의 멤버 dacr을 읽은 값을 기록한다.

uaccess_disable 매크로

arch/arm/include/asm/assembler.h

01        .macro  uaccess_disable, tmp, isb=1
02#ifdef CONFIG_CPU_SW_DOMAIN_PAN
03        /*
04         * Whenever we re-enter userspace, the domains should always be
05         * set appropriately.
06         */
07        mov     \tmp, #DACR_UACCESS_DISABLE
08        mcr     p15, 0, \tmp, c3, c0, 0         @ Set domain register
09        .if     \isb
10        instr_sync
11        .endif
12#endif
13        .endm

보안을 위해 커널에서 user 영역에 접근을 하지 못하게 제한한다.

코드 라인 7~8에서 커널에서 user 영역에 접근을 제한한다.
코드 라인 9~11에서 @isb=1인 경우 instruction 베리어를 수행한다.

uaccess_enable 매크로

arch/arm/include/asm/assembler.h

01        .macro  uaccess_enable, tmp, isb=1
02#ifdef CONFIG_CPU_SW_DOMAIN_PAN
03        /*
04         * Whenever we re-enter userspace, the domains should always be
05         * set appropriately.
06         */
07        mov     \tmp, #DACR_UACCESS_ENABLE
08        mcr     p15, 0, \tmp, c3, c0, 0
09        .if     \isb
10        instr_sync
11        .endif
12#endif
13        .endm

보안을 위해 커널에서 user 영역에 접근을 하지 못하게 제한한 것을 허용하게 한다.

코드 라인 7~8에서 커널에서 user 영역에 접근하도록 허용한다.
코드 라인 9~11에서 @isb=1인 경우 instruction 베리어를 수행한다.

DACR_UACCESS_DISABLE

arch/arm/include/asm/domain.h

`1`	`#define DACR_UACCESS_DISABLE \`

`2`	`(__DACR_DEFAULT \| domain_val(DOMAIN_USER, DOMAIN_NOACCESS))`

유저 도메인의 타입을 noaccess로 지정한다. (커널에서 유저 영역의 액세스 금지)

DACR_UACCESS_ENABLE

arch/arm/include/asm/domain.h

1#define DACR_UACCESS_DISABLE    \
2        (__DACR_DEFAULT | domain_val(DOMAIN_USER, DOMAIN_NOACCESS))
3#define DACR_UACCESS_ENABLE     \
4        (__DACR_DEFAULT | domain_val(DOMAIN_USER, DOMAIN_CLIENT))

유저 도메인의 타입을 client로 지정한다. (커널에서 유저 영역의 액세스 허용)

arch/arm/include/asm/domain.h

1#define __DACR_DEFAULT \
2        domain_val(DOMAIN_KERNEL, DOMAIN_CLIENT) | \
3        domain_val(DOMAIN_IO, DOMAIN_CLIENT) | \
4        domain_val(DOMAIN_VECTORS, DOMAIN_CLIENT)

`1`	`#define domain_val(dom,type) ((type) << (2 * (dom)))`

16개의 도메인 중 요청한 도메인 @dom에 도메인 @type을 지정한다.

DACR(Domain Access Control Register) 레지스터는 16개의 도메인에 2비트씩 도메인 타입을 지정할 수 있다.

도메인 타입

1#define DOMAIN_NOACCESS 0
2#define DOMAIN_CLIENT   1
3#ifdef CONFIG_CPU_USE_DOMAINS
4#define DOMAIN_MANAGER  3
5#else
6#define DOMAIN_MANAGER  1
7#endif

유효한 유저 프로세스 주소 사용 여부 체크

access_ok() – ARM64

arch/arm64/include/asm/uaccess.h

`1`	`#define access_ok(addr, size) __range_ok(addr, size)`

@addr 주소에서 @size 만큼의 영역이 유효한 유저 프로세스 주소인지 여부를 체크한다. 유효하지 않는 경우 0을 반환한다.

__range_ok() – ARM64

arch/arm64/include/asm/uaccess.h

1/*
2 * Test whether a block of memory is a valid user space address.
3 * Returns 1 if the range is valid, 0 otherwise.
4 *
5 * This is equivalent to the following test:
6 * (u65)addr + (u65)size <= (u65)current->addr_limit + 1
7 */

01static inline unsigned long __range_ok(const void __user *addr, unsigned long size)
02{
03        unsigned long ret, limit = current_thread_info()->addr_limit;
04 
05        __chk_user_ptr(addr);
06        asm volatile(
07        // A + B <= C + 1 for all A,B,C, in four easy steps:
08        // 1: X = A + B; X' = X % 2^64
09        "       adds    %0, %3, %2\n"
10        // 2: Set C = 0 if X > 2^64, to guarantee X' > C in step 4
11        "       csel    %1, xzr, %1, hi\n"
12        // 3: Set X' = ~0 if X >= 2^64. For X == 2^64, this decrements X'
13        //    to compensate for the carry flag being set in step 4. For
14        //    X > 2^64, X' merely has to remain nonzero, which it does.
15        "       csinv   %0, %0, xzr, cc\n"
16        // 4: For X < 2^64, this gives us X' - C - 1 <= 0, where the -1
17        //    comes from the carry in being clear. Otherwise, we are
18        //    testing X' - C == 0, subject to the previous adjustments.
19        "       sbcs    xzr, %0, %1\n"
20        "       cset    %0, ls\n"
21        : "=&r" (ret), "+r" (limit) : "Ir" (size), "0" (addr) : "cc");
22 
23        return ret;
24}

access_ok() – ARM32

arch/arm/include/asm/uaccess.h

`1`	`#define access_ok(addr, size) (__range_ok(addr, size) == 0)`

@addr 주소에서 @size 만큼의 영역이 유효한 유저 프로세스 주소인지 여부를 체크한다. 유효하지 않는 경우 0을 반환한다.

__range_ok() – ARM32

arch/arm/include/asm/uaccess.h

1/* We use 33-bit arithmetic here... */
2#define __range_ok(addr, size) ({ \
3        unsigned long flag, roksum; \
4        __chk_user_ptr(addr);   \
5        __asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" \
6                : "=&r" (flag), "=&r" (roksum) \
7                : "r" (addr), "Ir" (size), "0" (current_thread_info()->addr_limit) \
8                : "cc"); \
9        flag; })

커널에서 유저 영역의 값(1, 2, 4, 8 바이트) 읽어오기

get_user() API는 아키텍처별로 약간의 다른 구현을 사용한다.

arm64
- exception 테이블을 활용하여 읽기를 시도한다.
arm32
- MMU를 사용하는 ARMv7 아키텍처에 한해 exception 테이블 사용없이 미리 체크를 한 후 읽기를 시도한다.
- MMU를 사용하지 않는 경우 exception 테이블을 활용하여 읽기를 시도한다.

get_user() – ARM64

arch/arm64/include/asm/uaccess.h

`1`	`#define get_user __get_user`

커널에서 유저 영역의 주소 @p에 담긴 데이터를 @p 타입 사이즈만큼 읽어 커널 영역의 주소 @x에 대입한다. 만일 읽을 수 없으면 -EFAULT 에러를 반환한다.

__get_user() – ARM64

arch/arm64/include/asm/uaccess.h

1#define __get_user(x, ptr)                                              \
2({                                                                      \
3        int __gu_err = 0;                                               \
4        __get_user_check((x), (ptr), __gu_err);                         \
5        __gu_err;                                                       \
6})

__get_user_check() – ARM64

arch/arm64/include/asm/uaccess.h

01#define __get_user_check(x, ptr, err)                                   \
02({                                                                      \
03        __typeof__(*(ptr)) __user *__p = (ptr);                         \
04        might_fault();                                                  \
05        if (access_ok(__p, sizeof(*__p))) {                             \
06                __p = uaccess_mask_ptr(__p);                            \
07                __get_user_err((x), __p, (err));                        \
08        } else {                                                        \
09                (x) = 0; (err) = -EFAULT;                               \
10        }                                                               \
11})

__get_user_err() – ARM64

arch/arm64/include/asm/uaccess.h

01#define __get_user_err(x, ptr, err)                                     \
02do {                                                                    \
03        unsigned long __gu_val;                                         \
04        __chk_user_ptr(ptr);                                            \
05        uaccess_enable_not_uao();                                       \
06        switch (sizeof(*(ptr))) {                                       \
07        case 1:                                                         \
08                __get_user_asm("ldrb", "ldtrb", "%w", __gu_val, (ptr),  \
09                               (err), ARM64_HAS_UAO);                   \
10                break;                                                  \
11        case 2:                                                         \
12                __get_user_asm("ldrh", "ldtrh", "%w", __gu_val, (ptr),  \
13                               (err), ARM64_HAS_UAO);                   \
14                break;                                                  \
15        case 4:                                                         \
16                __get_user_asm("ldr", "ldtr", "%w", __gu_val, (ptr),    \
17                               (err), ARM64_HAS_UAO);                   \
18                break;                                                  \
19        case 8:                                                         \
20                __get_user_asm("ldr", "ldtr", "%x",  __gu_val, (ptr),   \
21                               (err), ARM64_HAS_UAO);                   \
22                break;                                                  \
23        default:                                                        \
24                BUILD_BUG();                                            \
25        }                                                               \
26        uaccess_disable_not_uao();                                      \
27        (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
28} while (0)

__get_user_asm() – ARM64

arch/arm64/include/asm/uaccess.h

1/*
2 * The "__xxx" versions of the user access functions do not verify the address
3 * space - it must have been done previously with a separate "access_ok()"
4 * call.
5 *
6 * The "__xxx_error" versions set the third argument to -EFAULT if an error
7 * occurs, and leave it unchanged on success.
8 */

01#define __get_user_asm(instr, alt_instr, reg, x, addr, err, feature)    \
02        asm volatile(                                                   \
03        "1:"ALTERNATIVE(instr "     " reg "1, [%2]\n",                  \
04                        alt_instr " " reg "1, [%2]\n", feature)         \
05        "2:\n"                                                          \
06        "       .section .fixup, \"ax\"\n"                              \
07        "       .align  2\n"                                            \
08        "3:     mov     %w0, %3\n"                                      \
09        "       mov     %1, #0\n"                                       \
10        "       b       2b\n"                                           \
11        "       .previous\n"                                            \
12        _ASM_EXTABLE(1b, 3b)                                            \
13        : "+r" (err), "=&r" (x)                                         \
14        : "r" (addr), "i" (-EFAULT))

get_user() – ARM32

arch/arm/include/asm/uaccess.h

1#define get_user(x, p)                                                  \
2        ({                                                              \
3                might_fault();                                          \
4                __get_user_check(x, p);                                 \
5         })

커널에서 유저 영역의 주소 @p에 담긴 데이터를 @p 타입 사이즈만큼 읽어 커널 영역의 주소 @x에 대입한다. 만일 읽을 수 없으면 -EFAULT 에러를 반환한다.

__get_user_check() – ARM32

arch/arm/include/asm/uaccess.h

01#define __get_user_check(x, p)                                          \
02        ({                                                              \
03                unsigned long __limit = current_thread_info()->addr_limit - 1; \
04                register typeof(*(p)) __user *__p asm("r0") = (p);      \
05                register __inttype(x) __r2 asm("r2");                   \
06                register unsigned long __l asm("r1") = __limit;         \
07                register int __e asm("r0");                             \
08                unsigned int __ua_flags = uaccess_save_and_enable();    \
09                switch (sizeof(*(__p))) {                               \
10                case 1:                                                 \
11                        if (sizeof((x)) >= 8)                           \
12                                __get_user_x_64t(__r2, __p, __e, __l, 1); \
13                        else                                            \
14                                __get_user_x(__r2, __p, __e, __l, 1);   \
15                        break;                                          \
16                case 2:                                                 \
17                        if (sizeof((x)) >= 8)                           \
18                                __get_user_x_64t(__r2, __p, __e, __l, 2); \
19                        else                                            \
20                                __get_user_x(__r2, __p, __e, __l, 2);   \
21                        break;                                          \
22                case 4:                                                 \
23                        if (sizeof((x)) >= 8)                           \
24                                __get_user_x_64t(__r2, __p, __e, __l, 4); \
25                        else                                            \
26                                __get_user_x(__r2, __p, __e, __l, 4);   \
27                        break;                                          \
28                case 8:                                                 \
29                        if (sizeof((x)) < 8)                            \
30                                __get_user_x_32t(__r2, __p, __e, __l, 4); \
31                        else                                            \
32                                __get_user_x(__r2, __p, __e, __l, 8);   \
33                        break;                                          \
34                default: __e = __get_user_bad(); break;                 \
35                }                                                       \
36                uaccess_restore(__ua_flags);                            \
37                x = (typeof(*(p))) __r2;                                \
38                __e;                                                    \
39        })

__get_user_x() – ARM32

arch/arm/include/asm/uaccess.h

1#define __get_user_x(__r2, __p, __e, __l, __s)                          \
2           __asm__ __volatile__ (                                       \
3                __asmeq("%0", "r0") __asmeq("%1", "r2")                 \
4                __asmeq("%3", "r1")                                     \
5                "bl     __get_user_" #__s                               \
6                : "=&r" (__e), "=r" (__r2)                              \
7                : "0" (__p), "r" (__l)                                  \
8                : __GUP_CLOBBER_##__s)

사이즈(__s)에 따라 커널이 유저 영역을 읽는 함수를 호출한다.

1, 2, 4, 8 바이트에 따른 호출함수가 라이브러리에 따로 준비되어 있다.

__get_user_1() – ARM32

arch/arm/lib/getuser.S

1ENTRY(__get_user_1)
2        check_uaccess r0, 1, r1, r2, __get_user_bad
31: TUSER(ldrb)  r2, [r0]
4        mov     r0, #0
5        ret     lr
6ENDPROC(__get_user_1)
7_ASM_NOKPROBE(__get_user_1)

커널에서 유저 영역의 1바이트를 읽어낸다. 만일 읽을 수 없으면 -EFAULT 에러를 반환한다.

check_uaccess() 매크로 – ARM32

arch/arm/include/asm/assembler.h

01        .macro check_uaccess, addr:req, size:req, limit:req, tmp:req, bad:req
02#ifndef CONFIG_CPU_USE_DOMAINS
03        adds    \tmp, \addr, #\size - 1
04        sbcccs  \tmp, \tmp, \limit
05        bcs     \bad
06#ifdef CONFIG_CPU_SPECTRE
07        movcs   \addr, #0
08        csdb
09#endif
10#endif
11        .endm

커널에서 유저 데이터 엑세스에 문제가 없는지 확인한다. 에러 발생 시 -EFAULT를 반환한다.

MMU를 enable 시킨 ARMv7 아키텍처를 사용하면 CONFIG_CPU_SPECTRE 커널 옵션을 디폴트로 사용한다.
csdb 는 Consumption of Speculative Data Barrier를 의미한다.

__get_user_bad() & __get_user_bad8() – ARM32

arch/arm/lib/getuser.S

01__get_user_bad8:
02        mov     r3, #0
03__get_user_bad:
04        mov     r2, #0
05        mov     r0, #-EFAULT
06        ret     lr
07ENDPROC(__get_user_bad)
08ENDPROC(__get_user_bad8)
09_ASM_NOKPROBE(__get_user_bad)
10_ASM_NOKPROBE(__get_user_bad8)

커널에서 유저 데이터 액세스에 문제가 발생했을 때 처리할 함수이다. -EFAULT 에러를 r0 레지스터를 통해 반환한다.

참고

sort_main_extable() | 문c
Exception Table (extable) | 문c

커널 스터디 참고 사이트

2019-05-172024-03-05 문영일 6 Comments

국내

해외

ARM64 아키텍처 참고 PDF 문서

ARM Architecture Reference Manual – 다운로드 pdf
ARM Cortex-A Series Programmer’s Guide for ARMv8-A – 다운로드 pdf
ARM 아키텍처별 Technical Reference Manual
- Cortex-A32 – 다운로드 pdf
- Cortex-A34 – 다운로드 pdf
- Cortex-A35 – 다운로드 pdf
- Cortex-A53 – 다운로드 pdf
- Cortex-A55 – 다운로드 pdf
- Cortex-A57 – 다운로드 pdf
- Cortex-A72 – 다운로드 pdf
- Cortex-A73 – 다운로드 pdf
- Cortex-A75 – 다운로드 pdf
- Cortex-A76 – 다운로드 pdf
- Cortex-A77 – 다운로드 pdf
- Cortex-A78 – 다운로드 pdf
- Cortex-A510 – 다운로드 pdf
- Cortex-A520 – 다운로드 pdf
- Cortex-A710 – 다운로드 pdf
- Cortex-A715 – 다운로드 pdf
- Cortex-A720 – 다운로드 pdf
- Cortex-X1 – 다운로드 pdf
- Cortex-X2 – 다운로드 pdf
- Cortex-X3 – 다운로드 pdf
- Cortex-X4 – 다운로드 pdf
AAPCS(ARM Architecture Procedure Call Standard for the ARM64) – 다운로드 pdf
PSCI(Power State Coordination Interface) – 다운로드 pdf