1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <linux/atomic.h> 4 #include <linux/bsearch.h> 5 #include <linux/bug.h> 6 #include <linux/debugfs.h> 7 #include <linux/init.h> 8 #include <linux/kallsyms.h> 9 #include <linux/seq_file.h> 10 #include <linux/slab.h> 11 #include <linux/sort.h> 12 #include <linux/string.h> 13 #include <linux/uaccess.h> 14 15 #include "kcsan.h" 16 17 /* 18 * Statistics counters. 19 */ 20 static atomic_long_t counters[KCSAN_COUNTER_COUNT]; 21 22 /* 23 * Addresses for filtering functions from reporting. This list can be used as a 24 * whitelist or blacklist. 25 */ 26 static struct { 27 unsigned long *addrs; /* array of addresses */ 28 size_t size; /* current size */ 29 int used; /* number of elements used */ 30 bool sorted; /* if elements are sorted */ 31 bool whitelist; /* if list is a blacklist or whitelist */ 32 } report_filterlist = { 33 .addrs = NULL, 34 .size = 8, /* small initial size */ 35 .used = 0, 36 .sorted = false, 37 .whitelist = false, /* default is blacklist */ 38 }; 39 static DEFINE_SPINLOCK(report_filterlist_lock); 40 41 static const char *counter_to_name(enum kcsan_counter_id id) 42 { 43 switch (id) { 44 case KCSAN_COUNTER_USED_WATCHPOINTS: return "used_watchpoints"; 45 case KCSAN_COUNTER_SETUP_WATCHPOINTS: return "setup_watchpoints"; 46 case KCSAN_COUNTER_DATA_RACES: return "data_races"; 47 case KCSAN_COUNTER_NO_CAPACITY: return "no_capacity"; 48 case KCSAN_COUNTER_REPORT_RACES: return "report_races"; 49 case KCSAN_COUNTER_RACES_UNKNOWN_ORIGIN: return "races_unknown_origin"; 50 case KCSAN_COUNTER_UNENCODABLE_ACCESSES: return "unencodable_accesses"; 51 case KCSAN_COUNTER_ENCODING_FALSE_POSITIVES: return "encoding_false_positives"; 52 case KCSAN_COUNTER_COUNT: 53 BUG(); 54 } 55 return NULL; 56 } 57 58 void kcsan_counter_inc(enum kcsan_counter_id id) 59 { 60 atomic_long_inc(&counters[id]); 61 } 62 63 void kcsan_counter_dec(enum kcsan_counter_id id) 64 { 65 atomic_long_dec(&counters[id]); 66 } 67 68 /* 69 * The microbenchmark allows benchmarking KCSAN core runtime only. To run 70 * multiple threads, pipe 'microbench=<iters>' from multiple tasks into the 71 * debugfs file. 72 */ 73 static void microbenchmark(unsigned long iters) 74 { 75 cycles_t cycles; 76 77 pr_info("KCSAN: %s begin | iters: %lu\n", __func__, iters); 78 79 cycles = get_cycles(); 80 while (iters--) { 81 /* 82 * We can run this benchmark from multiple tasks; this address 83 * calculation increases likelyhood of some accesses overlapping 84 * (they still won't conflict because all are reads). 85 */ 86 unsigned long addr = 87 iters % (CONFIG_KCSAN_NUM_WATCHPOINTS * PAGE_SIZE); 88 __kcsan_check_read((void *)addr, sizeof(long)); 89 } 90 cycles = get_cycles() - cycles; 91 92 pr_info("KCSAN: %s end | cycles: %llu\n", __func__, cycles); 93 } 94 95 static int cmp_filterlist_addrs(const void *rhs, const void *lhs) 96 { 97 const unsigned long a = *(const unsigned long *)rhs; 98 const unsigned long b = *(const unsigned long *)lhs; 99 100 return a < b ? -1 : a == b ? 0 : 1; 101 } 102 103 bool kcsan_skip_report_debugfs(unsigned long func_addr) 104 { 105 unsigned long symbolsize, offset; 106 unsigned long flags; 107 bool ret = false; 108 109 if (!kallsyms_lookup_size_offset(func_addr, &symbolsize, &offset)) 110 return false; 111 func_addr -= offset; /* Get function start */ 112 113 spin_lock_irqsave(&report_filterlist_lock, flags); 114 if (report_filterlist.used == 0) 115 goto out; 116 117 /* Sort array if it is unsorted, and then do a binary search. */ 118 if (!report_filterlist.sorted) { 119 sort(report_filterlist.addrs, report_filterlist.used, 120 sizeof(unsigned long), cmp_filterlist_addrs, NULL); 121 report_filterlist.sorted = true; 122 } 123 ret = !!bsearch(&func_addr, report_filterlist.addrs, 124 report_filterlist.used, sizeof(unsigned long), 125 cmp_filterlist_addrs); 126 if (report_filterlist.whitelist) 127 ret = !ret; 128 129 out: 130 spin_unlock_irqrestore(&report_filterlist_lock, flags); 131 return ret; 132 } 133 134 static void set_report_filterlist_whitelist(bool whitelist) 135 { 136 unsigned long flags; 137 138 spin_lock_irqsave(&report_filterlist_lock, flags); 139 report_filterlist.whitelist = whitelist; 140 spin_unlock_irqrestore(&report_filterlist_lock, flags); 141 } 142 143 /* Returns 0 on success, error-code otherwise. */ 144 static ssize_t insert_report_filterlist(const char *func) 145 { 146 unsigned long flags; 147 unsigned long addr = kallsyms_lookup_name(func); 148 ssize_t ret = 0; 149 150 if (!addr) { 151 pr_err("KCSAN: could not find function: '%s'\n", func); 152 return -ENOENT; 153 } 154 155 spin_lock_irqsave(&report_filterlist_lock, flags); 156 157 if (report_filterlist.addrs == NULL) { 158 /* initial allocation */ 159 report_filterlist.addrs = 160 kmalloc_array(report_filterlist.size, 161 sizeof(unsigned long), GFP_KERNEL); 162 if (report_filterlist.addrs == NULL) { 163 ret = -ENOMEM; 164 goto out; 165 } 166 } else if (report_filterlist.used == report_filterlist.size) { 167 /* resize filterlist */ 168 size_t new_size = report_filterlist.size * 2; 169 unsigned long *new_addrs = 170 krealloc(report_filterlist.addrs, 171 new_size * sizeof(unsigned long), GFP_KERNEL); 172 173 if (new_addrs == NULL) { 174 /* leave filterlist itself untouched */ 175 ret = -ENOMEM; 176 goto out; 177 } 178 179 report_filterlist.size = new_size; 180 report_filterlist.addrs = new_addrs; 181 } 182 183 /* Note: deduplicating should be done in userspace. */ 184 report_filterlist.addrs[report_filterlist.used++] = 185 kallsyms_lookup_name(func); 186 report_filterlist.sorted = false; 187 188 out: 189 spin_unlock_irqrestore(&report_filterlist_lock, flags); 190 191 return ret; 192 } 193 194 static int show_info(struct seq_file *file, void *v) 195 { 196 int i; 197 unsigned long flags; 198 199 /* show stats */ 200 seq_printf(file, "enabled: %i\n", READ_ONCE(kcsan_enabled)); 201 for (i = 0; i < KCSAN_COUNTER_COUNT; ++i) 202 seq_printf(file, "%s: %ld\n", counter_to_name(i), 203 atomic_long_read(&counters[i])); 204 205 /* show filter functions, and filter type */ 206 spin_lock_irqsave(&report_filterlist_lock, flags); 207 seq_printf(file, "\n%s functions: %s\n", 208 report_filterlist.whitelist ? "whitelisted" : "blacklisted", 209 report_filterlist.used == 0 ? "none" : ""); 210 for (i = 0; i < report_filterlist.used; ++i) 211 seq_printf(file, " %ps\n", (void *)report_filterlist.addrs[i]); 212 spin_unlock_irqrestore(&report_filterlist_lock, flags); 213 214 return 0; 215 } 216 217 static int debugfs_open(struct inode *inode, struct file *file) 218 { 219 return single_open(file, show_info, NULL); 220 } 221 222 static ssize_t 223 debugfs_write(struct file *file, const char __user *buf, size_t count, loff_t *off) 224 { 225 char kbuf[KSYM_NAME_LEN]; 226 char *arg; 227 int read_len = count < (sizeof(kbuf) - 1) ? count : (sizeof(kbuf) - 1); 228 229 if (copy_from_user(kbuf, buf, read_len)) 230 return -EFAULT; 231 kbuf[read_len] = '\0'; 232 arg = strstrip(kbuf); 233 234 if (!strcmp(arg, "on")) { 235 WRITE_ONCE(kcsan_enabled, true); 236 } else if (!strcmp(arg, "off")) { 237 WRITE_ONCE(kcsan_enabled, false); 238 } else if (!strncmp(arg, "microbench=", sizeof("microbench=") - 1)) { 239 unsigned long iters; 240 241 if (kstrtoul(&arg[sizeof("microbench=") - 1], 0, &iters)) 242 return -EINVAL; 243 microbenchmark(iters); 244 } else if (!strcmp(arg, "whitelist")) { 245 set_report_filterlist_whitelist(true); 246 } else if (!strcmp(arg, "blacklist")) { 247 set_report_filterlist_whitelist(false); 248 } else if (arg[0] == '!') { 249 ssize_t ret = insert_report_filterlist(&arg[1]); 250 251 if (ret < 0) 252 return ret; 253 } else { 254 return -EINVAL; 255 } 256 257 return count; 258 } 259 260 static const struct file_operations debugfs_ops = 261 { 262 .read = seq_read, 263 .open = debugfs_open, 264 .write = debugfs_write, 265 .release = single_release 266 }; 267 268 void __init kcsan_debugfs_init(void) 269 { 270 debugfs_create_file("kcsan", 0644, NULL, NULL, &debugfs_ops); 271 } 272