dma-debug: add allocator code
[linux-3.10.git] / lib / dma-debug.c
1 /*
2  * Copyright (C) 2008 Advanced Micro Devices, Inc.
3  *
4  * Author: Joerg Roedel <joerg.roedel@amd.com>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License version 2 as published
8  * by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
18  */
19
20 #include <linux/dma-debug.h>
21 #include <linux/spinlock.h>
22 #include <linux/types.h>
23 #include <linux/list.h>
24
25 #define HASH_SIZE       1024ULL
26 #define HASH_FN_SHIFT   13
27 #define HASH_FN_MASK    (HASH_SIZE - 1)
28
29 enum {
30         dma_debug_single,
31         dma_debug_page,
32         dma_debug_sg,
33         dma_debug_coherent,
34 };
35
36 struct dma_debug_entry {
37         struct list_head list;
38         struct device    *dev;
39         int              type;
40         phys_addr_t      paddr;
41         u64              dev_addr;
42         u64              size;
43         int              direction;
44         int              sg_call_ents;
45         int              sg_mapped_ents;
46 };
47
48 struct hash_bucket {
49         struct list_head list;
50         spinlock_t lock;
51 } __cacheline_aligned_in_smp;
52
53 /* Hash list to save the allocated dma addresses */
54 static struct hash_bucket dma_entry_hash[HASH_SIZE];
55 /* List of pre-allocated dma_debug_entry's */
56 static LIST_HEAD(free_entries);
57 /* Lock for the list above */
58 static DEFINE_SPINLOCK(free_entries_lock);
59
60 /* Global disable flag - will be set in case of an error */
61 static bool global_disable __read_mostly;
62
63 static u32 num_free_entries;
64 static u32 min_free_entries;
65
66 /*
67  * Hash related functions
68  *
69  * Every DMA-API request is saved into a struct dma_debug_entry. To
70  * have quick access to these structs they are stored into a hash.
71  */
72 static int hash_fn(struct dma_debug_entry *entry)
73 {
74         /*
75          * Hash function is based on the dma address.
76          * We use bits 20-27 here as the index into the hash
77          */
78         return (entry->dev_addr >> HASH_FN_SHIFT) & HASH_FN_MASK;
79 }
80
81 /*
82  * Request exclusive access to a hash bucket for a given dma_debug_entry.
83  */
84 static struct hash_bucket *get_hash_bucket(struct dma_debug_entry *entry,
85                                            unsigned long *flags)
86 {
87         int idx = hash_fn(entry);
88         unsigned long __flags;
89
90         spin_lock_irqsave(&dma_entry_hash[idx].lock, __flags);
91         *flags = __flags;
92         return &dma_entry_hash[idx];
93 }
94
95 /*
96  * Give up exclusive access to the hash bucket
97  */
98 static void put_hash_bucket(struct hash_bucket *bucket,
99                             unsigned long *flags)
100 {
101         unsigned long __flags = *flags;
102
103         spin_unlock_irqrestore(&bucket->lock, __flags);
104 }
105
106 /*
107  * Search a given entry in the hash bucket list
108  */
109 static struct dma_debug_entry *hash_bucket_find(struct hash_bucket *bucket,
110                                                 struct dma_debug_entry *ref)
111 {
112         struct dma_debug_entry *entry;
113
114         list_for_each_entry(entry, &bucket->list, list) {
115                 if ((entry->dev_addr == ref->dev_addr) &&
116                     (entry->dev == ref->dev))
117                         return entry;
118         }
119
120         return NULL;
121 }
122
123 /*
124  * Add an entry to a hash bucket
125  */
126 static void hash_bucket_add(struct hash_bucket *bucket,
127                             struct dma_debug_entry *entry)
128 {
129         list_add_tail(&entry->list, &bucket->list);
130 }
131
132 /*
133  * Remove entry from a hash bucket list
134  */
135 static void hash_bucket_del(struct dma_debug_entry *entry)
136 {
137         list_del(&entry->list);
138 }
139
140 /*
141  * Wrapper function for adding an entry to the hash.
142  * This function takes care of locking itself.
143  */
144 static void add_dma_entry(struct dma_debug_entry *entry)
145 {
146         struct hash_bucket *bucket;
147         unsigned long flags;
148
149         bucket = get_hash_bucket(entry, &flags);
150         hash_bucket_add(bucket, entry);
151         put_hash_bucket(bucket, &flags);
152 }
153
154 /* struct dma_entry allocator
155  *
156  * The next two functions implement the allocator for
157  * struct dma_debug_entries.
158  */
159 static struct dma_debug_entry *dma_entry_alloc(void)
160 {
161         struct dma_debug_entry *entry = NULL;
162         unsigned long flags;
163
164         spin_lock_irqsave(&free_entries_lock, flags);
165
166         if (list_empty(&free_entries)) {
167                 printk(KERN_ERR "DMA-API: debugging out of memory "
168                                 "- disabling\n");
169                 global_disable = true;
170                 goto out;
171         }
172
173         entry = list_entry(free_entries.next, struct dma_debug_entry, list);
174         list_del(&entry->list);
175         memset(entry, 0, sizeof(*entry));
176
177         num_free_entries -= 1;
178         if (num_free_entries < min_free_entries)
179                 min_free_entries = num_free_entries;
180
181 out:
182         spin_unlock_irqrestore(&free_entries_lock, flags);
183
184         return entry;
185 }
186
187 static void dma_entry_free(struct dma_debug_entry *entry)
188 {
189         unsigned long flags;
190
191         /*
192          * add to beginning of the list - this way the entries are
193          * more likely cache hot when they are reallocated.
194          */
195         spin_lock_irqsave(&free_entries_lock, flags);
196         list_add(&entry->list, &free_entries);
197         num_free_entries += 1;
198         spin_unlock_irqrestore(&free_entries_lock, flags);
199 }
200