Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Copyright (C) 2008 Advanced Micro Devices, Inc.
4 : : *
5 : : * Author: Joerg Roedel <joerg.roedel@amd.com>
6 : : */
7 : :
8 : : #define pr_fmt(fmt) "DMA-API: " fmt
9 : :
10 : : #include <linux/sched/task_stack.h>
11 : : #include <linux/scatterlist.h>
12 : : #include <linux/dma-mapping.h>
13 : : #include <linux/sched/task.h>
14 : : #include <linux/stacktrace.h>
15 : : #include <linux/dma-debug.h>
16 : : #include <linux/spinlock.h>
17 : : #include <linux/vmalloc.h>
18 : : #include <linux/debugfs.h>
19 : : #include <linux/uaccess.h>
20 : : #include <linux/export.h>
21 : : #include <linux/device.h>
22 : : #include <linux/types.h>
23 : : #include <linux/sched.h>
24 : : #include <linux/ctype.h>
25 : : #include <linux/list.h>
26 : : #include <linux/slab.h>
27 : :
28 : : #include <asm/sections.h>
29 : :
30 : : #define HASH_SIZE 16384ULL
31 : : #define HASH_FN_SHIFT 13
32 : : #define HASH_FN_MASK (HASH_SIZE - 1)
33 : :
34 : : #define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)
35 : : /* If the pool runs out, add this many new entries at once */
36 : : #define DMA_DEBUG_DYNAMIC_ENTRIES (PAGE_SIZE / sizeof(struct dma_debug_entry))
37 : :
38 : : enum {
39 : : dma_debug_single,
40 : : dma_debug_sg,
41 : : dma_debug_coherent,
42 : : dma_debug_resource,
43 : : };
44 : :
45 : : enum map_err_types {
46 : : MAP_ERR_CHECK_NOT_APPLICABLE,
47 : : MAP_ERR_NOT_CHECKED,
48 : : MAP_ERR_CHECKED,
49 : : };
50 : :
51 : : #define DMA_DEBUG_STACKTRACE_ENTRIES 5
52 : :
53 : : /**
54 : : * struct dma_debug_entry - track a dma_map* or dma_alloc_coherent mapping
55 : : * @list: node on pre-allocated free_entries list
56 : : * @dev: 'dev' argument to dma_map_{page|single|sg} or dma_alloc_coherent
57 : : * @size: length of the mapping
58 : : * @type: single, page, sg, coherent
59 : : * @direction: enum dma_data_direction
60 : : * @sg_call_ents: 'nents' from dma_map_sg
61 : : * @sg_mapped_ents: 'mapped_ents' from dma_map_sg
62 : : * @pfn: page frame of the start address
63 : : * @offset: offset of mapping relative to pfn
64 : : * @map_err_type: track whether dma_mapping_error() was checked
65 : : * @stacktrace: support backtraces when a violation is detected
66 : : */
67 : : struct dma_debug_entry {
68 : : struct list_head list;
69 : : struct device *dev;
70 : : u64 dev_addr;
71 : : u64 size;
72 : : int type;
73 : : int direction;
74 : : int sg_call_ents;
75 : : int sg_mapped_ents;
76 : : unsigned long pfn;
77 : : size_t offset;
78 : : enum map_err_types map_err_type;
79 : : #ifdef CONFIG_STACKTRACE
80 : : unsigned int stack_len;
81 : : unsigned long stack_entries[DMA_DEBUG_STACKTRACE_ENTRIES];
82 : : #endif
83 : : } ____cacheline_aligned_in_smp;
84 : :
85 : : typedef bool (*match_fn)(struct dma_debug_entry *, struct dma_debug_entry *);
86 : :
87 : : struct hash_bucket {
88 : : struct list_head list;
89 : : spinlock_t lock;
90 : : };
91 : :
92 : : /* Hash list to save the allocated dma addresses */
93 : : static struct hash_bucket dma_entry_hash[HASH_SIZE];
94 : : /* List of pre-allocated dma_debug_entry's */
95 : : static LIST_HEAD(free_entries);
96 : : /* Lock for the list above */
97 : : static DEFINE_SPINLOCK(free_entries_lock);
98 : :
99 : : /* Global disable flag - will be set in case of an error */
100 : : static bool global_disable __read_mostly;
101 : :
102 : : /* Early initialization disable flag, set at the end of dma_debug_init */
103 : : static bool dma_debug_initialized __read_mostly;
104 : :
105 : 46560 : static inline bool dma_debug_disabled(void)
106 : : {
107 [ - - - - : 46560 : return global_disable || !dma_debug_initialized;
- - - - -
- - - - -
+ - + - +
- - - + -
+ - + - +
- + - +
- ]
108 : : }
109 : :
110 : : /* Global error count */
111 : : static u32 error_count;
112 : :
113 : : /* Global error show enable*/
114 : : static u32 show_all_errors __read_mostly;
115 : : /* Number of errors to show */
116 : : static u32 show_num_errors = 1;
117 : :
118 : : static u32 num_free_entries;
119 : : static u32 min_free_entries;
120 : : static u32 nr_total_entries;
121 : :
122 : : /* number of preallocated entries requested by kernel cmdline */
123 : : static u32 nr_prealloc_entries = PREALLOC_DMA_DEBUG_ENTRIES;
124 : :
125 : : /* per-driver filter related state */
126 : :
127 : : #define NAME_MAX_LEN 64
128 : :
129 : : static char current_driver_name[NAME_MAX_LEN] __read_mostly;
130 : : static struct device_driver *current_driver __read_mostly;
131 : :
132 : : static DEFINE_RWLOCK(driver_name_lock);
133 : :
134 : : static const char *const maperr2str[] = {
135 : : [MAP_ERR_CHECK_NOT_APPLICABLE] = "dma map error check not applicable",
136 : : [MAP_ERR_NOT_CHECKED] = "dma map error not checked",
137 : : [MAP_ERR_CHECKED] = "dma map error checked",
138 : : };
139 : :
140 : : static const char *type2name[5] = { "single", "page",
141 : : "scather-gather", "coherent",
142 : : "resource" };
143 : :
144 : : static const char *dir2name[4] = { "DMA_BIDIRECTIONAL", "DMA_TO_DEVICE",
145 : : "DMA_FROM_DEVICE", "DMA_NONE" };
146 : :
147 : : /*
148 : : * The access to some variables in this macro is racy. We can't use atomic_t
149 : : * here because all these variables are exported to debugfs. Some of them even
150 : : * writeable. This is also the reason why a lock won't help much. But anyway,
151 : : * the races are no big deal. Here is why:
152 : : *
153 : : * error_count: the addition is racy, but the worst thing that can happen is
154 : : * that we don't count some errors
155 : : * show_num_errors: the subtraction is racy. Also no big deal because in
156 : : * worst case this will result in one warning more in the
157 : : * system log than the user configured. This variable is
158 : : * writeable via debugfs.
159 : : */
160 : 0 : static inline void dump_entry_trace(struct dma_debug_entry *entry)
161 : : {
162 : : #ifdef CONFIG_STACKTRACE
163 [ # # ]: 0 : if (entry) {
164 : 0 : pr_warn("Mapped at:\n");
165 : 0 : stack_trace_print(entry->stack_entries, entry->stack_len, 0);
166 : : }
167 : : #endif
168 : 0 : }
169 : :
170 : 0 : static bool driver_filter(struct device *dev)
171 : : {
172 : 0 : struct device_driver *drv;
173 : 0 : unsigned long flags;
174 : 0 : bool ret;
175 : :
176 : : /* driver filter off */
177 [ # # ]: 0 : if (likely(!current_driver_name[0]))
178 : : return true;
179 : :
180 : : /* driver filter on and initialized */
181 [ # # # # : 0 : if (current_driver && dev && dev->driver == current_driver)
# # ]
182 : : return true;
183 : :
184 : : /* driver filter on, but we can't filter on a NULL device... */
185 [ # # ]: 0 : if (!dev)
186 : : return false;
187 : :
188 [ # # # # ]: 0 : if (current_driver || !current_driver_name[0])
189 : : return false;
190 : :
191 : : /* driver filter on but not yet initialized */
192 : 0 : drv = dev->driver;
193 [ # # ]: 0 : if (!drv)
194 : : return false;
195 : :
196 : : /* lock to protect against change of current_driver_name */
197 : 0 : read_lock_irqsave(&driver_name_lock, flags);
198 : :
199 : 0 : ret = false;
200 [ # # ]: 0 : if (drv->name &&
201 [ # # ]: 0 : strncmp(current_driver_name, drv->name, NAME_MAX_LEN - 1) == 0) {
202 : 0 : current_driver = drv;
203 : 0 : ret = true;
204 : : }
205 : :
206 : 0 : read_unlock_irqrestore(&driver_name_lock, flags);
207 : :
208 : 0 : return ret;
209 : : }
210 : :
211 : : #define err_printk(dev, entry, format, arg...) do { \
212 : : error_count += 1; \
213 : : if (driver_filter(dev) && \
214 : : (show_all_errors || show_num_errors > 0)) { \
215 : : WARN(1, pr_fmt("%s %s: ") format, \
216 : : dev ? dev_driver_string(dev) : "NULL", \
217 : : dev ? dev_name(dev) : "NULL", ## arg); \
218 : : dump_entry_trace(entry); \
219 : : } \
220 : : if (!show_all_errors && show_num_errors > 0) \
221 : : show_num_errors -= 1; \
222 : : } while (0);
223 : :
224 : : /*
225 : : * Hash related functions
226 : : *
227 : : * Every DMA-API request is saved into a struct dma_debug_entry. To
228 : : * have quick access to these structs they are stored into a hash.
229 : : */
230 : 21808 : static int hash_fn(struct dma_debug_entry *entry)
231 : : {
232 : : /*
233 : : * Hash function is based on the dma address.
234 : : * We use bits 20-27 here as the index into the hash
235 : : */
236 : 21808 : return (entry->dev_addr >> HASH_FN_SHIFT) & HASH_FN_MASK;
237 : : }
238 : :
239 : : /*
240 : : * Request exclusive access to a hash bucket for a given dma_debug_entry.
241 : : */
242 : 21808 : static struct hash_bucket *get_hash_bucket(struct dma_debug_entry *entry,
243 : : unsigned long *flags)
244 : : __acquires(&dma_entry_hash[idx].lock)
245 : : {
246 : 21808 : int idx = hash_fn(entry);
247 : 21808 : unsigned long __flags;
248 : :
249 : 43616 : spin_lock_irqsave(&dma_entry_hash[idx].lock, __flags);
250 : 21808 : *flags = __flags;
251 : 21808 : return &dma_entry_hash[idx];
252 : : }
253 : :
254 : : /*
255 : : * Give up exclusive access to the hash bucket
256 : : */
257 : 21808 : static void put_hash_bucket(struct hash_bucket *bucket,
258 : : unsigned long flags)
259 : : __releases(&bucket->lock)
260 : : {
261 : 21808 : spin_unlock_irqrestore(&bucket->lock, flags);
262 : : }
263 : :
264 : 14344 : static bool exact_match(struct dma_debug_entry *a, struct dma_debug_entry *b)
265 : : {
266 : 14344 : return ((a->dev_addr == b->dev_addr) &&
267 [ - + + + : 13732 : (a->dev == b->dev)) ? true : false;
- + ]
268 : : }
269 : :
270 : 0 : static bool containing_match(struct dma_debug_entry *a,
271 : : struct dma_debug_entry *b)
272 : : {
273 [ # # ]: 0 : if (a->dev != b->dev)
274 : : return false;
275 : :
276 [ # # ]: 0 : if ((b->dev_addr <= a->dev_addr) &&
277 [ # # ]: 0 : ((b->dev_addr + b->size) >= (a->dev_addr + a->size)))
278 : 0 : return true;
279 : :
280 : : return false;
281 : : }
282 : :
283 : : /*
284 : : * Search a given entry in the hash bucket list
285 : : */
286 : 13536 : static struct dma_debug_entry *__hash_bucket_find(struct hash_bucket *bucket,
287 : : struct dma_debug_entry *ref,
288 : : match_fn match)
289 : : {
290 : 13536 : struct dma_debug_entry *entry, *ret = NULL;
291 : 13536 : int matches = 0, match_lvl, last_lvl = -1;
292 : :
293 [ + - ]: 13537 : list_for_each_entry(entry, &bucket->list, list) {
294 [ + + ]: 13537 : if (!match(ref, entry))
295 : 1 : continue;
296 : :
297 : : /*
298 : : * Some drivers map the same physical address multiple
299 : : * times. Without a hardware IOMMU this results in the
300 : : * same device addresses being put into the dma-debug
301 : : * hash multiple times too. This can result in false
302 : : * positives being reported. Therefore we implement a
303 : : * best-fit algorithm here which returns the entry from
304 : : * the hash which fits best to the reference value
305 : : * instead of the first-fit.
306 : : */
307 : 13536 : matches += 1;
308 : 13536 : match_lvl = 0;
309 [ - + ]: 13536 : entry->size == ref->size ? ++match_lvl : 0;
310 [ + - ]: 13536 : entry->type == ref->type ? ++match_lvl : 0;
311 [ + - ]: 13536 : entry->direction == ref->direction ? ++match_lvl : 0;
312 [ + - ]: 13536 : entry->sg_call_ents == ref->sg_call_ents ? ++match_lvl : 0;
313 : :
314 [ + - ]: 13536 : if (match_lvl == 4) {
315 : : /* perfect-fit - return the result */
316 : 13536 : return entry;
317 [ # # ]: 0 : } else if (match_lvl > last_lvl) {
318 : : /*
319 : : * We found an entry that fits better then the
320 : : * previous one or it is the 1st match.
321 : : */
322 : 0 : last_lvl = match_lvl;
323 : 0 : ret = entry;
324 : : }
325 : : }
326 : :
327 : : /*
328 : : * If we have multiple matches but no perfect-fit, just return
329 : : * NULL.
330 : : */
331 [ # # ]: 0 : ret = (matches == 1) ? ret : NULL;
332 : :
333 : : return ret;
334 : : }
335 : :
336 : 10607 : static struct dma_debug_entry *bucket_find_exact(struct hash_bucket *bucket,
337 : : struct dma_debug_entry *ref)
338 : : {
339 : 10607 : return __hash_bucket_find(bucket, ref, exact_match);
340 : : }
341 : :
342 : 0 : static struct dma_debug_entry *bucket_find_contain(struct hash_bucket **bucket,
343 : : struct dma_debug_entry *ref,
344 : : unsigned long *flags)
345 : : {
346 : :
347 [ # # ]: 0 : unsigned int max_range = dma_get_max_seg_size(ref->dev);
348 : 0 : struct dma_debug_entry *entry, index = *ref;
349 : 0 : unsigned int range = 0;
350 : :
351 [ # # ]: 0 : while (range <= max_range) {
352 : 0 : entry = __hash_bucket_find(*bucket, ref, containing_match);
353 : :
354 [ # # ]: 0 : if (entry)
355 : 0 : return entry;
356 : :
357 : : /*
358 : : * Nothing found, go back a hash bucket
359 : : */
360 : 0 : put_hash_bucket(*bucket, *flags);
361 : 0 : range += (1 << HASH_FN_SHIFT);
362 : 0 : index.dev_addr -= (1 << HASH_FN_SHIFT);
363 : 0 : *bucket = get_hash_bucket(&index, flags);
364 : : }
365 : :
366 : : return NULL;
367 : : }
368 : :
369 : : /*
370 : : * Add an entry to a hash bucket
371 : : */
372 : 10811 : static void hash_bucket_add(struct hash_bucket *bucket,
373 : : struct dma_debug_entry *entry)
374 : : {
375 : 10811 : list_add_tail(&entry->list, &bucket->list);
376 : : }
377 : :
378 : : /*
379 : : * Remove entry from a hash bucket list
380 : : */
381 : 10607 : static void hash_bucket_del(struct dma_debug_entry *entry)
382 : : {
383 : 10607 : list_del(&entry->list);
384 : : }
385 : :
386 : 0 : static unsigned long long phys_addr(struct dma_debug_entry *entry)
387 : : {
388 [ # # ]: 0 : if (entry->type == dma_debug_resource)
389 : 0 : return __pfn_to_phys(entry->pfn) + entry->offset;
390 : :
391 : 0 : return page_to_phys(pfn_to_page(entry->pfn)) + entry->offset;
392 : : }
393 : :
394 : : /*
395 : : * Dump mapping entries for debugging purposes
396 : : */
397 : 0 : void debug_dma_dump_mappings(struct device *dev)
398 : : {
399 : 0 : int idx;
400 : :
401 [ # # ]: 0 : for (idx = 0; idx < HASH_SIZE; idx++) {
402 : 0 : struct hash_bucket *bucket = &dma_entry_hash[idx];
403 : 0 : struct dma_debug_entry *entry;
404 : 0 : unsigned long flags;
405 : :
406 : 0 : spin_lock_irqsave(&bucket->lock, flags);
407 : :
408 [ # # ]: 0 : list_for_each_entry(entry, &bucket->list, list) {
409 [ # # # # ]: 0 : if (!dev || dev == entry->dev) {
410 [ # # ]: 0 : dev_info(entry->dev,
411 : : "%s idx %d P=%Lx N=%lx D=%Lx L=%Lx %s %s\n",
412 : : type2name[entry->type], idx,
413 : : phys_addr(entry), entry->pfn,
414 : : entry->dev_addr, entry->size,
415 : : dir2name[entry->direction],
416 : : maperr2str[entry->map_err_type]);
417 : : }
418 : : }
419 : :
420 : 0 : spin_unlock_irqrestore(&bucket->lock, flags);
421 : 0 : cond_resched();
422 : : }
423 : 0 : }
424 : :
425 : : /*
426 : : * For each mapping (initial cacheline in the case of
427 : : * dma_alloc_coherent/dma_map_page, initial cacheline in each page of a
428 : : * scatterlist, or the cacheline specified in dma_map_single) insert
429 : : * into this tree using the cacheline as the key. At
430 : : * dma_unmap_{single|sg|page} or dma_free_coherent delete the entry. If
431 : : * the entry already exists at insertion time add a tag as a reference
432 : : * count for the overlapping mappings. For now, the overlap tracking
433 : : * just ensures that 'unmaps' balance 'maps' before marking the
434 : : * cacheline idle, but we should also be flagging overlaps as an API
435 : : * violation.
436 : : *
437 : : * Memory usage is mostly constrained by the maximum number of available
438 : : * dma-debug entries in that we need a free dma_debug_entry before
439 : : * inserting into the tree. In the case of dma_map_page and
440 : : * dma_alloc_coherent there is only one dma_debug_entry and one
441 : : * dma_active_cacheline entry to track per event. dma_map_sg(), on the
442 : : * other hand, consumes a single dma_debug_entry, but inserts 'nents'
443 : : * entries into the tree.
444 : : *
445 : : * At any time debug_dma_assert_idle() can be called to trigger a
446 : : * warning if any cachelines in the given page are in the active set.
447 : : */
448 : : static RADIX_TREE(dma_active_cacheline, GFP_NOWAIT);
449 : : static DEFINE_SPINLOCK(radix_lock);
450 : : #define ACTIVE_CACHELINE_MAX_OVERLAP ((1 << RADIX_TREE_MAX_TAGS) - 1)
451 : : #define CACHELINE_PER_PAGE_SHIFT (PAGE_SHIFT - L1_CACHE_SHIFT)
452 : : #define CACHELINES_PER_PAGE (1 << CACHELINE_PER_PAGE_SHIFT)
453 : :
454 : 59306 : static phys_addr_t to_cacheline_number(struct dma_debug_entry *entry)
455 : : {
456 : 59306 : return (entry->pfn << CACHELINE_PER_PAGE_SHIFT) +
457 : 59306 : (entry->offset >> L1_CACHE_SHIFT);
458 : : }
459 : :
460 : 10272 : static int active_cacheline_read_overlap(phys_addr_t cln)
461 : : {
462 : 10272 : int overlap = 0, i;
463 : :
464 [ + + ]: 41088 : for (i = RADIX_TREE_MAX_TAGS - 1; i >= 0; i--)
465 [ - + ]: 30816 : if (radix_tree_tag_get(&dma_active_cacheline, cln, i))
466 : 0 : overlap |= 1 << i;
467 : 10272 : return overlap;
468 : : }
469 : :
470 : 10272 : static int active_cacheline_set_overlap(phys_addr_t cln, int overlap)
471 : : {
472 : 10272 : int i;
473 : :
474 [ - + ]: 10272 : if (overlap > ACTIVE_CACHELINE_MAX_OVERLAP || overlap < 0)
475 : : return overlap;
476 : :
477 [ # # ]: 0 : for (i = RADIX_TREE_MAX_TAGS - 1; i >= 0; i--)
478 [ # # ]: 0 : if (overlap & 1 << i)
479 : 0 : radix_tree_tag_set(&dma_active_cacheline, cln, i);
480 : : else
481 : 0 : radix_tree_tag_clear(&dma_active_cacheline, cln, i);
482 : :
483 : : return overlap;
484 : : }
485 : :
486 : 0 : static void active_cacheline_inc_overlap(phys_addr_t cln)
487 : : {
488 : 0 : int overlap = active_cacheline_read_overlap(cln);
489 : :
490 : 0 : overlap = active_cacheline_set_overlap(cln, ++overlap);
491 : :
492 : : /* If we overflowed the overlap counter then we're potentially
493 : : * leaking dma-mappings. Otherwise, if maps and unmaps are
494 : : * balanced then this overflow may cause false negatives in
495 : : * debug_dma_assert_idle() as the cacheline may be marked idle
496 : : * prematurely.
497 : : */
498 [ # # # # ]: 0 : WARN_ONCE(overlap > ACTIVE_CACHELINE_MAX_OVERLAP,
499 : : pr_fmt("exceeded %d overlapping mappings of cacheline %pa\n"),
500 : : ACTIVE_CACHELINE_MAX_OVERLAP, &cln);
501 : 0 : }
502 : :
503 : 10272 : static int active_cacheline_dec_overlap(phys_addr_t cln)
504 : : {
505 : 10272 : int overlap = active_cacheline_read_overlap(cln);
506 : :
507 : 10272 : return active_cacheline_set_overlap(cln, --overlap);
508 : : }
509 : :
510 : 10811 : static int active_cacheline_insert(struct dma_debug_entry *entry)
511 : : {
512 : 10811 : phys_addr_t cln = to_cacheline_number(entry);
513 : 10811 : unsigned long flags;
514 : 10811 : int rc;
515 : :
516 : : /* If the device is not writing memory then we don't have any
517 : : * concerns about the cpu consuming stale data. This mitigates
518 : : * legitimate usages of overlapping mappings.
519 : : */
520 [ + + ]: 10811 : if (entry->direction == DMA_TO_DEVICE)
521 : : return 0;
522 : :
523 : 10473 : spin_lock_irqsave(&radix_lock, flags);
524 : 10473 : rc = radix_tree_insert(&dma_active_cacheline, cln, entry);
525 [ - + ]: 10473 : if (rc == -EEXIST)
526 : 0 : active_cacheline_inc_overlap(cln);
527 : 10473 : spin_unlock_irqrestore(&radix_lock, flags);
528 : :
529 : 10473 : return rc;
530 : : }
531 : :
532 : 10607 : static void active_cacheline_remove(struct dma_debug_entry *entry)
533 : : {
534 : 10607 : phys_addr_t cln = to_cacheline_number(entry);
535 : 10607 : unsigned long flags;
536 : :
537 : : /* ...mirror the insert case */
538 [ + + ]: 10607 : if (entry->direction == DMA_TO_DEVICE)
539 : : return;
540 : :
541 : 10272 : spin_lock_irqsave(&radix_lock, flags);
542 : : /* since we are counting overlaps the final put of the
543 : : * cacheline will occur when the overlap count is 0.
544 : : * active_cacheline_dec_overlap() returns -1 in that case
545 : : */
546 [ + - ]: 10272 : if (active_cacheline_dec_overlap(cln) < 0)
547 : 10272 : radix_tree_delete(&dma_active_cacheline, cln);
548 : 10272 : spin_unlock_irqrestore(&radix_lock, flags);
549 : : }
550 : :
551 : : /**
552 : : * debug_dma_assert_idle() - assert that a page is not undergoing dma
553 : : * @page: page to lookup in the dma_active_cacheline tree
554 : : *
555 : : * Place a call to this routine in cases where the cpu touching the page
556 : : * before the dma completes (page is dma_unmapped) will lead to data
557 : : * corruption.
558 : : */
559 : 39853 : void debug_dma_assert_idle(struct page *page)
560 : : {
561 : 39853 : static struct dma_debug_entry *ents[CACHELINES_PER_PAGE];
562 : 39853 : struct dma_debug_entry *entry = NULL;
563 : 39853 : void **results = (void **) &ents;
564 : 39853 : unsigned int nents, i;
565 : 39853 : unsigned long flags;
566 : 39853 : phys_addr_t cln;
567 : :
568 [ + - + - ]: 79706 : if (dma_debug_disabled())
569 : 39853 : return;
570 : :
571 [ + - ]: 39853 : if (!page)
572 : : return;
573 : :
574 : 39853 : cln = (phys_addr_t) page_to_pfn(page) << CACHELINE_PER_PAGE_SHIFT;
575 : 39853 : spin_lock_irqsave(&radix_lock, flags);
576 : 39853 : nents = radix_tree_gang_lookup(&dma_active_cacheline, results, cln,
577 : : CACHELINES_PER_PAGE);
578 [ + + ]: 79706 : for (i = 0; i < nents; i++) {
579 : 37888 : phys_addr_t ent_cln = to_cacheline_number(ents[i]);
580 : :
581 [ + - ]: 37888 : if (ent_cln == cln) {
582 : : entry = ents[i];
583 : : break;
584 [ - + ]: 37888 : } else if (ent_cln >= cln + CACHELINES_PER_PAGE)
585 : : break;
586 : : }
587 : 39853 : spin_unlock_irqrestore(&radix_lock, flags);
588 : :
589 [ - + ]: 39853 : if (!entry)
590 : : return;
591 : :
592 : 0 : cln = to_cacheline_number(entry);
593 [ # # # # : 0 : err_printk(entry->dev, entry,
# # # # #
# # # #
# ]
594 : : "cpu touching an active dma mapped cacheline [cln=%pa]\n",
595 : 0 : &cln);
596 : : }
597 : :
598 : : /*
599 : : * Wrapper function for adding an entry to the hash.
600 : : * This function takes care of locking itself.
601 : : */
602 : 10811 : static void add_dma_entry(struct dma_debug_entry *entry)
603 : : {
604 : 10811 : struct hash_bucket *bucket;
605 : 10811 : unsigned long flags;
606 : 10811 : int rc;
607 : :
608 : 10811 : bucket = get_hash_bucket(entry, &flags);
609 : 10811 : hash_bucket_add(bucket, entry);
610 : 10811 : put_hash_bucket(bucket, flags);
611 : :
612 : 10811 : rc = active_cacheline_insert(entry);
613 [ - + ]: 10811 : if (rc == -ENOMEM) {
614 : 0 : pr_err("cacheline tracking ENOMEM, dma-debug disabled\n");
615 : 0 : global_disable = true;
616 : : }
617 : :
618 : : /* TODO: report -EEXIST errors here as overlapping mappings are
619 : : * not supported by the DMA API
620 : : */
621 : 10811 : }
622 : :
623 : 6144 : static int dma_debug_create_entries(gfp_t gfp)
624 : : {
625 : 6144 : struct dma_debug_entry *entry;
626 : 6144 : int i;
627 : :
628 : 6144 : entry = (void *)get_zeroed_page(gfp);
629 [ + - ]: 6144 : if (!entry)
630 : : return -ENOMEM;
631 : :
632 [ + + ]: 202752 : for (i = 0; i < DMA_DEBUG_DYNAMIC_ENTRIES; i++)
633 : 196608 : list_add_tail(&entry[i].list, &free_entries);
634 : :
635 : 6144 : num_free_entries += DMA_DEBUG_DYNAMIC_ENTRIES;
636 : 6144 : nr_total_entries += DMA_DEBUG_DYNAMIC_ENTRIES;
637 : :
638 : 6144 : return 0;
639 : : }
640 : :
641 : 10811 : static struct dma_debug_entry *__dma_entry_alloc(void)
642 : : {
643 : 10811 : struct dma_debug_entry *entry;
644 : :
645 : 10811 : entry = list_entry(free_entries.next, struct dma_debug_entry, list);
646 [ + + ]: 10811 : list_del(&entry->list);
647 : 10811 : memset(entry, 0, sizeof(*entry));
648 : :
649 : 10811 : num_free_entries -= 1;
650 [ + + ]: 10811 : if (num_free_entries < min_free_entries)
651 : 328 : min_free_entries = num_free_entries;
652 : :
653 : 10811 : return entry;
654 : : }
655 : :
656 : 0 : void __dma_entry_alloc_check_leak(void)
657 : : {
658 : 0 : u32 tmp = nr_total_entries % nr_prealloc_entries;
659 : :
660 : : /* Shout each time we tick over some multiple of the initial pool */
661 [ # # ]: 0 : if (tmp < DMA_DEBUG_DYNAMIC_ENTRIES) {
662 : 0 : pr_info("dma_debug_entry pool grown to %u (%u00%%)\n",
663 : : nr_total_entries,
664 : : (nr_total_entries / nr_prealloc_entries));
665 : : }
666 : 0 : }
667 : :
668 : : /* struct dma_entry allocator
669 : : *
670 : : * The next two functions implement the allocator for
671 : : * struct dma_debug_entries.
672 : : */
673 : 10811 : static struct dma_debug_entry *dma_entry_alloc(void)
674 : : {
675 : 10811 : struct dma_debug_entry *entry;
676 : 10811 : unsigned long flags;
677 : :
678 : 10811 : spin_lock_irqsave(&free_entries_lock, flags);
679 [ - + ]: 10811 : if (num_free_entries == 0) {
680 [ # # ]: 0 : if (dma_debug_create_entries(GFP_ATOMIC)) {
681 : 0 : global_disable = true;
682 : 0 : spin_unlock_irqrestore(&free_entries_lock, flags);
683 : 0 : pr_err("debugging out of memory - disabling\n");
684 : 0 : return NULL;
685 : : }
686 : 0 : __dma_entry_alloc_check_leak();
687 : : }
688 : :
689 : 10811 : entry = __dma_entry_alloc();
690 : :
691 : 10811 : spin_unlock_irqrestore(&free_entries_lock, flags);
692 : :
693 : : #ifdef CONFIG_STACKTRACE
694 : 10811 : entry->stack_len = stack_trace_save(entry->stack_entries,
695 : : ARRAY_SIZE(entry->stack_entries),
696 : : 1);
697 : : #endif
698 : 10811 : return entry;
699 : : }
700 : :
701 : 10607 : static void dma_entry_free(struct dma_debug_entry *entry)
702 : : {
703 : 10607 : unsigned long flags;
704 : :
705 : 10607 : active_cacheline_remove(entry);
706 : :
707 : : /*
708 : : * add to beginning of the list - this way the entries are
709 : : * more likely cache hot when they are reallocated.
710 : : */
711 : 10607 : spin_lock_irqsave(&free_entries_lock, flags);
712 : 10607 : list_add(&entry->list, &free_entries);
713 : 10607 : num_free_entries += 1;
714 : 10607 : spin_unlock_irqrestore(&free_entries_lock, flags);
715 : 10607 : }
716 : :
717 : : /*
718 : : * DMA-API debugging init code
719 : : *
720 : : * The init code does two things:
721 : : * 1. Initialize core data structures
722 : : * 2. Preallocate a given number of dma_debug_entry structs
723 : : */
724 : :
725 : 0 : static ssize_t filter_read(struct file *file, char __user *user_buf,
726 : : size_t count, loff_t *ppos)
727 : : {
728 : 0 : char buf[NAME_MAX_LEN + 1];
729 : 0 : unsigned long flags;
730 : 0 : int len;
731 : :
732 [ # # ]: 0 : if (!current_driver_name[0])
733 : : return 0;
734 : :
735 : : /*
736 : : * We can't copy to userspace directly because current_driver_name can
737 : : * only be read under the driver_name_lock with irqs disabled. So
738 : : * create a temporary copy first.
739 : : */
740 : 0 : read_lock_irqsave(&driver_name_lock, flags);
741 : 0 : len = scnprintf(buf, NAME_MAX_LEN + 1, "%s\n", current_driver_name);
742 : 0 : read_unlock_irqrestore(&driver_name_lock, flags);
743 : :
744 : 0 : return simple_read_from_buffer(user_buf, count, ppos, buf, len);
745 : : }
746 : :
747 : 0 : static ssize_t filter_write(struct file *file, const char __user *userbuf,
748 : : size_t count, loff_t *ppos)
749 : : {
750 : 0 : char buf[NAME_MAX_LEN];
751 : 0 : unsigned long flags;
752 : 0 : size_t len;
753 : 0 : int i;
754 : :
755 : : /*
756 : : * We can't copy from userspace directly. Access to
757 : : * current_driver_name is protected with a write_lock with irqs
758 : : * disabled. Since copy_from_user can fault and may sleep we
759 : : * need to copy to temporary buffer first
760 : : */
761 : 0 : len = min(count, (size_t)(NAME_MAX_LEN - 1));
762 [ # # ]: 0 : if (copy_from_user(buf, userbuf, len))
763 : : return -EFAULT;
764 : :
765 : 0 : buf[len] = 0;
766 : :
767 : 0 : write_lock_irqsave(&driver_name_lock, flags);
768 : :
769 : : /*
770 : : * Now handle the string we got from userspace very carefully.
771 : : * The rules are:
772 : : * - only use the first token we got
773 : : * - token delimiter is everything looking like a space
774 : : * character (' ', '\n', '\t' ...)
775 : : *
776 : : */
777 [ # # ]: 0 : if (!isalnum(buf[0])) {
778 : : /*
779 : : * If the first character userspace gave us is not
780 : : * alphanumerical then assume the filter should be
781 : : * switched off.
782 : : */
783 [ # # ]: 0 : if (current_driver_name[0])
784 : 0 : pr_info("switching off dma-debug driver filter\n");
785 : 0 : current_driver_name[0] = 0;
786 : 0 : current_driver = NULL;
787 : 0 : goto out_unlock;
788 : : }
789 : :
790 : : /*
791 : : * Now parse out the first token and use it as the name for the
792 : : * driver to filter for.
793 : : */
794 [ # # ]: 0 : for (i = 0; i < NAME_MAX_LEN - 1; ++i) {
795 : 0 : current_driver_name[i] = buf[i];
796 [ # # # # : 0 : if (isspace(buf[i]) || buf[i] == ' ' || buf[i] == 0)
# # ]
797 : : break;
798 : : }
799 : 0 : current_driver_name[i] = 0;
800 : 0 : current_driver = NULL;
801 : :
802 : 0 : pr_info("enable driver filter for driver [%s]\n",
803 : : current_driver_name);
804 : :
805 : 0 : out_unlock:
806 : 0 : write_unlock_irqrestore(&driver_name_lock, flags);
807 : :
808 : 0 : return count;
809 : : }
810 : :
811 : : static const struct file_operations filter_fops = {
812 : : .read = filter_read,
813 : : .write = filter_write,
814 : : .llseek = default_llseek,
815 : : };
816 : :
817 : 0 : static int dump_show(struct seq_file *seq, void *v)
818 : : {
819 : 0 : int idx;
820 : :
821 [ # # ]: 0 : for (idx = 0; idx < HASH_SIZE; idx++) {
822 : 0 : struct hash_bucket *bucket = &dma_entry_hash[idx];
823 : 0 : struct dma_debug_entry *entry;
824 : 0 : unsigned long flags;
825 : :
826 : 0 : spin_lock_irqsave(&bucket->lock, flags);
827 [ # # ]: 0 : list_for_each_entry(entry, &bucket->list, list) {
828 : 0 : seq_printf(seq,
829 : : "%s %s %s idx %d P=%llx N=%lx D=%llx L=%llx %s %s\n",
830 [ # # ]: 0 : dev_name(entry->dev),
831 : 0 : dev_driver_string(entry->dev),
832 : : type2name[entry->type], idx,
833 : : phys_addr(entry), entry->pfn,
834 : : entry->dev_addr, entry->size,
835 : 0 : dir2name[entry->direction],
836 [ # # ]: 0 : maperr2str[entry->map_err_type]);
837 : : }
838 : 0 : spin_unlock_irqrestore(&bucket->lock, flags);
839 : : }
840 : 0 : return 0;
841 : : }
842 : 0 : DEFINE_SHOW_ATTRIBUTE(dump);
843 : :
844 : 3 : static void dma_debug_fs_init(void)
845 : : {
846 : 3 : struct dentry *dentry = debugfs_create_dir("dma-api", NULL);
847 : :
848 : 3 : debugfs_create_bool("disabled", 0444, dentry, &global_disable);
849 : 3 : debugfs_create_u32("error_count", 0444, dentry, &error_count);
850 : 3 : debugfs_create_u32("all_errors", 0644, dentry, &show_all_errors);
851 : 3 : debugfs_create_u32("num_errors", 0644, dentry, &show_num_errors);
852 : 3 : debugfs_create_u32("num_free_entries", 0444, dentry, &num_free_entries);
853 : 3 : debugfs_create_u32("min_free_entries", 0444, dentry, &min_free_entries);
854 : 3 : debugfs_create_u32("nr_total_entries", 0444, dentry, &nr_total_entries);
855 : 3 : debugfs_create_file("driver_filter", 0644, dentry, NULL, &filter_fops);
856 : 3 : debugfs_create_file("dump", 0444, dentry, NULL, &dump_fops);
857 : 3 : }
858 : :
859 : 0 : static int device_dma_allocations(struct device *dev, struct dma_debug_entry **out_entry)
860 : : {
861 : 0 : struct dma_debug_entry *entry;
862 : 0 : unsigned long flags;
863 : 0 : int count = 0, i;
864 : :
865 [ # # ]: 0 : for (i = 0; i < HASH_SIZE; ++i) {
866 : 0 : spin_lock_irqsave(&dma_entry_hash[i].lock, flags);
867 [ # # ]: 0 : list_for_each_entry(entry, &dma_entry_hash[i].list, list) {
868 [ # # ]: 0 : if (entry->dev == dev) {
869 : 0 : count += 1;
870 : 0 : *out_entry = entry;
871 : : }
872 : : }
873 : 0 : spin_unlock_irqrestore(&dma_entry_hash[i].lock, flags);
874 : : }
875 : :
876 : 0 : return count;
877 : : }
878 : :
879 : 57 : static int dma_debug_device_change(struct notifier_block *nb, unsigned long action, void *data)
880 : : {
881 : 57 : struct device *dev = data;
882 : 57 : struct dma_debug_entry *uninitialized_var(entry);
883 : 57 : int count;
884 : :
885 [ + - + - ]: 114 : if (dma_debug_disabled())
886 : : return 0;
887 : :
888 [ - + ]: 57 : switch (action) {
889 : 0 : case BUS_NOTIFY_UNBOUND_DRIVER:
890 : 0 : count = device_dma_allocations(dev, &entry);
891 [ # # ]: 0 : if (count == 0)
892 : : break;
893 [ # # # # : 0 : err_printk(dev, entry, "device driver has pending "
# # # # #
# # # #
# ]
894 : : "DMA allocations while released from device "
895 : : "[count=%d]\n"
896 : : "One of leaked entries details: "
897 : : "[device address=0x%016llx] [size=%llu bytes] "
898 : : "[mapped with %s] [mapped as %s]\n",
899 : : count, entry->dev_addr, entry->size,
900 : : dir2name[entry->direction], type2name[entry->type]);
901 : : break;
902 : : default:
903 : : break;
904 : : }
905 : :
906 : 0 : return 0;
907 : : }
908 : :
909 : 3 : void dma_debug_add_bus(struct bus_type *bus)
910 : : {
911 : 3 : struct notifier_block *nb;
912 : :
913 [ + - + - ]: 6 : if (dma_debug_disabled())
914 : : return;
915 : :
916 : 3 : nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
917 [ - + ]: 3 : if (nb == NULL) {
918 : 0 : pr_err("dma_debug_add_bus: out of memory\n");
919 : 0 : return;
920 : : }
921 : :
922 : 3 : nb->notifier_call = dma_debug_device_change;
923 : :
924 : 3 : bus_register_notifier(bus, nb);
925 : : }
926 : :
927 : 3 : static int dma_debug_init(void)
928 : : {
929 : 3 : int i, nr_pages;
930 : :
931 : : /* Do not use dma_debug_initialized here, since we really want to be
932 : : * called to set dma_debug_initialized
933 : : */
934 [ + - ]: 3 : if (global_disable)
935 : : return 0;
936 : :
937 [ + + ]: 49155 : for (i = 0; i < HASH_SIZE; ++i) {
938 : 49152 : INIT_LIST_HEAD(&dma_entry_hash[i].list);
939 : 49152 : spin_lock_init(&dma_entry_hash[i].lock);
940 : : }
941 : :
942 : 3 : dma_debug_fs_init();
943 : :
944 : 3 : nr_pages = DIV_ROUND_UP(nr_prealloc_entries, DMA_DEBUG_DYNAMIC_ENTRIES);
945 [ + + ]: 6147 : for (i = 0; i < nr_pages; ++i)
946 : 6144 : dma_debug_create_entries(GFP_KERNEL);
947 [ + - ]: 3 : if (num_free_entries >= nr_prealloc_entries) {
948 : 3 : pr_info("preallocated %d debug entries\n", nr_total_entries);
949 [ # # ]: 0 : } else if (num_free_entries > 0) {
950 : 0 : pr_warn("%d debug entries requested but only %d allocated\n",
951 : : nr_prealloc_entries, nr_total_entries);
952 : : } else {
953 : 0 : pr_err("debugging out of memory error - disabled\n");
954 : 0 : global_disable = true;
955 : :
956 : 0 : return 0;
957 : : }
958 : 3 : min_free_entries = num_free_entries;
959 : :
960 : 3 : dma_debug_initialized = true;
961 : :
962 : 3 : pr_info("debugging enabled by kernel config\n");
963 : 3 : return 0;
964 : : }
965 : : core_initcall(dma_debug_init);
966 : :
967 : 0 : static __init int dma_debug_cmdline(char *str)
968 : : {
969 [ # # ]: 0 : if (!str)
970 : : return -EINVAL;
971 : :
972 [ # # ]: 0 : if (strncmp(str, "off", 3) == 0) {
973 : 0 : pr_info("debugging disabled on kernel command line\n");
974 : 0 : global_disable = true;
975 : : }
976 : :
977 : : return 0;
978 : : }
979 : :
980 : 0 : static __init int dma_debug_entries_cmdline(char *str)
981 : : {
982 [ # # ]: 0 : if (!str)
983 : : return -EINVAL;
984 [ # # ]: 0 : if (!get_option(&str, &nr_prealloc_entries))
985 : 0 : nr_prealloc_entries = PREALLOC_DMA_DEBUG_ENTRIES;
986 : : return 0;
987 : : }
988 : :
989 : : __setup("dma_debug=", dma_debug_cmdline);
990 : : __setup("dma_debug_entries=", dma_debug_entries_cmdline);
991 : :
992 : 10607 : static void check_unmap(struct dma_debug_entry *ref)
993 : : {
994 : 10607 : struct dma_debug_entry *entry;
995 : 10607 : struct hash_bucket *bucket;
996 : 10607 : unsigned long flags;
997 : :
998 : 10607 : bucket = get_hash_bucket(ref, &flags);
999 : 10607 : entry = bucket_find_exact(bucket, ref);
1000 : :
1001 [ - + ]: 10607 : if (!entry) {
1002 : : /* must drop lock before calling dma_mapping_error */
1003 : 0 : put_hash_bucket(bucket, flags);
1004 : :
1005 : 0 : if (dma_mapping_error(ref->dev, ref->dev_addr)) {
1006 [ # # # # : 0 : err_printk(ref->dev, NULL,
# # # # #
# # # #
# ]
1007 : : "device driver tries to free an "
1008 : : "invalid DMA memory address\n");
1009 : : } else {
1010 [ # # # # : 0 : err_printk(ref->dev, NULL,
# # # # #
# # # #
# ]
1011 : : "device driver tries to free DMA "
1012 : : "memory it has not allocated [device "
1013 : : "address=0x%016llx] [size=%llu bytes]\n",
1014 : 0 : ref->dev_addr, ref->size);
1015 : : }
1016 : 0 : return;
1017 : : }
1018 : :
1019 [ - + ]: 10607 : if (ref->size != entry->size) {
1020 [ # # # # : 0 : err_printk(ref->dev, entry, "device driver frees "
# # # # #
# # # #
# ]
1021 : : "DMA memory with different size "
1022 : : "[device address=0x%016llx] [map size=%llu bytes] "
1023 : : "[unmap size=%llu bytes]\n",
1024 : 10607 : ref->dev_addr, entry->size, ref->size);
1025 : : }
1026 : :
1027 [ - + ]: 10607 : if (ref->type != entry->type) {
1028 [ # # # # : 0 : err_printk(ref->dev, entry, "device driver frees "
# # # # #
# # # #
# ]
1029 : : "DMA memory with wrong function "
1030 : : "[device address=0x%016llx] [size=%llu bytes] "
1031 : : "[mapped as %s] [unmapped as %s]\n",
1032 : : ref->dev_addr, ref->size,
1033 : : type2name[entry->type], type2name[ref->type]);
1034 [ - + - - ]: 10607 : } else if ((entry->type == dma_debug_coherent) &&
1035 : : (phys_addr(ref) != phys_addr(entry))) {
1036 [ # # # # : 0 : err_printk(ref->dev, entry, "device driver frees "
# # # # #
# # # # #
# # ]
1037 : : "DMA memory with different CPU address "
1038 : : "[device address=0x%016llx] [size=%llu bytes] "
1039 : : "[cpu alloc address=0x%016llx] "
1040 : : "[cpu free address=0x%016llx]",
1041 : : ref->dev_addr, ref->size,
1042 : : phys_addr(entry),
1043 : 10607 : phys_addr(ref));
1044 : : }
1045 : :
1046 [ + - + - ]: 10607 : if (ref->sg_call_ents && ref->type == dma_debug_sg &&
1047 [ - + ]: 10607 : ref->sg_call_ents != entry->sg_call_ents) {
1048 [ # # # # : 0 : err_printk(ref->dev, entry, "device driver frees "
# # # # #
# # # #
# ]
1049 : : "DMA sg list with different entry count "
1050 : : "[map count=%d] [unmap count=%d]\n",
1051 : 10607 : entry->sg_call_ents, ref->sg_call_ents);
1052 : : }
1053 : :
1054 : : /*
1055 : : * This may be no bug in reality - but most implementations of the
1056 : : * DMA API don't handle this properly, so check for it here
1057 : : */
1058 [ - + ]: 10607 : if (ref->direction != entry->direction) {
1059 [ # # # # : 0 : err_printk(ref->dev, entry, "device driver frees "
# # # # #
# # # #
# ]
1060 : : "DMA memory with different direction "
1061 : : "[device address=0x%016llx] [size=%llu bytes] "
1062 : : "[mapped with %s] [unmapped with %s]\n",
1063 : : ref->dev_addr, ref->size,
1064 : : dir2name[entry->direction],
1065 : 10607 : dir2name[ref->direction]);
1066 : : }
1067 : :
1068 : : /*
1069 : : * Drivers should use dma_mapping_error() to check the returned
1070 : : * addresses of dma_map_single() and dma_map_page().
1071 : : * If not, print this warning message. See Documentation/DMA-API.txt.
1072 : : */
1073 [ - + ]: 10607 : if (entry->map_err_type == MAP_ERR_NOT_CHECKED) {
1074 [ # # # # : 0 : err_printk(ref->dev, entry,
# # # # #
# # # #
# ]
1075 : : "device driver failed to check map error"
1076 : : "[device address=0x%016llx] [size=%llu bytes] "
1077 : : "[mapped as %s]",
1078 : : ref->dev_addr, ref->size,
1079 : 10607 : type2name[entry->type]);
1080 : : }
1081 : :
1082 : 10607 : hash_bucket_del(entry);
1083 : 10607 : dma_entry_free(entry);
1084 : :
1085 : 10607 : put_hash_bucket(bucket, flags);
1086 : : }
1087 : :
1088 : 10802 : static void check_for_stack(struct device *dev,
1089 : : struct page *page, size_t offset)
1090 : : {
1091 : 10802 : void *addr;
1092 [ + + ]: 10802 : struct vm_struct *stack_vm_area = task_stack_vm_area(current);
1093 : :
1094 : 10802 : if (!stack_vm_area) {
1095 : : /* Stack is direct-mapped. */
1096 [ + + ]: 10802 : if (PageHighMem(page))
1097 : : return;
1098 [ + + ]: 10802 : addr = page_address(page) + offset;
1099 [ + + ]: 10802 : if (object_is_on_stack(addr))
1100 [ # # # # : 0 : err_printk(dev, NULL, "device driver maps memory from stack [addr=%p]\n", addr);
# # # # #
# # # #
# ]
1101 : : } else {
1102 : : /* Stack is vmalloced. */
1103 : : int i;
1104 : :
1105 : : for (i = 0; i < stack_vm_area->nr_pages; i++) {
1106 : : if (page != stack_vm_area->pages[i])
1107 : : continue;
1108 : :
1109 : : addr = (u8 *)current->stack + i * PAGE_SIZE + offset;
1110 : : err_printk(dev, NULL, "device driver maps memory from stack [probable addr=%p]\n", addr);
1111 : : break;
1112 : : }
1113 : : }
1114 : : }
1115 : :
1116 : 21604 : static inline bool overlap(void *addr, unsigned long len, void *start, void *end)
1117 : : {
1118 : 21604 : unsigned long a1 = (unsigned long)addr;
1119 : 21604 : unsigned long b1 = a1 + len;
1120 : 21604 : unsigned long a2 = (unsigned long)start;
1121 : 21604 : unsigned long b2 = (unsigned long)end;
1122 : :
1123 : 21604 : return !(b1 <= a2 || a1 >= b2);
1124 : : }
1125 : :
1126 : 10802 : static void check_for_illegal_area(struct device *dev, void *addr, unsigned long len)
1127 : : {
1128 [ + - - + ]: 10802 : if (overlap(addr, len, _stext, _etext) ||
1129 : : overlap(addr, len, __start_rodata, __end_rodata))
1130 [ # # # # : 0 : err_printk(dev, NULL, "device driver maps memory from kernel text or rodata [addr=%p] [len=%lu]\n", addr, len);
# # # # #
# # # #
# ]
1131 : 10802 : }
1132 : :
1133 : 0 : static void check_sync(struct device *dev,
1134 : : struct dma_debug_entry *ref,
1135 : : bool to_cpu)
1136 : : {
1137 : 0 : struct dma_debug_entry *entry;
1138 : 0 : struct hash_bucket *bucket;
1139 : 0 : unsigned long flags;
1140 : :
1141 : 0 : bucket = get_hash_bucket(ref, &flags);
1142 : :
1143 : 0 : entry = bucket_find_contain(&bucket, ref, &flags);
1144 : :
1145 [ # # ]: 0 : if (!entry) {
1146 [ # # # # : 0 : err_printk(dev, NULL, "device driver tries "
# # # # #
# # # #
# ]
1147 : : "to sync DMA memory it has not allocated "
1148 : : "[device address=0x%016llx] [size=%llu bytes]\n",
1149 : 0 : (unsigned long long)ref->dev_addr, ref->size);
1150 : 0 : goto out;
1151 : : }
1152 : :
1153 [ # # ]: 0 : if (ref->size > entry->size) {
1154 [ # # # # : 0 : err_printk(dev, entry, "device driver syncs"
# # # # #
# # # #
# ]
1155 : : " DMA memory outside allocated range "
1156 : : "[device address=0x%016llx] "
1157 : : "[allocation size=%llu bytes] "
1158 : : "[sync offset+size=%llu]\n",
1159 : : entry->dev_addr, entry->size,
1160 : 0 : ref->size);
1161 : : }
1162 : :
1163 [ # # ]: 0 : if (entry->direction == DMA_BIDIRECTIONAL)
1164 : 0 : goto out;
1165 : :
1166 [ # # ]: 0 : if (ref->direction != entry->direction) {
1167 [ # # # # : 0 : err_printk(dev, entry, "device driver syncs "
# # # # #
# # # #
# ]
1168 : : "DMA memory with different direction "
1169 : : "[device address=0x%016llx] [size=%llu bytes] "
1170 : : "[mapped with %s] [synced with %s]\n",
1171 : : (unsigned long long)ref->dev_addr, entry->size,
1172 : : dir2name[entry->direction],
1173 : 0 : dir2name[ref->direction]);
1174 : : }
1175 : :
1176 [ # # # # ]: 0 : if (to_cpu && !(entry->direction == DMA_FROM_DEVICE) &&
1177 [ # # ]: 0 : !(ref->direction == DMA_TO_DEVICE))
1178 [ # # # # : 0 : err_printk(dev, entry, "device driver syncs "
# # # # #
# # # #
# ]
1179 : : "device read-only DMA memory for cpu "
1180 : : "[device address=0x%016llx] [size=%llu bytes] "
1181 : : "[mapped with %s] [synced with %s]\n",
1182 : : (unsigned long long)ref->dev_addr, entry->size,
1183 : : dir2name[entry->direction],
1184 : 0 : dir2name[ref->direction]);
1185 : :
1186 [ # # # # ]: 0 : if (!to_cpu && !(entry->direction == DMA_TO_DEVICE) &&
1187 [ # # ]: 0 : !(ref->direction == DMA_FROM_DEVICE))
1188 [ # # # # : 0 : err_printk(dev, entry, "device driver syncs "
# # # # #
# # # #
# ]
1189 : : "device write-only DMA memory to device "
1190 : : "[device address=0x%016llx] [size=%llu bytes] "
1191 : : "[mapped with %s] [synced with %s]\n",
1192 : : (unsigned long long)ref->dev_addr, entry->size,
1193 : : dir2name[entry->direction],
1194 : 0 : dir2name[ref->direction]);
1195 : :
1196 [ # # # # ]: 0 : if (ref->sg_call_ents && ref->type == dma_debug_sg &&
1197 [ # # ]: 0 : ref->sg_call_ents != entry->sg_call_ents) {
1198 [ # # # # : 0 : err_printk(ref->dev, entry, "device driver syncs "
# # # # #
# # # #
# ]
1199 : : "DMA sg list with different entry count "
1200 : : "[map count=%d] [sync count=%d]\n",
1201 : 0 : entry->sg_call_ents, ref->sg_call_ents);
1202 : : }
1203 : :
1204 : 0 : out:
1205 : 0 : put_hash_bucket(bucket, flags);
1206 : 0 : }
1207 : :
1208 : 10607 : static void check_sg_segment(struct device *dev, struct scatterlist *sg)
1209 : : {
1210 : : #ifdef CONFIG_DMA_API_DEBUG_SG
1211 [ + - ]: 10607 : unsigned int max_seg = dma_get_max_seg_size(dev);
1212 [ + - ]: 10607 : u64 start, end, boundary = dma_get_seg_boundary(dev);
1213 : :
1214 : : /*
1215 : : * Either the driver forgot to set dma_parms appropriately, or
1216 : : * whoever generated the list forgot to check them.
1217 : : */
1218 [ - + ]: 10607 : if (sg->length > max_seg)
1219 [ # # # # : 0 : err_printk(dev, NULL, "mapping sg segment longer than device claims to support [len=%u] [max=%u]\n",
# # # # #
# # # #
# ]
1220 : 10607 : sg->length, max_seg);
1221 : : /*
1222 : : * In some cases this could potentially be the DMA API
1223 : : * implementation's fault, but it would usually imply that
1224 : : * the scatterlist was built inappropriately to begin with.
1225 : : */
1226 : 10607 : start = sg_dma_address(sg);
1227 : 10607 : end = start + sg_dma_len(sg) - 1;
1228 [ - + ]: 10607 : if ((start ^ end) & ~boundary)
1229 [ # # # # : 0 : err_printk(dev, NULL, "mapping sg segment across boundary [start=0x%016llx] [end=0x%016llx] [boundary=0x%016llx]\n",
# # # # #
# # # #
# ]
1230 : 10607 : start, end, boundary);
1231 : : #endif
1232 : 10607 : }
1233 : :
1234 : 195 : void debug_dma_map_single(struct device *dev, const void *addr,
1235 : : unsigned long len)
1236 : : {
1237 [ + - + - ]: 390 : if (unlikely(dma_debug_disabled()))
1238 : : return;
1239 : :
1240 [ - + ]: 195 : if (!virt_addr_valid(addr))
1241 [ # # # # : 0 : err_printk(dev, NULL, "device driver maps memory from invalid area [addr=%p] [len=%lu]\n",
# # # # #
# # # #
# ]
1242 : 195 : addr, len);
1243 : :
1244 [ - + ]: 195 : if (is_vmalloc_addr(addr))
1245 [ # # # # : 0 : err_printk(dev, NULL, "device driver maps memory from vmalloc area [addr=%p] [len=%lu]\n",
# # # # #
# # # #
# ]
1246 : 195 : addr, len);
1247 : : }
1248 : : EXPORT_SYMBOL(debug_dma_map_single);
1249 : :
1250 : 195 : void debug_dma_map_page(struct device *dev, struct page *page, size_t offset,
1251 : : size_t size, int direction, dma_addr_t dma_addr)
1252 : : {
1253 : 195 : struct dma_debug_entry *entry;
1254 : :
1255 [ + - + - ]: 390 : if (unlikely(dma_debug_disabled()))
1256 : : return;
1257 : :
1258 : 195 : if (dma_mapping_error(dev, dma_addr))
1259 : : return;
1260 : :
1261 : 195 : entry = dma_entry_alloc();
1262 [ + - ]: 195 : if (!entry)
1263 : : return;
1264 : :
1265 : 195 : entry->dev = dev;
1266 : 195 : entry->type = dma_debug_single;
1267 : 195 : entry->pfn = page_to_pfn(page);
1268 : 195 : entry->offset = offset,
1269 : 195 : entry->dev_addr = dma_addr;
1270 : 195 : entry->size = size;
1271 : 195 : entry->direction = direction;
1272 : 195 : entry->map_err_type = MAP_ERR_NOT_CHECKED;
1273 : :
1274 : 195 : check_for_stack(dev, page, offset);
1275 : :
1276 : 195 : if (!PageHighMem(page)) {
1277 : 195 : void *addr = page_address(page) + offset;
1278 : :
1279 : 195 : check_for_illegal_area(dev, addr, size);
1280 : : }
1281 : :
1282 : 195 : add_dma_entry(entry);
1283 : : }
1284 : : EXPORT_SYMBOL(debug_dma_map_page);
1285 : :
1286 : 390 : void debug_dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
1287 : : {
1288 : 390 : struct dma_debug_entry ref;
1289 : 390 : struct dma_debug_entry *entry;
1290 : 390 : struct hash_bucket *bucket;
1291 : 390 : unsigned long flags;
1292 : :
1293 [ + - + - ]: 780 : if (unlikely(dma_debug_disabled()))
1294 : : return;
1295 : :
1296 : 390 : ref.dev = dev;
1297 : 390 : ref.dev_addr = dma_addr;
1298 : 390 : bucket = get_hash_bucket(&ref, &flags);
1299 : :
1300 [ + + ]: 1002 : list_for_each_entry(entry, &bucket->list, list) {
1301 [ + + + + ]: 1614 : if (!exact_match(&ref, entry))
1302 : 612 : continue;
1303 : :
1304 : : /*
1305 : : * The same physical address can be mapped multiple
1306 : : * times. Without a hardware IOMMU this results in the
1307 : : * same device addresses being put into the dma-debug
1308 : : * hash multiple times too. This can result in false
1309 : : * positives being reported. Therefore we implement a
1310 : : * best-fit algorithm here which updates the first entry
1311 : : * from the hash which fits the reference value and is
1312 : : * not currently listed as being checked.
1313 : : */
1314 [ + - ]: 195 : if (entry->map_err_type == MAP_ERR_NOT_CHECKED) {
1315 : 195 : entry->map_err_type = MAP_ERR_CHECKED;
1316 : 195 : break;
1317 : : }
1318 : : }
1319 : :
1320 : 390 : put_hash_bucket(bucket, flags);
1321 : : }
1322 : : EXPORT_SYMBOL(debug_dma_mapping_error);
1323 : :
1324 : 0 : void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
1325 : : size_t size, int direction)
1326 : : {
1327 : 0 : struct dma_debug_entry ref = {
1328 : : .type = dma_debug_single,
1329 : : .dev = dev,
1330 : : .dev_addr = addr,
1331 : : .size = size,
1332 : : .direction = direction,
1333 : : };
1334 : :
1335 [ # # # # ]: 0 : if (unlikely(dma_debug_disabled()))
1336 : 0 : return;
1337 : 0 : check_unmap(&ref);
1338 : : }
1339 : : EXPORT_SYMBOL(debug_dma_unmap_page);
1340 : :
1341 : 2929 : void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
1342 : : int nents, int mapped_ents, int direction)
1343 : : {
1344 : 2929 : struct dma_debug_entry *entry;
1345 : 2929 : struct scatterlist *s;
1346 : 2929 : int i;
1347 : :
1348 [ + - + - ]: 5858 : if (unlikely(dma_debug_disabled()))
1349 : : return;
1350 : :
1351 [ + + ]: 13536 : for_each_sg(sg, s, mapped_ents, i) {
1352 : 10607 : entry = dma_entry_alloc();
1353 [ + - ]: 10607 : if (!entry)
1354 : : return;
1355 : :
1356 : 10607 : entry->type = dma_debug_sg;
1357 : 10607 : entry->dev = dev;
1358 : 10607 : entry->pfn = page_to_pfn(sg_page(s));
1359 : 10607 : entry->offset = s->offset,
1360 : 10607 : entry->size = sg_dma_len(s);
1361 : 10607 : entry->dev_addr = sg_dma_address(s);
1362 : 10607 : entry->direction = direction;
1363 : 10607 : entry->sg_call_ents = nents;
1364 : 10607 : entry->sg_mapped_ents = mapped_ents;
1365 : :
1366 : 10607 : check_for_stack(dev, sg_page(s), s->offset);
1367 : :
1368 : 10607 : if (!PageHighMem(sg_page(s))) {
1369 : 10607 : check_for_illegal_area(dev, sg_virt(s), sg_dma_len(s));
1370 : : }
1371 : :
1372 : 10607 : check_sg_segment(dev, s);
1373 : :
1374 : 10607 : add_dma_entry(entry);
1375 : : }
1376 : : }
1377 : : EXPORT_SYMBOL(debug_dma_map_sg);
1378 : :
1379 : : static int get_nr_mapped_entries(struct device *dev,
1380 : : struct dma_debug_entry *ref)
1381 : : {
1382 : : struct dma_debug_entry *entry;
1383 : : struct hash_bucket *bucket;
1384 : : unsigned long flags;
1385 : : int mapped_ents;
1386 : :
1387 : : bucket = get_hash_bucket(ref, &flags);
1388 : : entry = bucket_find_exact(bucket, ref);
1389 : : mapped_ents = 0;
1390 : :
1391 : : if (entry)
1392 : : mapped_ents = entry->sg_mapped_ents;
1393 : : put_hash_bucket(bucket, flags);
1394 : :
1395 : : return mapped_ents;
1396 : : }
1397 : :
1398 : 2929 : void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
1399 : : int nelems, int dir)
1400 : : {
1401 : 2929 : struct scatterlist *s;
1402 : 2929 : int mapped_ents = 0, i;
1403 : :
1404 [ + - + - ]: 5858 : if (unlikely(dma_debug_disabled()))
1405 : : return;
1406 : :
1407 [ + + ]: 13536 : for_each_sg(sglist, s, nelems, i) {
1408 : :
1409 : 10607 : struct dma_debug_entry ref = {
1410 : : .type = dma_debug_sg,
1411 : : .dev = dev,
1412 : 10607 : .pfn = page_to_pfn(sg_page(s)),
1413 : 10607 : .offset = s->offset,
1414 : 10607 : .dev_addr = sg_dma_address(s),
1415 [ + - ]: 10607 : .size = sg_dma_len(s),
1416 : : .direction = dir,
1417 : : .sg_call_ents = nelems,
1418 : : };
1419 : :
1420 [ + - ]: 10607 : if (mapped_ents && i >= mapped_ents)
1421 : : break;
1422 : :
1423 [ + + ]: 10607 : if (!i)
1424 : 2929 : mapped_ents = get_nr_mapped_entries(dev, &ref);
1425 : :
1426 : 10607 : check_unmap(&ref);
1427 : : }
1428 : : }
1429 : : EXPORT_SYMBOL(debug_dma_unmap_sg);
1430 : :
1431 : 9 : void debug_dma_alloc_coherent(struct device *dev, size_t size,
1432 : : dma_addr_t dma_addr, void *virt)
1433 : : {
1434 : 9 : struct dma_debug_entry *entry;
1435 : :
1436 [ + - + - ]: 18 : if (unlikely(dma_debug_disabled()))
1437 : : return;
1438 : :
1439 [ + - ]: 9 : if (unlikely(virt == NULL))
1440 : : return;
1441 : :
1442 : : /* handle vmalloc and linear addresses */
1443 [ + - + - ]: 9 : if (!is_vmalloc_addr(virt) && !virt_addr_valid(virt))
1444 : : return;
1445 : :
1446 : 9 : entry = dma_entry_alloc();
1447 [ + - ]: 9 : if (!entry)
1448 : : return;
1449 : :
1450 : 9 : entry->type = dma_debug_coherent;
1451 : 9 : entry->dev = dev;
1452 : 9 : entry->offset = offset_in_page(virt);
1453 : 9 : entry->size = size;
1454 : 9 : entry->dev_addr = dma_addr;
1455 : 9 : entry->direction = DMA_BIDIRECTIONAL;
1456 : :
1457 [ - + ]: 9 : if (is_vmalloc_addr(virt))
1458 : 0 : entry->pfn = vmalloc_to_pfn(virt);
1459 : : else
1460 [ + - ]: 18 : entry->pfn = page_to_pfn(virt_to_page(virt));
1461 : :
1462 : 9 : add_dma_entry(entry);
1463 : : }
1464 : :
1465 : 0 : void debug_dma_free_coherent(struct device *dev, size_t size,
1466 : : void *virt, dma_addr_t addr)
1467 : : {
1468 : 0 : struct dma_debug_entry ref = {
1469 : : .type = dma_debug_coherent,
1470 : : .dev = dev,
1471 : 0 : .offset = offset_in_page(virt),
1472 : : .dev_addr = addr,
1473 : : .size = size,
1474 : : .direction = DMA_BIDIRECTIONAL,
1475 : : };
1476 : :
1477 : : /* handle vmalloc and linear addresses */
1478 [ # # # # ]: 0 : if (!is_vmalloc_addr(virt) && !virt_addr_valid(virt))
1479 : 0 : return;
1480 : :
1481 [ # # ]: 0 : if (is_vmalloc_addr(virt))
1482 : 0 : ref.pfn = vmalloc_to_pfn(virt);
1483 : : else
1484 [ # # ]: 0 : ref.pfn = page_to_pfn(virt_to_page(virt));
1485 : :
1486 [ # # # # ]: 0 : if (unlikely(dma_debug_disabled()))
1487 : : return;
1488 : :
1489 : 0 : check_unmap(&ref);
1490 : : }
1491 : :
1492 : 0 : void debug_dma_map_resource(struct device *dev, phys_addr_t addr, size_t size,
1493 : : int direction, dma_addr_t dma_addr)
1494 : : {
1495 : 0 : struct dma_debug_entry *entry;
1496 : :
1497 [ # # # # ]: 0 : if (unlikely(dma_debug_disabled()))
1498 : : return;
1499 : :
1500 : 0 : entry = dma_entry_alloc();
1501 [ # # ]: 0 : if (!entry)
1502 : : return;
1503 : :
1504 : 0 : entry->type = dma_debug_resource;
1505 : 0 : entry->dev = dev;
1506 : 0 : entry->pfn = PHYS_PFN(addr);
1507 : 0 : entry->offset = offset_in_page(addr);
1508 : 0 : entry->size = size;
1509 : 0 : entry->dev_addr = dma_addr;
1510 : 0 : entry->direction = direction;
1511 : 0 : entry->map_err_type = MAP_ERR_NOT_CHECKED;
1512 : :
1513 : 0 : add_dma_entry(entry);
1514 : : }
1515 : : EXPORT_SYMBOL(debug_dma_map_resource);
1516 : :
1517 : 0 : void debug_dma_unmap_resource(struct device *dev, dma_addr_t dma_addr,
1518 : : size_t size, int direction)
1519 : : {
1520 : 0 : struct dma_debug_entry ref = {
1521 : : .type = dma_debug_resource,
1522 : : .dev = dev,
1523 : : .dev_addr = dma_addr,
1524 : : .size = size,
1525 : : .direction = direction,
1526 : : };
1527 : :
1528 [ # # # # ]: 0 : if (unlikely(dma_debug_disabled()))
1529 : 0 : return;
1530 : :
1531 : 0 : check_unmap(&ref);
1532 : : }
1533 : : EXPORT_SYMBOL(debug_dma_unmap_resource);
1534 : :
1535 : 0 : void debug_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
1536 : : size_t size, int direction)
1537 : : {
1538 : 0 : struct dma_debug_entry ref;
1539 : :
1540 [ # # # # ]: 0 : if (unlikely(dma_debug_disabled()))
1541 : 0 : return;
1542 : :
1543 : 0 : ref.type = dma_debug_single;
1544 : 0 : ref.dev = dev;
1545 : 0 : ref.dev_addr = dma_handle;
1546 : 0 : ref.size = size;
1547 : 0 : ref.direction = direction;
1548 : 0 : ref.sg_call_ents = 0;
1549 : :
1550 : 0 : check_sync(dev, &ref, true);
1551 : : }
1552 : : EXPORT_SYMBOL(debug_dma_sync_single_for_cpu);
1553 : :
1554 : 0 : void debug_dma_sync_single_for_device(struct device *dev,
1555 : : dma_addr_t dma_handle, size_t size,
1556 : : int direction)
1557 : : {
1558 : 0 : struct dma_debug_entry ref;
1559 : :
1560 [ # # # # ]: 0 : if (unlikely(dma_debug_disabled()))
1561 : 0 : return;
1562 : :
1563 : 0 : ref.type = dma_debug_single;
1564 : 0 : ref.dev = dev;
1565 : 0 : ref.dev_addr = dma_handle;
1566 : 0 : ref.size = size;
1567 : 0 : ref.direction = direction;
1568 : 0 : ref.sg_call_ents = 0;
1569 : :
1570 : 0 : check_sync(dev, &ref, false);
1571 : : }
1572 : : EXPORT_SYMBOL(debug_dma_sync_single_for_device);
1573 : :
1574 : 0 : void debug_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
1575 : : int nelems, int direction)
1576 : : {
1577 : 0 : struct scatterlist *s;
1578 : 0 : int mapped_ents = 0, i;
1579 : :
1580 [ # # # # ]: 0 : if (unlikely(dma_debug_disabled()))
1581 : : return;
1582 : :
1583 [ # # ]: 0 : for_each_sg(sg, s, nelems, i) {
1584 : :
1585 : 0 : struct dma_debug_entry ref = {
1586 : : .type = dma_debug_sg,
1587 : : .dev = dev,
1588 : 0 : .pfn = page_to_pfn(sg_page(s)),
1589 : 0 : .offset = s->offset,
1590 : 0 : .dev_addr = sg_dma_address(s),
1591 [ # # ]: 0 : .size = sg_dma_len(s),
1592 : : .direction = direction,
1593 : : .sg_call_ents = nelems,
1594 : : };
1595 : :
1596 [ # # ]: 0 : if (!i)
1597 : 0 : mapped_ents = get_nr_mapped_entries(dev, &ref);
1598 : :
1599 [ # # ]: 0 : if (i >= mapped_ents)
1600 : : break;
1601 : :
1602 : 0 : check_sync(dev, &ref, true);
1603 : : }
1604 : : }
1605 : : EXPORT_SYMBOL(debug_dma_sync_sg_for_cpu);
1606 : :
1607 : 0 : void debug_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
1608 : : int nelems, int direction)
1609 : : {
1610 : 0 : struct scatterlist *s;
1611 : 0 : int mapped_ents = 0, i;
1612 : :
1613 [ # # # # ]: 0 : if (unlikely(dma_debug_disabled()))
1614 : : return;
1615 : :
1616 [ # # ]: 0 : for_each_sg(sg, s, nelems, i) {
1617 : :
1618 : 0 : struct dma_debug_entry ref = {
1619 : : .type = dma_debug_sg,
1620 : : .dev = dev,
1621 : 0 : .pfn = page_to_pfn(sg_page(s)),
1622 : 0 : .offset = s->offset,
1623 : 0 : .dev_addr = sg_dma_address(s),
1624 [ # # ]: 0 : .size = sg_dma_len(s),
1625 : : .direction = direction,
1626 : : .sg_call_ents = nelems,
1627 : : };
1628 [ # # ]: 0 : if (!i)
1629 : 0 : mapped_ents = get_nr_mapped_entries(dev, &ref);
1630 : :
1631 [ # # ]: 0 : if (i >= mapped_ents)
1632 : : break;
1633 : :
1634 : 0 : check_sync(dev, &ref, false);
1635 : : }
1636 : : }
1637 : : EXPORT_SYMBOL(debug_dma_sync_sg_for_device);
1638 : :
1639 : 0 : static int __init dma_debug_driver_setup(char *str)
1640 : : {
1641 : 0 : int i;
1642 : :
1643 [ # # ]: 0 : for (i = 0; i < NAME_MAX_LEN - 1; ++i, ++str) {
1644 : 0 : current_driver_name[i] = *str;
1645 [ # # ]: 0 : if (*str == 0)
1646 : : break;
1647 : : }
1648 : :
1649 [ # # ]: 0 : if (current_driver_name[0])
1650 : 0 : pr_info("enable driver filter for driver [%s]\n",
1651 : : current_driver_name);
1652 : :
1653 : :
1654 : 0 : return 1;
1655 : : }
1656 : : __setup("dma_debug_driver=", dma_debug_driver_setup);
|
