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