1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020 HiSilicon Limited. 4 */ 5 6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 8 #include <linux/debugfs.h> 9 #include <linux/delay.h> 10 #include <linux/device.h> 11 #include <linux/dma-mapping.h> 12 #include <linux/kernel.h> 13 #include <linux/kthread.h> 14 #include <linux/map_benchmark.h> 15 #include <linux/math64.h> 16 #include <linux/module.h> 17 #include <linux/pci.h> 18 #include <linux/platform_device.h> 19 #include <linux/slab.h> 20 #include <linux/timekeeping.h> 21 22 struct map_benchmark_data { 23 struct map_benchmark bparam; 24 struct device *dev; 25 struct dentry *debugfs; 26 enum dma_data_direction dir; 27 atomic64_t sum_map_100ns; 28 atomic64_t sum_unmap_100ns; 29 atomic64_t sum_sq_map; 30 atomic64_t sum_sq_unmap; 31 atomic64_t loops; 32 }; 33 34 static int map_benchmark_thread(void *data) 35 { 36 void *buf; 37 dma_addr_t dma_addr; 38 struct map_benchmark_data *map = data; 39 int npages = map->bparam.granule; 40 u64 size = npages * PAGE_SIZE; 41 int ret = 0; 42 43 buf = alloc_pages_exact(size, GFP_KERNEL); 44 if (!buf) 45 return -ENOMEM; 46 47 while (!kthread_should_stop()) { 48 u64 map_100ns, unmap_100ns, map_sq, unmap_sq; 49 ktime_t map_stime, map_etime, unmap_stime, unmap_etime; 50 ktime_t map_delta, unmap_delta; 51 52 /* 53 * for a non-coherent device, if we don't stain them in the 54 * cache, this will give an underestimate of the real-world 55 * overhead of BIDIRECTIONAL or TO_DEVICE mappings; 56 * 66 means evertything goes well! 66 is lucky. 57 */ 58 if (map->dir != DMA_FROM_DEVICE) 59 memset(buf, 0x66, size); 60 61 map_stime = ktime_get(); 62 dma_addr = dma_map_single(map->dev, buf, size, map->dir); 63 if (unlikely(dma_mapping_error(map->dev, dma_addr))) { 64 pr_err("dma_map_single failed on %s\n", 65 dev_name(map->dev)); 66 ret = -ENOMEM; 67 goto out; 68 } 69 map_etime = ktime_get(); 70 map_delta = ktime_sub(map_etime, map_stime); 71 72 /* Pretend DMA is transmitting */ 73 ndelay(map->bparam.dma_trans_ns); 74 75 unmap_stime = ktime_get(); 76 dma_unmap_single(map->dev, dma_addr, size, map->dir); 77 unmap_etime = ktime_get(); 78 unmap_delta = ktime_sub(unmap_etime, unmap_stime); 79 80 /* calculate sum and sum of squares */ 81 82 map_100ns = div64_ul(map_delta, 100); 83 unmap_100ns = div64_ul(unmap_delta, 100); 84 map_sq = map_100ns * map_100ns; 85 unmap_sq = unmap_100ns * unmap_100ns; 86 87 atomic64_add(map_100ns, &map->sum_map_100ns); 88 atomic64_add(unmap_100ns, &map->sum_unmap_100ns); 89 atomic64_add(map_sq, &map->sum_sq_map); 90 atomic64_add(unmap_sq, &map->sum_sq_unmap); 91 atomic64_inc(&map->loops); 92 } 93 94 out: 95 free_pages_exact(buf, size); 96 return ret; 97 } 98 99 static int do_map_benchmark(struct map_benchmark_data *map) 100 { 101 struct task_struct **tsk; 102 int threads = map->bparam.threads; 103 int node = map->bparam.node; 104 const cpumask_t *cpu_mask = cpumask_of_node(node); 105 u64 loops; 106 int ret = 0; 107 int i; 108 109 tsk = kmalloc_array(threads, sizeof(*tsk), GFP_KERNEL); 110 if (!tsk) 111 return -ENOMEM; 112 113 get_device(map->dev); 114 115 for (i = 0; i < threads; i++) { 116 tsk[i] = kthread_create_on_node(map_benchmark_thread, map, 117 map->bparam.node, "dma-map-benchmark/%d", i); 118 if (IS_ERR(tsk[i])) { 119 pr_err("create dma_map thread failed\n"); 120 ret = PTR_ERR(tsk[i]); 121 while (--i >= 0) 122 kthread_stop(tsk[i]); 123 goto out; 124 } 125 126 if (node != NUMA_NO_NODE) 127 kthread_bind_mask(tsk[i], cpu_mask); 128 } 129 130 /* clear the old value in the previous benchmark */ 131 atomic64_set(&map->sum_map_100ns, 0); 132 atomic64_set(&map->sum_unmap_100ns, 0); 133 atomic64_set(&map->sum_sq_map, 0); 134 atomic64_set(&map->sum_sq_unmap, 0); 135 atomic64_set(&map->loops, 0); 136 137 for (i = 0; i < threads; i++) { 138 get_task_struct(tsk[i]); 139 wake_up_process(tsk[i]); 140 } 141 142 msleep_interruptible(map->bparam.seconds * 1000); 143 144 /* wait for the completion of all started benchmark threads */ 145 for (i = 0; i < threads; i++) { 146 int kthread_ret = kthread_stop_put(tsk[i]); 147 148 if (kthread_ret) 149 ret = kthread_ret; 150 } 151 152 if (ret) 153 goto out; 154 155 loops = atomic64_read(&map->loops); 156 if (likely(loops > 0)) { 157 u64 map_variance, unmap_variance; 158 u64 sum_map = atomic64_read(&map->sum_map_100ns); 159 u64 sum_unmap = atomic64_read(&map->sum_unmap_100ns); 160 u64 sum_sq_map = atomic64_read(&map->sum_sq_map); 161 u64 sum_sq_unmap = atomic64_read(&map->sum_sq_unmap); 162 163 /* average latency */ 164 map->bparam.avg_map_100ns = div64_u64(sum_map, loops); 165 map->bparam.avg_unmap_100ns = div64_u64(sum_unmap, loops); 166 167 /* standard deviation of latency */ 168 map_variance = div64_u64(sum_sq_map, loops) - 169 map->bparam.avg_map_100ns * 170 map->bparam.avg_map_100ns; 171 unmap_variance = div64_u64(sum_sq_unmap, loops) - 172 map->bparam.avg_unmap_100ns * 173 map->bparam.avg_unmap_100ns; 174 map->bparam.map_stddev = int_sqrt64(map_variance); 175 map->bparam.unmap_stddev = int_sqrt64(unmap_variance); 176 } 177 178 out: 179 put_device(map->dev); 180 kfree(tsk); 181 return ret; 182 } 183 184 static long map_benchmark_ioctl(struct file *file, unsigned int cmd, 185 unsigned long arg) 186 { 187 struct map_benchmark_data *map = file->private_data; 188 void __user *argp = (void __user *)arg; 189 u64 old_dma_mask; 190 int ret; 191 192 if (copy_from_user(&map->bparam, argp, sizeof(map->bparam))) 193 return -EFAULT; 194 195 switch (cmd) { 196 case DMA_MAP_BENCHMARK: 197 if (map->bparam.threads == 0 || 198 map->bparam.threads > DMA_MAP_MAX_THREADS) { 199 pr_err("invalid thread number\n"); 200 return -EINVAL; 201 } 202 203 if (map->bparam.seconds == 0 || 204 map->bparam.seconds > DMA_MAP_MAX_SECONDS) { 205 pr_err("invalid duration seconds\n"); 206 return -EINVAL; 207 } 208 209 if (map->bparam.dma_trans_ns > DMA_MAP_MAX_TRANS_DELAY) { 210 pr_err("invalid transmission delay\n"); 211 return -EINVAL; 212 } 213 214 if (map->bparam.node != NUMA_NO_NODE && 215 (map->bparam.node < 0 || map->bparam.node >= MAX_NUMNODES || 216 !node_possible(map->bparam.node))) { 217 pr_err("invalid numa node\n"); 218 return -EINVAL; 219 } 220 221 if (map->bparam.granule < 1 || map->bparam.granule > 1024) { 222 pr_err("invalid granule size\n"); 223 return -EINVAL; 224 } 225 226 switch (map->bparam.dma_dir) { 227 case DMA_MAP_BIDIRECTIONAL: 228 map->dir = DMA_BIDIRECTIONAL; 229 break; 230 case DMA_MAP_FROM_DEVICE: 231 map->dir = DMA_FROM_DEVICE; 232 break; 233 case DMA_MAP_TO_DEVICE: 234 map->dir = DMA_TO_DEVICE; 235 break; 236 default: 237 pr_err("invalid DMA direction\n"); 238 return -EINVAL; 239 } 240 241 old_dma_mask = dma_get_mask(map->dev); 242 243 ret = dma_set_mask(map->dev, 244 DMA_BIT_MASK(map->bparam.dma_bits)); 245 if (ret) { 246 pr_err("failed to set dma_mask on device %s\n", 247 dev_name(map->dev)); 248 return -EINVAL; 249 } 250 251 ret = do_map_benchmark(map); 252 253 /* 254 * restore the original dma_mask as many devices' dma_mask are 255 * set by architectures, acpi, busses. When we bind them back 256 * to their original drivers, those drivers shouldn't see 257 * dma_mask changed by benchmark 258 */ 259 dma_set_mask(map->dev, old_dma_mask); 260 261 if (ret) 262 return ret; 263 break; 264 default: 265 return -EINVAL; 266 } 267 268 if (copy_to_user(argp, &map->bparam, sizeof(map->bparam))) 269 return -EFAULT; 270 271 return ret; 272 } 273 274 static const struct file_operations map_benchmark_fops = { 275 .open = simple_open, 276 .unlocked_ioctl = map_benchmark_ioctl, 277 }; 278 279 static void map_benchmark_remove_debugfs(void *data) 280 { 281 struct map_benchmark_data *map = (struct map_benchmark_data *)data; 282 283 debugfs_remove(map->debugfs); 284 } 285 286 static int __map_benchmark_probe(struct device *dev) 287 { 288 struct dentry *entry; 289 struct map_benchmark_data *map; 290 int ret; 291 292 map = devm_kzalloc(dev, sizeof(*map), GFP_KERNEL); 293 if (!map) 294 return -ENOMEM; 295 map->dev = dev; 296 297 ret = devm_add_action(dev, map_benchmark_remove_debugfs, map); 298 if (ret) { 299 pr_err("Can't add debugfs remove action\n"); 300 return ret; 301 } 302 303 /* 304 * we only permit a device bound with this driver, 2nd probe 305 * will fail 306 */ 307 entry = debugfs_create_file("dma_map_benchmark", 0600, NULL, map, 308 &map_benchmark_fops); 309 if (IS_ERR(entry)) 310 return PTR_ERR(entry); 311 map->debugfs = entry; 312 313 return 0; 314 } 315 316 static int map_benchmark_platform_probe(struct platform_device *pdev) 317 { 318 return __map_benchmark_probe(&pdev->dev); 319 } 320 321 static struct platform_driver map_benchmark_platform_driver = { 322 .driver = { 323 .name = "dma_map_benchmark", 324 }, 325 .probe = map_benchmark_platform_probe, 326 }; 327 328 static int 329 map_benchmark_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) 330 { 331 return __map_benchmark_probe(&pdev->dev); 332 } 333 334 static struct pci_driver map_benchmark_pci_driver = { 335 .name = "dma_map_benchmark", 336 .probe = map_benchmark_pci_probe, 337 }; 338 339 static int __init map_benchmark_init(void) 340 { 341 int ret; 342 343 ret = pci_register_driver(&map_benchmark_pci_driver); 344 if (ret) 345 return ret; 346 347 ret = platform_driver_register(&map_benchmark_platform_driver); 348 if (ret) { 349 pci_unregister_driver(&map_benchmark_pci_driver); 350 return ret; 351 } 352 353 return 0; 354 } 355 356 static void __exit map_benchmark_cleanup(void) 357 { 358 platform_driver_unregister(&map_benchmark_platform_driver); 359 pci_unregister_driver(&map_benchmark_pci_driver); 360 } 361 362 module_init(map_benchmark_init); 363 module_exit(map_benchmark_cleanup); 364 365 MODULE_AUTHOR("Barry Song <[email protected]>"); 366 MODULE_DESCRIPTION("dma_map benchmark driver"); 367