Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /** |
f0c408b5 | 2 | * \file drm_memory_debug.h |
1da177e4 LT |
3 | * Memory management wrappers for DRM. |
4 | * | |
5 | * \author Rickard E. (Rik) Faith <faith@valinux.com> | |
6 | * \author Gareth Hughes <gareth@valinux.com> | |
7 | */ | |
8 | ||
9 | /* | |
10 | * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. | |
11 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. | |
12 | * All Rights Reserved. | |
13 | * | |
14 | * Permission is hereby granted, free of charge, to any person obtaining a | |
15 | * copy of this software and associated documentation files (the "Software"), | |
16 | * to deal in the Software without restriction, including without limitation | |
17 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
18 | * and/or sell copies of the Software, and to permit persons to whom the | |
19 | * Software is furnished to do so, subject to the following conditions: | |
20 | * | |
21 | * The above copyright notice and this permission notice (including the next | |
22 | * paragraph) shall be included in all copies or substantial portions of the | |
23 | * Software. | |
24 | * | |
25 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
26 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
27 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
28 | * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
29 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
30 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |
31 | * OTHER DEALINGS IN THE SOFTWARE. | |
32 | */ | |
33 | ||
34 | #include <linux/config.h> | |
35 | #include "drmP.h" | |
36 | ||
37 | typedef struct drm_mem_stats { | |
b5e89ed5 DA |
38 | const char *name; |
39 | int succeed_count; | |
40 | int free_count; | |
41 | int fail_count; | |
42 | unsigned long bytes_allocated; | |
43 | unsigned long bytes_freed; | |
1da177e4 LT |
44 | } drm_mem_stats_t; |
45 | ||
34af946a | 46 | static DEFINE_SPINLOCK(drm_mem_lock); |
f0c408b5 DA |
47 | static unsigned long drm_ram_available = 0; /* In pages */ |
48 | static unsigned long drm_ram_used = 0; | |
49 | static drm_mem_stats_t drm_mem_stats[] = | |
b5e89ed5 | 50 | { |
f0c408b5 DA |
51 | [DRM_MEM_DMA] = {"dmabufs"}, |
52 | [DRM_MEM_SAREA] = {"sareas"}, | |
53 | [DRM_MEM_DRIVER] = {"driver"}, | |
54 | [DRM_MEM_MAGIC] = {"magic"}, | |
55 | [DRM_MEM_IOCTLS] = {"ioctltab"}, | |
56 | [DRM_MEM_MAPS] = {"maplist"}, | |
57 | [DRM_MEM_VMAS] = {"vmalist"}, | |
58 | [DRM_MEM_BUFS] = {"buflist"}, | |
59 | [DRM_MEM_SEGS] = {"seglist"}, | |
60 | [DRM_MEM_PAGES] = {"pagelist"}, | |
61 | [DRM_MEM_FILES] = {"files"}, | |
62 | [DRM_MEM_QUEUES] = {"queues"}, | |
63 | [DRM_MEM_CMDS] = {"commands"}, | |
64 | [DRM_MEM_MAPPINGS] = {"mappings"}, | |
65 | [DRM_MEM_BUFLISTS] = {"buflists"}, | |
66 | [DRM_MEM_AGPLISTS] = {"agplist"}, | |
67 | [DRM_MEM_SGLISTS] = {"sglist"}, | |
68 | [DRM_MEM_TOTALAGP] = {"totalagp"}, | |
69 | [DRM_MEM_BOUNDAGP] = {"boundagp"}, | |
70 | [DRM_MEM_CTXBITMAP] = {"ctxbitmap"}, | |
71 | [DRM_MEM_CTXLIST] = {"ctxlist"}, | |
72 | [DRM_MEM_STUB] = {"stub"}, | |
73 | {NULL, 0,} /* Last entry must be null */ | |
1da177e4 LT |
74 | }; |
75 | ||
f0c408b5 | 76 | void drm_mem_init (void) { |
1da177e4 | 77 | drm_mem_stats_t *mem; |
b5e89ed5 | 78 | struct sysinfo si; |
1da177e4 | 79 | |
f0c408b5 | 80 | for (mem = drm_mem_stats; mem->name; ++mem) { |
b5e89ed5 DA |
81 | mem->succeed_count = 0; |
82 | mem->free_count = 0; | |
83 | mem->fail_count = 0; | |
1da177e4 | 84 | mem->bytes_allocated = 0; |
b5e89ed5 | 85 | mem->bytes_freed = 0; |
1da177e4 LT |
86 | } |
87 | ||
88 | si_meminfo(&si); | |
f0c408b5 DA |
89 | drm_ram_available = si.totalram; |
90 | drm_ram_used = 0; | |
1da177e4 LT |
91 | } |
92 | ||
93 | /* drm_mem_info is called whenever a process reads /dev/drm/mem. */ | |
94 | ||
f0c408b5 | 95 | static int drm__mem_info (char *buf, char **start, off_t offset, |
b5e89ed5 | 96 | int request, int *eof, void *data) { |
1da177e4 | 97 | drm_mem_stats_t *pt; |
b5e89ed5 | 98 | int len = 0; |
1da177e4 LT |
99 | |
100 | if (offset > DRM_PROC_LIMIT) { | |
101 | *eof = 1; | |
102 | return 0; | |
103 | } | |
104 | ||
b5e89ed5 | 105 | *eof = 0; |
1da177e4 LT |
106 | *start = &buf[offset]; |
107 | ||
108 | DRM_PROC_PRINT(" total counts " | |
109 | " | outstanding \n"); | |
110 | DRM_PROC_PRINT("type alloc freed fail bytes freed" | |
111 | " | allocs bytes\n\n"); | |
112 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB |\n", | |
113 | "system", 0, 0, 0, | |
f0c408b5 | 114 | drm_ram_available << (PAGE_SHIFT - 10)); |
1da177e4 | 115 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB |\n", |
f0c408b5 | 116 | "locked", 0, 0, 0, drm_ram_used >> 10); |
1da177e4 | 117 | DRM_PROC_PRINT("\n"); |
f0c408b5 | 118 | for (pt = drm_mem_stats; pt->name; pt++) { |
1da177e4 LT |
119 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu %10lu | %6d %10ld\n", |
120 | pt->name, | |
121 | pt->succeed_count, | |
122 | pt->free_count, | |
123 | pt->fail_count, | |
124 | pt->bytes_allocated, | |
125 | pt->bytes_freed, | |
126 | pt->succeed_count - pt->free_count, | |
127 | (long)pt->bytes_allocated | |
128 | - (long)pt->bytes_freed); | |
129 | } | |
130 | ||
b5e89ed5 DA |
131 | if (len > request + offset) |
132 | return request; | |
1da177e4 LT |
133 | *eof = 1; |
134 | return len - offset; | |
135 | } | |
136 | ||
f0c408b5 | 137 | int drm_mem_info (char *buf, char **start, off_t offset, |
b5e89ed5 | 138 | int len, int *eof, void *data) { |
1da177e4 LT |
139 | int ret; |
140 | ||
f0c408b5 DA |
141 | spin_lock(&drm_mem_lock); |
142 | ret = drm__mem_info (buf, start, offset, len, eof, data); | |
143 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
144 | return ret; |
145 | } | |
146 | ||
f0c408b5 | 147 | void *drm_alloc (size_t size, int area) { |
1da177e4 LT |
148 | void *pt; |
149 | ||
150 | if (!size) { | |
151 | DRM_MEM_ERROR(area, "Allocating 0 bytes\n"); | |
152 | return NULL; | |
153 | } | |
154 | ||
155 | if (!(pt = kmalloc(size, GFP_KERNEL))) { | |
f0c408b5 DA |
156 | spin_lock(&drm_mem_lock); |
157 | ++drm_mem_stats[area].fail_count; | |
158 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
159 | return NULL; |
160 | } | |
f0c408b5 DA |
161 | spin_lock(&drm_mem_lock); |
162 | ++drm_mem_stats[area].succeed_count; | |
163 | drm_mem_stats[area].bytes_allocated += size; | |
164 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
165 | return pt; |
166 | } | |
167 | ||
f0c408b5 | 168 | void *drm_calloc (size_t nmemb, size_t size, int area) { |
1da177e4 LT |
169 | void *addr; |
170 | ||
f0c408b5 | 171 | addr = drm_alloc (nmemb * size, area); |
1da177e4 LT |
172 | if (addr != NULL) |
173 | memset((void *)addr, 0, size * nmemb); | |
174 | ||
175 | return addr; | |
176 | } | |
177 | ||
f0c408b5 | 178 | void *drm_realloc (void *oldpt, size_t oldsize, size_t size, int area) { |
1da177e4 LT |
179 | void *pt; |
180 | ||
f0c408b5 | 181 | if (!(pt = drm_alloc (size, area))) |
b5e89ed5 | 182 | return NULL; |
1da177e4 LT |
183 | if (oldpt && oldsize) { |
184 | memcpy(pt, oldpt, oldsize); | |
f0c408b5 | 185 | drm_free (oldpt, oldsize, area); |
1da177e4 LT |
186 | } |
187 | return pt; | |
188 | } | |
189 | ||
f0c408b5 | 190 | void drm_free (void *pt, size_t size, int area) { |
1da177e4 LT |
191 | int alloc_count; |
192 | int free_count; | |
193 | ||
b5e89ed5 DA |
194 | if (!pt) |
195 | DRM_MEM_ERROR(area, "Attempt to free NULL pointer\n"); | |
196 | else | |
197 | kfree(pt); | |
f0c408b5 DA |
198 | spin_lock(&drm_mem_lock); |
199 | drm_mem_stats[area].bytes_freed += size; | |
200 | free_count = ++drm_mem_stats[area].free_count; | |
201 | alloc_count = drm_mem_stats[area].succeed_count; | |
202 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
203 | if (free_count > alloc_count) { |
204 | DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n", | |
205 | free_count, alloc_count); | |
206 | } | |
207 | } | |
208 | ||
f0c408b5 | 209 | void *drm_ioremap (unsigned long offset, unsigned long size, |
b5e89ed5 | 210 | drm_device_t * dev) { |
1da177e4 LT |
211 | void *pt; |
212 | ||
213 | if (!size) { | |
214 | DRM_MEM_ERROR(DRM_MEM_MAPPINGS, | |
215 | "Mapping 0 bytes at 0x%08lx\n", offset); | |
216 | return NULL; | |
217 | } | |
218 | ||
219 | if (!(pt = drm_ioremap(offset, size, dev))) { | |
f0c408b5 DA |
220 | spin_lock(&drm_mem_lock); |
221 | ++drm_mem_stats[DRM_MEM_MAPPINGS].fail_count; | |
222 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
223 | return NULL; |
224 | } | |
f0c408b5 DA |
225 | spin_lock(&drm_mem_lock); |
226 | ++drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count; | |
227 | drm_mem_stats[DRM_MEM_MAPPINGS].bytes_allocated += size; | |
228 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
229 | return pt; |
230 | } | |
231 | ||
031de96a | 232 | #if 0 |
f0c408b5 | 233 | void *drm_ioremap_nocache (unsigned long offset, unsigned long size, |
b5e89ed5 | 234 | drm_device_t * dev) { |
1da177e4 LT |
235 | void *pt; |
236 | ||
237 | if (!size) { | |
238 | DRM_MEM_ERROR(DRM_MEM_MAPPINGS, | |
239 | "Mapping 0 bytes at 0x%08lx\n", offset); | |
240 | return NULL; | |
241 | } | |
242 | ||
243 | if (!(pt = drm_ioremap_nocache(offset, size, dev))) { | |
f0c408b5 DA |
244 | spin_lock(&drm_mem_lock); |
245 | ++drm_mem_stats[DRM_MEM_MAPPINGS].fail_count; | |
246 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
247 | return NULL; |
248 | } | |
f0c408b5 DA |
249 | spin_lock(&drm_mem_lock); |
250 | ++drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count; | |
251 | drm_mem_stats[DRM_MEM_MAPPINGS].bytes_allocated += size; | |
252 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
253 | return pt; |
254 | } | |
031de96a | 255 | #endif /* 0 */ |
1da177e4 | 256 | |
f0c408b5 | 257 | void drm_ioremapfree (void *pt, unsigned long size, drm_device_t * dev) { |
1da177e4 LT |
258 | int alloc_count; |
259 | int free_count; | |
260 | ||
261 | if (!pt) | |
262 | DRM_MEM_ERROR(DRM_MEM_MAPPINGS, | |
263 | "Attempt to free NULL pointer\n"); | |
264 | else | |
265 | drm_ioremapfree(pt, size, dev); | |
266 | ||
f0c408b5 DA |
267 | spin_lock(&drm_mem_lock); |
268 | drm_mem_stats[DRM_MEM_MAPPINGS].bytes_freed += size; | |
269 | free_count = ++drm_mem_stats[DRM_MEM_MAPPINGS].free_count; | |
270 | alloc_count = drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count; | |
271 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
272 | if (free_count > alloc_count) { |
273 | DRM_MEM_ERROR(DRM_MEM_MAPPINGS, | |
274 | "Excess frees: %d frees, %d allocs\n", | |
275 | free_count, alloc_count); | |
276 | } | |
277 | } | |
278 | ||
279 | #if __OS_HAS_AGP | |
280 | ||
f0c408b5 | 281 | DRM_AGP_MEM *drm_alloc_agp (drm_device_t *dev, int pages, u32 type) { |
1da177e4 LT |
282 | DRM_AGP_MEM *handle; |
283 | ||
284 | if (!pages) { | |
285 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, "Allocating 0 pages\n"); | |
286 | return NULL; | |
287 | } | |
288 | ||
f0c408b5 DA |
289 | if ((handle = drm_agp_allocate_memory (pages, type))) { |
290 | spin_lock(&drm_mem_lock); | |
291 | ++drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count; | |
292 | drm_mem_stats[DRM_MEM_TOTALAGP].bytes_allocated | |
b5e89ed5 | 293 | += pages << PAGE_SHIFT; |
f0c408b5 | 294 | spin_unlock(&drm_mem_lock); |
1da177e4 LT |
295 | return handle; |
296 | } | |
f0c408b5 DA |
297 | spin_lock(&drm_mem_lock); |
298 | ++drm_mem_stats[DRM_MEM_TOTALAGP].fail_count; | |
299 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
300 | return NULL; |
301 | } | |
302 | ||
f0c408b5 | 303 | int drm_free_agp (DRM_AGP_MEM * handle, int pages) { |
b5e89ed5 DA |
304 | int alloc_count; |
305 | int free_count; | |
306 | int retval = -EINVAL; | |
1da177e4 LT |
307 | |
308 | if (!handle) { | |
309 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, | |
310 | "Attempt to free NULL AGP handle\n"); | |
311 | return retval; | |
312 | } | |
313 | ||
f0c408b5 DA |
314 | if (drm_agp_free_memory (handle)) { |
315 | spin_lock(&drm_mem_lock); | |
316 | free_count = ++drm_mem_stats[DRM_MEM_TOTALAGP].free_count; | |
317 | alloc_count = drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count; | |
318 | drm_mem_stats[DRM_MEM_TOTALAGP].bytes_freed | |
b5e89ed5 | 319 | += pages << PAGE_SHIFT; |
f0c408b5 | 320 | spin_unlock(&drm_mem_lock); |
1da177e4 LT |
321 | if (free_count > alloc_count) { |
322 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, | |
323 | "Excess frees: %d frees, %d allocs\n", | |
324 | free_count, alloc_count); | |
325 | } | |
326 | return 0; | |
327 | } | |
328 | return retval; | |
329 | } | |
330 | ||
f0c408b5 | 331 | int drm_bind_agp (DRM_AGP_MEM * handle, unsigned int start) { |
1da177e4 LT |
332 | int retcode = -EINVAL; |
333 | ||
334 | if (!handle) { | |
335 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | |
336 | "Attempt to bind NULL AGP handle\n"); | |
337 | return retcode; | |
338 | } | |
339 | ||
f0c408b5 DA |
340 | if (!(retcode = drm_agp_bind_memory (handle, start))) { |
341 | spin_lock(&drm_mem_lock); | |
342 | ++drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count; | |
343 | drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_allocated | |
b5e89ed5 | 344 | += handle->page_count << PAGE_SHIFT; |
f0c408b5 | 345 | spin_unlock(&drm_mem_lock); |
1da177e4 LT |
346 | return retcode; |
347 | } | |
f0c408b5 DA |
348 | spin_lock(&drm_mem_lock); |
349 | ++drm_mem_stats[DRM_MEM_BOUNDAGP].fail_count; | |
350 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
351 | return retcode; |
352 | } | |
353 | ||
f0c408b5 | 354 | int drm_unbind_agp (DRM_AGP_MEM * handle) { |
1da177e4 LT |
355 | int alloc_count; |
356 | int free_count; | |
357 | int retcode = -EINVAL; | |
358 | ||
359 | if (!handle) { | |
360 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | |
361 | "Attempt to unbind NULL AGP handle\n"); | |
362 | return retcode; | |
363 | } | |
364 | ||
f0c408b5 | 365 | if ((retcode = drm_agp_unbind_memory (handle))) |
b5e89ed5 | 366 | return retcode; |
f0c408b5 DA |
367 | spin_lock(&drm_mem_lock); |
368 | free_count = ++drm_mem_stats[DRM_MEM_BOUNDAGP].free_count; | |
369 | alloc_count = drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count; | |
370 | drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_freed | |
b5e89ed5 | 371 | += handle->page_count << PAGE_SHIFT; |
f0c408b5 | 372 | spin_unlock(&drm_mem_lock); |
1da177e4 LT |
373 | if (free_count > alloc_count) { |
374 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | |
375 | "Excess frees: %d frees, %d allocs\n", | |
376 | free_count, alloc_count); | |
377 | } | |
378 | return retcode; | |
379 | } | |
380 | #endif |