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