1 /* 2 * Copyright (c) 2013-2018, Intel Corporation 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * * Redistributions of source code must retain the above copyright notice, 8 * this list of conditions and the following disclaimer. 9 * * Redistributions in binary form must reproduce the above copyright notice, 10 * this list of conditions and the following disclaimer in the documentation 11 * and/or other materials provided with the distribution. 12 * * Neither the name of Intel Corporation nor the names of its contributors 13 * may be used to endorse or promote products derived from this software 14 * without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include "pt_config.h" 30 #include "pt_opcodes.h" 31 32 #include "intel-pt.h" 33 34 #include <string.h> 35 #include <stddef.h> 36 37 38 int pt_cpu_errata(struct pt_errata *errata, const struct pt_cpu *cpu) 39 { 40 if (!errata || !cpu) 41 return -pte_invalid; 42 43 memset(errata, 0, sizeof(*errata)); 44 45 /* We don't know about others. */ 46 if (cpu->vendor != pcv_intel) 47 return -pte_bad_cpu; 48 49 switch (cpu->family) { 50 case 0x6: 51 switch (cpu->model) { 52 case 0x3d: 53 case 0x47: 54 case 0x4f: 55 case 0x56: 56 errata->bdm70 = 1; 57 errata->bdm64 = 1; 58 return 0; 59 60 case 0x4e: 61 case 0x5e: 62 errata->bdm70 = 1; 63 errata->skd007 = 1; 64 errata->skd022 = 1; 65 errata->skd010 = 1; 66 errata->skl014 = 1; 67 return 0; 68 69 case 0x8e: 70 case 0x9e: 71 errata->bdm70 = 1; 72 errata->skl014 = 1; 73 errata->skd022 = 1; 74 errata->skd010 = 1; 75 errata->skd007 = 1; 76 return 0; 77 78 case 0x5c: 79 case 0x5f: 80 errata->apl12 = 1; 81 errata->apl11 = 1; 82 return 0; 83 } 84 break; 85 } 86 87 return -pte_bad_cpu; 88 } 89 90 int pt_config_from_user(struct pt_config *config, 91 const struct pt_config *uconfig) 92 { 93 uint8_t *begin, *end; 94 size_t size; 95 96 if (!config) 97 return -pte_internal; 98 99 if (!uconfig) 100 return -pte_invalid; 101 102 size = uconfig->size; 103 if (size < offsetof(struct pt_config, decode)) 104 return -pte_bad_config; 105 106 begin = uconfig->begin; 107 end = uconfig->end; 108 109 if (!begin || !end || end < begin) 110 return -pte_bad_config; 111 112 /* Ignore fields in the user's configuration we don't know; zero out 113 * fields the user didn't know about. 114 */ 115 if (sizeof(*config) <= size) 116 size = sizeof(*config); 117 else 118 memset(((uint8_t *) config) + size, 0, sizeof(*config) - size); 119 120 /* Copy (portions of) the user's configuration. */ 121 memcpy(config, uconfig, size); 122 123 /* We copied user's size - fix it. */ 124 config->size = size; 125 126 return 0; 127 } 128 129 /* The maximum number of filter addresses that fit into the configuration. */ 130 static inline size_t pt_filter_addr_ncfg(void) 131 { 132 return (sizeof(struct pt_conf_addr_filter) - 133 offsetof(struct pt_conf_addr_filter, addr0_a)) / 134 (2 * sizeof(uint64_t)); 135 } 136 137 uint32_t pt_filter_addr_cfg(const struct pt_conf_addr_filter *filter, uint8_t n) 138 { 139 if (!filter) 140 return 0u; 141 142 if (pt_filter_addr_ncfg() <= n) 143 return 0u; 144 145 return (filter->config.addr_cfg >> (4 * n)) & 0xf; 146 } 147 148 uint64_t pt_filter_addr_a(const struct pt_conf_addr_filter *filter, uint8_t n) 149 { 150 const uint64_t *addr; 151 152 if (!filter) 153 return 0ull; 154 155 if (pt_filter_addr_ncfg() <= n) 156 return 0ull; 157 158 addr = &filter->addr0_a; 159 return addr[2 * n]; 160 } 161 162 uint64_t pt_filter_addr_b(const struct pt_conf_addr_filter *filter, uint8_t n) 163 { 164 const uint64_t *addr; 165 166 if (!filter) 167 return 0ull; 168 169 if (pt_filter_addr_ncfg() <= n) 170 return 0ull; 171 172 addr = &filter->addr0_a; 173 return addr[(2 * n) + 1]; 174 } 175 176 static int pt_filter_check_cfg_filter(const struct pt_conf_addr_filter *filter, 177 uint64_t addr) 178 { 179 uint8_t n; 180 181 if (!filter) 182 return -pte_internal; 183 184 for (n = 0; n < pt_filter_addr_ncfg(); ++n) { 185 uint64_t addr_a, addr_b; 186 uint32_t addr_cfg; 187 188 addr_cfg = pt_filter_addr_cfg(filter, n); 189 if (addr_cfg != pt_addr_cfg_filter) 190 continue; 191 192 addr_a = pt_filter_addr_a(filter, n); 193 addr_b = pt_filter_addr_b(filter, n); 194 195 /* Note that both A and B are inclusive. */ 196 if ((addr_a <= addr) && (addr <= addr_b)) 197 return 1; 198 } 199 200 /* No filter hit. If we have at least one FilterEn filter, this means 201 * that tracing is disabled; otherwise, tracing is enabled. 202 */ 203 for (n = 0; n < pt_filter_addr_ncfg(); ++n) { 204 uint32_t addr_cfg; 205 206 addr_cfg = pt_filter_addr_cfg(filter, n); 207 if (addr_cfg == pt_addr_cfg_filter) 208 return 0; 209 } 210 211 return 1; 212 } 213 214 static int pt_filter_check_cfg_stop(const struct pt_conf_addr_filter *filter, 215 uint64_t addr) 216 { 217 uint8_t n; 218 219 if (!filter) 220 return -pte_internal; 221 222 for (n = 0; n < pt_filter_addr_ncfg(); ++n) { 223 uint64_t addr_a, addr_b; 224 uint32_t addr_cfg; 225 226 addr_cfg = pt_filter_addr_cfg(filter, n); 227 if (addr_cfg != pt_addr_cfg_stop) 228 continue; 229 230 addr_a = pt_filter_addr_a(filter, n); 231 addr_b = pt_filter_addr_b(filter, n); 232 233 /* Note that both A and B are inclusive. */ 234 if ((addr_a <= addr) && (addr <= addr_b)) 235 return 0; 236 } 237 238 return 1; 239 } 240 241 int pt_filter_addr_check(const struct pt_conf_addr_filter *filter, 242 uint64_t addr) 243 { 244 int status; 245 246 status = pt_filter_check_cfg_stop(filter, addr); 247 if (status <= 0) 248 return status; 249 250 return pt_filter_check_cfg_filter(filter, addr); 251 } 252