Home | History | Annotate | Line # | Download | only in include
msan.h revision 1.1 
      1 /*	$NetBSD: msan.h,v 1.1 2019/11/14 16:23:52 maxv Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2019 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Maxime Villard.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/ksyms.h>
     33 
     34 #include <amd64/pmap.h>
     35 #include <amd64/vmparam.h>
     36 
     37 #ifdef __HAVE_PCPU_AREA
     38 #error "PCPU area not allowed with KMSAN"
     39 #endif
     40 #ifdef __HAVE_DIRECT_MAP
     41 #error "DMAP not allowed with KMSAN"
     42 #endif
     43 
     44 /*
     45  * One big shadow, divided in two sub-shadows (SHAD and ORIG), themselves
     46  * divided in two regions (MAIN and KERN).
     47  */
     48 
     49 #define __MD_SHADOW_SIZE	0x20000000000ULL	/* 4 * NBPD_L4 */
     50 #define __MD_SHADOW_START	(VA_SIGN_NEG((L4_SLOT_KMSAN * NBPD_L4)))
     51 #define __MD_SHADOW_END		(__MD_SHADOW_START + __MD_SHADOW_SIZE)
     52 
     53 #define __MD_SHAD_MAIN_START	(__MD_SHADOW_START)
     54 #define __MD_SHAD_KERN_START	(__MD_SHADOW_START + 0x8000000000ULL)
     55 
     56 #define __MD_ORIG_MAIN_START	(__MD_SHAD_KERN_START + 0x8000000000ULL)
     57 #define __MD_ORIG_KERN_START	(__MD_ORIG_MAIN_START + 0x8000000000ULL)
     58 
     59 #define __MD_PTR_BASE		0xFFFFFFFF80000000ULL
     60 #define __MD_ORIG_TYPE		__BITS(31,28)
     61 
     62 static inline int8_t *
     63 kmsan_md_addr_to_shad(const void *addr)
     64 {
     65 	vaddr_t va = (vaddr_t)addr;
     66 
     67 	if (va >= vm_min_kernel_address && va < vm_max_kernel_address) {
     68 		return (int8_t *)(__MD_SHAD_MAIN_START + (va - vm_min_kernel_address));
     69 	} else if (va >= KERNBASE) {
     70 		return (int8_t *)(__MD_SHAD_KERN_START + (va - KERNBASE));
     71 	} else {
     72 		panic("%s: impossible, va=%p", __func__, (void *)va);
     73 	}
     74 }
     75 
     76 static inline int8_t *
     77 kmsan_md_addr_to_orig(const void *addr)
     78 {
     79 	vaddr_t va = (vaddr_t)addr;
     80 
     81 	if (va >= vm_min_kernel_address && va < vm_max_kernel_address) {
     82 		return (int8_t *)(__MD_ORIG_MAIN_START + (va - vm_min_kernel_address));
     83 	} else if (va >= KERNBASE) {
     84 		return (int8_t *)(__MD_ORIG_KERN_START + (va - KERNBASE));
     85 	} else {
     86 		panic("%s: impossible, va=%p", __func__, (void *)va);
     87 	}
     88 }
     89 
     90 static inline bool
     91 kmsan_md_unsupported(vaddr_t addr)
     92 {
     93 	return (addr >= (vaddr_t)PTE_BASE &&
     94 	    addr < ((vaddr_t)PTE_BASE + NBPD_L4));
     95 }
     96 
     97 static inline paddr_t
     98 __md_palloc(void)
     99 {
    100 	return pmap_get_physpage();
    101 }
    102 
    103 static void
    104 kmsan_md_shadow_map_page(vaddr_t va)
    105 {
    106 	paddr_t pa;
    107 
    108 	KASSERT(va >= __MD_SHADOW_START && va < __MD_SHADOW_END);
    109 
    110 	if (!pmap_valid_entry(L4_BASE[pl4_i(va)])) {
    111 		pa = __md_palloc();
    112 		L4_BASE[pl4_i(va)] = pa | PTE_W | pmap_pg_nx | PTE_P;
    113 	}
    114 	if (!pmap_valid_entry(L3_BASE[pl3_i(va)])) {
    115 		pa = __md_palloc();
    116 		L3_BASE[pl3_i(va)] = pa | PTE_W | pmap_pg_nx | PTE_P;
    117 	}
    118 	if (!pmap_valid_entry(L2_BASE[pl2_i(va)])) {
    119 		pa = __md_palloc();
    120 		L2_BASE[pl2_i(va)] = pa | PTE_W | pmap_pg_nx | PTE_P;
    121 	}
    122 	if (!pmap_valid_entry(L1_BASE[pl1_i(va)])) {
    123 		pa = __md_palloc();
    124 		L1_BASE[pl1_i(va)] = pa | PTE_W | pmap_pg_g | pmap_pg_nx | PTE_P;
    125 	}
    126 }
    127 
    128 static void
    129 kmsan_md_init(void)
    130 {
    131 	extern struct bootspace bootspace;
    132 	size_t i;
    133 
    134 	CTASSERT((__MD_SHADOW_SIZE / NBPD_L4) == NL4_SLOT_KMSAN);
    135 
    136 	/* Kernel. */
    137 	for (i = 0; i < BTSPACE_NSEGS; i++) {
    138 		if (bootspace.segs[i].type == BTSEG_NONE) {
    139 			continue;
    140 		}
    141 		kmsan_shadow_map((void *)bootspace.segs[i].va,
    142 		    bootspace.segs[i].sz);
    143 	}
    144 
    145 	/* Boot region. */
    146 	kmsan_shadow_map((void *)bootspace.boot.va, bootspace.boot.sz);
    147 
    148 	/* Module map. */
    149 	kmsan_shadow_map((void *)bootspace.smodule,
    150 	    (size_t)(bootspace.emodule - bootspace.smodule));
    151 
    152 	/* The bootstrap spare va. */
    153 	kmsan_shadow_map((void *)bootspace.spareva, PAGE_SIZE);
    154 }
    155 
    156 static inline msan_orig_t
    157 kmsan_md_orig_encode(int type, uintptr_t ptr)
    158 {
    159 	msan_orig_t ret;
    160 
    161 	ret = (ptr & 0xFFFFFFFF) & ~__MD_ORIG_TYPE;
    162 	ret |= __SHIFTIN(type, __MD_ORIG_TYPE);
    163 
    164 	return ret;
    165 }
    166 
    167 static inline void
    168 kmsan_md_orig_decode(msan_orig_t orig, int *type, uintptr_t *ptr)
    169 {
    170 	*type = __SHIFTOUT(orig, __MD_ORIG_TYPE);
    171 	*ptr = (uintptr_t)(orig & ~__MD_ORIG_TYPE) | __MD_PTR_BASE;
    172 }
    173 
    174 static inline bool
    175 kmsan_md_is_pc(uintptr_t ptr)
    176 {
    177 	extern uint8_t __rodata_start;
    178 
    179 	return (ptr < (uintptr_t)&__rodata_start);
    180 }
    181 
    182 static inline bool
    183 __md_unwind_end(const char *name)
    184 {
    185 	if (!strcmp(name, "syscall") ||
    186 	    !strcmp(name, "alltraps") ||
    187 	    !strcmp(name, "handle_syscall") ||
    188 	    !strncmp(name, "Xtrap", 5) ||
    189 	    !strncmp(name, "Xintr", 5) ||
    190 	    !strncmp(name, "Xhandle", 7) ||
    191 	    !strncmp(name, "Xresume", 7) ||
    192 	    !strncmp(name, "Xstray", 6) ||
    193 	    !strncmp(name, "Xhold", 5) ||
    194 	    !strncmp(name, "Xrecurse", 8) ||
    195 	    !strcmp(name, "Xdoreti") ||
    196 	    !strncmp(name, "Xsoft", 5)) {
    197 		return true;
    198 	}
    199 
    200 	return false;
    201 }
    202 
    203 static void
    204 kmsan_md_unwind(void)
    205 {
    206 	uint64_t *rbp, rip;
    207 	const char *mod;
    208 	const char *sym;
    209 	size_t nsym;
    210 	int error;
    211 
    212 	rbp = (uint64_t *)__builtin_frame_address(0);
    213 	nsym = 0;
    214 
    215 	while (1) {
    216 		/* 8(%rbp) contains the saved %rip. */
    217 		rip = *(rbp + 1);
    218 
    219 		if (rip < KERNBASE) {
    220 			break;
    221 		}
    222 		error = ksyms_getname(&mod, &sym, (vaddr_t)rip, KSYMS_PROC);
    223 		if (error) {
    224 			break;
    225 		}
    226 		kmsan_printf("#%zu %p in %s <%s>\n", nsym, (void *)rip, sym, mod);
    227 		if (__md_unwind_end(sym)) {
    228 			break;
    229 		}
    230 
    231 		rbp = (uint64_t *)*(rbp);
    232 		if (rbp == 0) {
    233 			break;
    234 		}
    235 		nsym++;
    236 
    237 		if (nsym >= 15) {
    238 			break;
    239 		}
    240 	}
    241 }
    242