Memory Tagging Extension in AArch64 Linux

MTE 구조와 tag 비교

문서 제목은 `Memory Tagging Extension (MTE) in AArch64 Linux`입니다. 작성자는 Vincenzo Frascino와 Catalin Marinas이며 날짜는 `2020-02-25`입니다.

ARMv8.5 processor의 MTE는 ARMv8.0 virtual-address tagging인 TBI(Top Byte Ignore) 위에 구축됩니다. Physical address space의 16-byte granule마다 4-bit allocation tag에 software가 접근할 수 있게 합니다.

해당 memory range는 `Normal-Tagged` memory attribute로 map해야 합니다. Memory access에 사용한 virtual address의 bit `59-56`에서 logical tag를 얻고, MTE가 활성화된 CPU는 이를 allocation tag와 비교합니다. 불일치하면 system-register 설정에 따라 exception을 일으킬 수 있습니다.

Userspace 지원과 PROT_MTE

`CONFIG_ARM64_MTE`를 선택하고 hardware가 MTE를 지원하면 kernel은 `HWCAP2_MTE`로 기능을 userspace에 광고합니다.

User process가 allocation tag에 접근하려면 `mmap()` 또는 `mprotect()`의 새 `prot` flag인 `PROT_MTE`로 address range의 Tagged memory attribute를 켜야 합니다. `PROT_MTE` page는 MTE allocation tag 접근을 허용합니다.

• 처음 user address space에 map할 때 allocation tag는 `0`이며 copy-on-write에서도 보존됩니다.
• `MAP_SHARED`를 지원하고 process 사이에 allocation tag를 공유할 수 있습니다.
• `PROT_MTE`는 `MAP_ANONYMOUS`와 RAM 기반 file mapping(`tmpfs`, `memfd`)에서만 지원합니다. 다른 mapping type은 `-EINVAL`을 반환합니다.
• `PROT_MTE` flag와 대응 memory type은 `mprotect()`로 제거할 수 없습니다.
• `MADV_DONTNEED` 또는 `MADV_FREE`를 적용한 `madvise()` range는 system call 이후 언제든 allocation tag가 `0`으로 clear될 수 있습니다.

Tag check fault mode

`PROT_MTE` range에 접근할 때 logical tag와 allocation tag가 다르면 다음 동작을 thread별로 선택할 수 있습니다.

`prctl(PR_SET_TAGGED_ADDR_CTRL, flags, 0, 0, 0)`의 `PR_MTE_TCF_MASK` bit-field로 mode를 선택합니다.

Mode를 지정하지 않으면 fault를 무시하고, 하나를 지정하면 그 mode로 실행합니다. 여러 mode를 지정하면 per-CPU preferred mode 절의 규칙으로 선택합니다. 현재 설정은 `prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0)`으로 읽으며 여러 mode를 요청했다면 모두 보고됩니다.

User thread는 `MSR TCO, #1`로 `PSTATE.TCO`를 설정해 tag checking을 끌 수도 있습니다. Signal handler는 중단 context와 무관하게 항상 `PSTATE.TCO = 0`으로 시작하고 `sigreturn()`에서 복원됩니다. User application에 사용할 수 있는 match-all logical tag는 없습니다.

`read()` 같은 kernel의 user-address 접근은 user mode가 `PR_MTE_TCF_NONE` 또는 `PR_MTE_TCF_ASYNC`이면 검사하지 않습니다. `PR_MTE_TCF_SYNC`이면 best effort로 검사하지만 항상 보장할 수는 없습니다. Kernel의 user-address 접근은 user 설정과 관계없이 effective `PSTATE.TCO = 0`으로 수행됩니다.

IRG·ADDG·SUBG tag 제외

Architecture는 `GCR_EL1.Exclude` bit-field로 `IRG`, `ADDG`, `SUBG`가 무작위 생성할 특정 tag를 제외할 수 있게 합니다. Linux 기본값은 `0` 이외의 모든 tag를 제외합니다.

User thread는 `prctl(PR_SET_TAGGED_ADDR_CTRL, flags, 0, 0, 0)`의 `PR_MTE_TAG_MASK` bit-field에 include할 tag bitmap을 넣습니다. Hardware는 exclude mask를 쓰지만 `prctl()`은 include mask를 받습니다. Include mask `0`, 즉 exclusion mask `0xffff`는 CPU가 항상 tag `0`을 생성하게 합니다.

Per-CPU preferred tag-check mode

일부 CPU에서는 엄격한 MTE mode와 덜 엄격한 mode의 성능이 비슷합니다. 이 경우 privileged user는 성능 손실 없이 더 나은 오류 검출을 얻도록 CPU의 preferred mode를 더 엄격하게 설정할 수 있습니다.

CPU별 설정은 `/sys/devices/system/cpu/cpu<N>/mte_tcf_preferred`에서 제어하며 privileged user가 `async`, `sync`, `asymm`을 쓸 수 있습니다. 기본 preferred mode는 `async`입니다.

Program은 `PR_SET_TAGGED_ADDR_CTRL`의 flags에 여러 fault-mode bit를 설정해 CPU preferred mode를 허용할 수 있습니다. Sync와 async를 모두 요청하면 kernel이 asymmetric도 선택할 수 있습니다. CPU preferred mode가 task의 허용 집합에 있으면 그것을 선택하고, 아니면 다음 순서로 task 집합에서 선택합니다.

• 1. Asynchronous
• 2. Asymmetric
• 3. Synchronous

execve·fork 초기 상태

`execve()` 후 새 process는 다음 상태로 시작합니다.

• `PR_TAGGED_ADDR_ENABLE = 0`, 즉 disabled
• 선택한 tag-check mode가 없어 fault를 무시함
• `PR_MTE_TAG_MASK = 0`, 즉 모든 tag 제외
• `PSTATE.TCO = 0`
• 초기 memory map 어디에도 `PROT_MTE`가 설정되지 않음

`fork()`의 새 process는 parent의 설정과 memory-map attribute를 상속합니다. 단 `MADV_WIPEONFORK`를 적용한 `madvise()` range는 data와 tag를 모두 `0`으로 clear합니다.

ptrace tag·regset interface

`PTRACE_PEEKMTETAGS`와 `PTRACE_POKEMTETAGS`는 tracer가 tracee address space의 tag를 읽거나 설정하게 합니다. 호출 형식은 `ptrace(request, pid, addr, data)`입니다.

• `request`: `PTRACE_PEEKMTETAGS` 또는 `PTRACE_POKEMTETAGS`
• `pid`: tracee PID
• `addr`: tracee address space의 address. 16-byte granule에 aligned되지 않으면 kernel이 대응 aligned address를 사용합니다.
• `data`: tracer address space의 `iov_len` 길이 buffer를 `iov_base`가 가리키는 `struct iovec` pointer
• `iov_base`의 tag는 byte당 4-bit tag 하나로 표현되며 tracee의 16-byte MTE tag granule 하나에 대응합니다.

`addr == NT_ARM_TAGGED_ADDR_CTRL`인 `PTRACE_GETREGSET`과 `PTRACE_SETREGSET`은 `Documentation/arch/arm64/tagged-address-abi.rst`와 이 문서의 `prctl()` option에 따른 tagged-address ABI control 및 MTE 설정에 접근합니다. 대응 regset은 8 byte인 `sizeof(long)` element 하나입니다.

Core dump의 MTE tag segment

`PROT_MTE`로 map된 user memory의 allocation tag는 core file에 별도 `PT_AARCH64_MEMTAG_MTE` segment로 dump됩니다.

Tag는 `p_offset`부터 byte당 4-bit tag 두 개로 저장됩니다. Tag granule이 16 byte이므로 4K page 하나는 core file에서 128 byte가 필요합니다.

올바른 MTE 사용 예제

예제는 `-march=armv8.5-a+memtag`로 compile합니다. `AT_HWCAP2`의 `HWCAP2_MTE`를 확인하고 tagged-address ABI, sync·async fault mode, non-zero random tag를 `prctl()`로 허용합니다.

그 뒤 anonymous page를 map하고 `mprotect()`로 `PROT_MTE`를 켭니다. `IRG`로 random logical tag를 pointer에 넣고 `STG`로 allocation tag를 설정한 다음, 다음 granule을 잘못된 tag로 접근해 synchronous mode에서 `SIGSEGV`가 발생하는지 확인합니다.

/*
 * To be compiled with -march=armv8.5-a+memtag
 */
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/auxv.h>
#include <sys/mman.h>
#include <sys/prctl.h>

/*
 * From arch/arm64/include/uapi/asm/hwcap.h
 */
#define HWCAP2_MTE              (1 << 18)

/*
 * From arch/arm64/include/uapi/asm/mman.h
 */
#define PROT_MTE                 0x20

/*
 * From include/uapi/linux/prctl.h
 */
#define PR_SET_TAGGED_ADDR_CTRL 55
#define PR_GET_TAGGED_ADDR_CTRL 56
# define PR_TAGGED_ADDR_ENABLE  (1UL << 0)
# define PR_MTE_TCF_SHIFT       1
# define PR_MTE_TCF_NONE        (0UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_SYNC        (1UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_ASYNC       (2UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TCF_MASK        (3UL << PR_MTE_TCF_SHIFT)
# define PR_MTE_TAG_SHIFT       3
# define PR_MTE_TAG_MASK        (0xffffUL << PR_MTE_TAG_SHIFT)

/*
 * Insert a random logical tag into the given pointer.
 */
#define insert_random_tag(ptr) ({                       \
        uint64_t __val;                                 \
        asm("irg %0, %1" : "=r" (__val) : "r" (ptr));   \
        __val;                                          \
})

/*
 * Set the allocation tag on the destination address.
 */
#define set_tag(tagged_addr) do {                                      \
        asm volatile("stg %0, [%0]" : : "r" (tagged_addr) : "memory"); \
} while (0)

int main()
{
        unsigned char *a;
        unsigned long page_sz = sysconf(_SC_PAGESIZE);
        unsigned long hwcap2 = getauxval(AT_HWCAP2);

        /* check if MTE is present */
        if (!(hwcap2 & HWCAP2_MTE))
                return EXIT_FAILURE;

        /*
         * Enable the tagged address ABI, synchronous or asynchronous MTE
         * tag check faults (based on per-CPU preference) and allow all
         * non-zero tags in the randomly generated set.
         */
        if (prctl(PR_SET_TAGGED_ADDR_CTRL,
                  PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC | PR_MTE_TCF_ASYNC |
                  (0xfffe << PR_MTE_TAG_SHIFT),
                  0, 0, 0)) {
                perror("prctl() failed");
                return EXIT_FAILURE;
        }

        a = mmap(0, page_sz, PROT_READ | PROT_WRITE,
                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
        if (a == MAP_FAILED) {
                perror("mmap() failed");
                return EXIT_FAILURE;
        }

        /*
         * Enable MTE on the above anonymous mmap. The flag could be passed
         * directly to mmap() and skip this step.
         */
        if (mprotect(a, page_sz, PROT_READ | PROT_WRITE | PROT_MTE)) {
                perror("mprotect() failed");
                return EXIT_FAILURE;
        }

        /* access with the default tag (0) */
        a[0] = 1;
        a[1] = 2;

        printf("a[0] = %hhu a[1] = %hhu\n", a[0], a[1]);

        /* set the logical and allocation tags */
        a = (unsigned char *)insert_random_tag(a);
        set_tag(a);

        printf("%p\n", a);

        /* non-zero tag access */
        a[0] = 3;
        printf("a[0] = %hhu a[1] = %hhu\n", a[0], a[1]);

        /*
         * If MTE is enabled correctly the next instruction will generate an
         * exception.
         */
        printf("Expecting SIGSEGV...\n");
        a[16] = 0xdd;

        /* this should not be printed in the PR_MTE_TCF_SYNC mode */
        printf("...haven't got one\n");

        return EXIT_FAILURE;
}