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 | ||
1da177e4 LT |
34 | #include "drmP.h" |
35 | ||
36 | typedef struct drm_mem_stats { | |
b5e89ed5 DA |
37 | const char *name; |
38 | int succeed_count; | |
39 | int free_count; | |
40 | int fail_count; | |
41 | unsigned long bytes_allocated; | |
42 | unsigned long bytes_freed; | |
1da177e4 LT |
43 | } drm_mem_stats_t; |
44 | ||
34af946a | 45 | static DEFINE_SPINLOCK(drm_mem_lock); |
f0c408b5 DA |
46 | static unsigned long drm_ram_available = 0; /* In pages */ |
47 | static unsigned long drm_ram_used = 0; | |
48 | static drm_mem_stats_t drm_mem_stats[] = | |
b5e89ed5 | 49 | { |
f0c408b5 DA |
50 | [DRM_MEM_DMA] = {"dmabufs"}, |
51 | [DRM_MEM_SAREA] = {"sareas"}, | |
52 | [DRM_MEM_DRIVER] = {"driver"}, | |
53 | [DRM_MEM_MAGIC] = {"magic"}, | |
54 | [DRM_MEM_IOCTLS] = {"ioctltab"}, | |
55 | [DRM_MEM_MAPS] = {"maplist"}, | |
56 | [DRM_MEM_VMAS] = {"vmalist"}, | |
57 | [DRM_MEM_BUFS] = {"buflist"}, | |
58 | [DRM_MEM_SEGS] = {"seglist"}, | |
59 | [DRM_MEM_PAGES] = {"pagelist"}, | |
60 | [DRM_MEM_FILES] = {"files"}, | |
61 | [DRM_MEM_QUEUES] = {"queues"}, | |
62 | [DRM_MEM_CMDS] = {"commands"}, | |
63 | [DRM_MEM_MAPPINGS] = {"mappings"}, | |
64 | [DRM_MEM_BUFLISTS] = {"buflists"}, | |
65 | [DRM_MEM_AGPLISTS] = {"agplist"}, | |
66 | [DRM_MEM_SGLISTS] = {"sglist"}, | |
67 | [DRM_MEM_TOTALAGP] = {"totalagp"}, | |
68 | [DRM_MEM_BOUNDAGP] = {"boundagp"}, | |
69 | [DRM_MEM_CTXBITMAP] = {"ctxbitmap"}, | |
70 | [DRM_MEM_CTXLIST] = {"ctxlist"}, | |
71 | [DRM_MEM_STUB] = {"stub"}, | |
72 | {NULL, 0,} /* Last entry must be null */ | |
1da177e4 LT |
73 | }; |
74 | ||
f0c408b5 | 75 | void drm_mem_init (void) { |
1da177e4 | 76 | drm_mem_stats_t *mem; |
b5e89ed5 | 77 | struct sysinfo si; |
1da177e4 | 78 | |
f0c408b5 | 79 | for (mem = drm_mem_stats; mem->name; ++mem) { |
b5e89ed5 DA |
80 | mem->succeed_count = 0; |
81 | mem->free_count = 0; | |
82 | mem->fail_count = 0; | |
1da177e4 | 83 | mem->bytes_allocated = 0; |
b5e89ed5 | 84 | mem->bytes_freed = 0; |
1da177e4 LT |
85 | } |
86 | ||
87 | si_meminfo(&si); | |
f0c408b5 DA |
88 | drm_ram_available = si.totalram; |
89 | drm_ram_used = 0; | |
1da177e4 LT |
90 | } |
91 | ||
92 | /* drm_mem_info is called whenever a process reads /dev/drm/mem. */ | |
93 | ||
f0c408b5 | 94 | static int drm__mem_info (char *buf, char **start, off_t offset, |
b5e89ed5 | 95 | int request, int *eof, void *data) { |
1da177e4 | 96 | drm_mem_stats_t *pt; |
b5e89ed5 | 97 | int len = 0; |
1da177e4 LT |
98 | |
99 | if (offset > DRM_PROC_LIMIT) { | |
100 | *eof = 1; | |
101 | return 0; | |
102 | } | |
103 | ||
b5e89ed5 | 104 | *eof = 0; |
1da177e4 LT |
105 | *start = &buf[offset]; |
106 | ||
107 | DRM_PROC_PRINT(" total counts " | |
108 | " | outstanding \n"); | |
109 | DRM_PROC_PRINT("type alloc freed fail bytes freed" | |
110 | " | allocs bytes\n\n"); | |
111 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB |\n", | |
112 | "system", 0, 0, 0, | |
f0c408b5 | 113 | drm_ram_available << (PAGE_SHIFT - 10)); |
1da177e4 | 114 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB |\n", |
f0c408b5 | 115 | "locked", 0, 0, 0, drm_ram_used >> 10); |
1da177e4 | 116 | DRM_PROC_PRINT("\n"); |
f0c408b5 | 117 | for (pt = drm_mem_stats; pt->name; pt++) { |
1da177e4 LT |
118 | DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu %10lu | %6d %10ld\n", |
119 | pt->name, | |
120 | pt->succeed_count, | |
121 | pt->free_count, | |
122 | pt->fail_count, | |
123 | pt->bytes_allocated, | |
124 | pt->bytes_freed, | |
125 | pt->succeed_count - pt->free_count, | |
126 | (long)pt->bytes_allocated | |
127 | - (long)pt->bytes_freed); | |
128 | } | |
129 | ||
b5e89ed5 DA |
130 | if (len > request + offset) |
131 | return request; | |
1da177e4 LT |
132 | *eof = 1; |
133 | return len - offset; | |
134 | } | |
135 | ||
f0c408b5 | 136 | int drm_mem_info (char *buf, char **start, off_t offset, |
b5e89ed5 | 137 | int len, int *eof, void *data) { |
1da177e4 LT |
138 | int ret; |
139 | ||
f0c408b5 DA |
140 | spin_lock(&drm_mem_lock); |
141 | ret = drm__mem_info (buf, start, offset, len, eof, data); | |
142 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
143 | return ret; |
144 | } | |
145 | ||
f0c408b5 | 146 | void *drm_alloc (size_t size, int area) { |
1da177e4 LT |
147 | void *pt; |
148 | ||
149 | if (!size) { | |
150 | DRM_MEM_ERROR(area, "Allocating 0 bytes\n"); | |
151 | return NULL; | |
152 | } | |
153 | ||
154 | if (!(pt = kmalloc(size, GFP_KERNEL))) { | |
f0c408b5 DA |
155 | spin_lock(&drm_mem_lock); |
156 | ++drm_mem_stats[area].fail_count; | |
157 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
158 | return NULL; |
159 | } | |
f0c408b5 DA |
160 | spin_lock(&drm_mem_lock); |
161 | ++drm_mem_stats[area].succeed_count; | |
162 | drm_mem_stats[area].bytes_allocated += size; | |
163 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
164 | return pt; |
165 | } | |
166 | ||
f0c408b5 | 167 | void *drm_calloc (size_t nmemb, size_t size, int area) { |
1da177e4 LT |
168 | void *addr; |
169 | ||
f0c408b5 | 170 | addr = drm_alloc (nmemb * size, area); |
1da177e4 LT |
171 | if (addr != NULL) |
172 | memset((void *)addr, 0, size * nmemb); | |
173 | ||
174 | return addr; | |
175 | } | |
176 | ||
f0c408b5 | 177 | void *drm_realloc (void *oldpt, size_t oldsize, size_t size, int area) { |
1da177e4 LT |
178 | void *pt; |
179 | ||
f0c408b5 | 180 | if (!(pt = drm_alloc (size, area))) |
b5e89ed5 | 181 | return NULL; |
1da177e4 LT |
182 | if (oldpt && oldsize) { |
183 | memcpy(pt, oldpt, oldsize); | |
f0c408b5 | 184 | drm_free (oldpt, oldsize, area); |
1da177e4 LT |
185 | } |
186 | return pt; | |
187 | } | |
188 | ||
f0c408b5 | 189 | void drm_free (void *pt, size_t size, int area) { |
1da177e4 LT |
190 | int alloc_count; |
191 | int free_count; | |
192 | ||
b5e89ed5 DA |
193 | if (!pt) |
194 | DRM_MEM_ERROR(area, "Attempt to free NULL pointer\n"); | |
195 | else | |
196 | kfree(pt); | |
f0c408b5 DA |
197 | spin_lock(&drm_mem_lock); |
198 | drm_mem_stats[area].bytes_freed += size; | |
199 | free_count = ++drm_mem_stats[area].free_count; | |
200 | alloc_count = drm_mem_stats[area].succeed_count; | |
201 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
202 | if (free_count > alloc_count) { |
203 | DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n", | |
204 | free_count, alloc_count); | |
205 | } | |
206 | } | |
207 | ||
1da177e4 LT |
208 | #if __OS_HAS_AGP |
209 | ||
f0c408b5 | 210 | DRM_AGP_MEM *drm_alloc_agp (drm_device_t *dev, int pages, u32 type) { |
1da177e4 LT |
211 | DRM_AGP_MEM *handle; |
212 | ||
213 | if (!pages) { | |
214 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, "Allocating 0 pages\n"); | |
215 | return NULL; | |
216 | } | |
217 | ||
f0c408b5 DA |
218 | if ((handle = drm_agp_allocate_memory (pages, type))) { |
219 | spin_lock(&drm_mem_lock); | |
220 | ++drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count; | |
221 | drm_mem_stats[DRM_MEM_TOTALAGP].bytes_allocated | |
b5e89ed5 | 222 | += pages << PAGE_SHIFT; |
f0c408b5 | 223 | spin_unlock(&drm_mem_lock); |
1da177e4 LT |
224 | return handle; |
225 | } | |
f0c408b5 DA |
226 | spin_lock(&drm_mem_lock); |
227 | ++drm_mem_stats[DRM_MEM_TOTALAGP].fail_count; | |
228 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
229 | return NULL; |
230 | } | |
231 | ||
f0c408b5 | 232 | int drm_free_agp (DRM_AGP_MEM * handle, int pages) { |
b5e89ed5 DA |
233 | int alloc_count; |
234 | int free_count; | |
235 | int retval = -EINVAL; | |
1da177e4 LT |
236 | |
237 | if (!handle) { | |
238 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, | |
239 | "Attempt to free NULL AGP handle\n"); | |
240 | return retval; | |
241 | } | |
242 | ||
f0c408b5 DA |
243 | if (drm_agp_free_memory (handle)) { |
244 | spin_lock(&drm_mem_lock); | |
245 | free_count = ++drm_mem_stats[DRM_MEM_TOTALAGP].free_count; | |
246 | alloc_count = drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count; | |
247 | drm_mem_stats[DRM_MEM_TOTALAGP].bytes_freed | |
b5e89ed5 | 248 | += pages << PAGE_SHIFT; |
f0c408b5 | 249 | spin_unlock(&drm_mem_lock); |
1da177e4 LT |
250 | if (free_count > alloc_count) { |
251 | DRM_MEM_ERROR(DRM_MEM_TOTALAGP, | |
252 | "Excess frees: %d frees, %d allocs\n", | |
253 | free_count, alloc_count); | |
254 | } | |
255 | return 0; | |
256 | } | |
257 | return retval; | |
258 | } | |
259 | ||
f0c408b5 | 260 | int drm_bind_agp (DRM_AGP_MEM * handle, unsigned int start) { |
1da177e4 LT |
261 | int retcode = -EINVAL; |
262 | ||
263 | if (!handle) { | |
264 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | |
265 | "Attempt to bind NULL AGP handle\n"); | |
266 | return retcode; | |
267 | } | |
268 | ||
f0c408b5 DA |
269 | if (!(retcode = drm_agp_bind_memory (handle, start))) { |
270 | spin_lock(&drm_mem_lock); | |
271 | ++drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count; | |
272 | drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_allocated | |
b5e89ed5 | 273 | += handle->page_count << PAGE_SHIFT; |
f0c408b5 | 274 | spin_unlock(&drm_mem_lock); |
1da177e4 LT |
275 | return retcode; |
276 | } | |
f0c408b5 DA |
277 | spin_lock(&drm_mem_lock); |
278 | ++drm_mem_stats[DRM_MEM_BOUNDAGP].fail_count; | |
279 | spin_unlock(&drm_mem_lock); | |
1da177e4 LT |
280 | return retcode; |
281 | } | |
282 | ||
f0c408b5 | 283 | int drm_unbind_agp (DRM_AGP_MEM * handle) { |
1da177e4 LT |
284 | int alloc_count; |
285 | int free_count; | |
286 | int retcode = -EINVAL; | |
287 | ||
288 | if (!handle) { | |
289 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | |
290 | "Attempt to unbind NULL AGP handle\n"); | |
291 | return retcode; | |
292 | } | |
293 | ||
f0c408b5 | 294 | if ((retcode = drm_agp_unbind_memory (handle))) |
b5e89ed5 | 295 | return retcode; |
f0c408b5 DA |
296 | spin_lock(&drm_mem_lock); |
297 | free_count = ++drm_mem_stats[DRM_MEM_BOUNDAGP].free_count; | |
298 | alloc_count = drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count; | |
299 | drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_freed | |
b5e89ed5 | 300 | += handle->page_count << PAGE_SHIFT; |
f0c408b5 | 301 | spin_unlock(&drm_mem_lock); |
1da177e4 LT |
302 | if (free_count > alloc_count) { |
303 | DRM_MEM_ERROR(DRM_MEM_BOUNDAGP, | |
304 | "Excess frees: %d frees, %d allocs\n", | |
305 | free_count, alloc_count); | |
306 | } | |
307 | return retcode; | |
308 | } | |
309 | #endif |