aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorKristian Høgsberg Kristensen2015-07-31 12:47:50 -0500
committerKristian Høgsberg Kristensen2015-08-03 11:19:47 -0500
commitcd2f91e18db087edf93fed828e568ee53b887860 (patch)
treea50e3c8d824f097aca87a3fc2bee2b2cae254e74
parentfc083322b0c8a58b51976adf23a582bce8bb75f1 (diff)
downloadexternal-libdrm-cd2f91e18db087edf93fed828e568ee53b887860.tar.gz
external-libdrm-cd2f91e18db087edf93fed828e568ee53b887860.tar.xz
external-libdrm-cd2f91e18db087edf93fed828e568ee53b887860.zip
intel: Drop aub dumping functionality
We now have a separate tool for this in intel-gpu-tools and we don't need to clutter up libdrm with this feature. We leave the entry points in there to avoid breaking API/ABI. Install intel-gpu-tools, then run (for example) $ intel_aubdump --output=trace.aub glxgears -geometry 500x500 See the intel_aubdump man page for more details. Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk> Signed-off-by: Kristian Høgsberg Kristensen <kristian.h.kristensen@intel.com>
-rw-r--r--intel/intel_bufmgr_gem.c375
1 files changed, 5 insertions, 370 deletions
diff --git a/intel/intel_bufmgr_gem.c b/intel/intel_bufmgr_gem.c
index b1c3b3a1..41de396b 100644
--- a/intel/intel_bufmgr_gem.c
+++ b/intel/intel_bufmgr_gem.c
@@ -61,7 +61,6 @@
61#include "intel_bufmgr.h" 61#include "intel_bufmgr.h"
62#include "intel_bufmgr_priv.h" 62#include "intel_bufmgr_priv.h"
63#include "intel_chipset.h" 63#include "intel_chipset.h"
64#include "intel_aub.h"
65#include "string.h" 64#include "string.h"
66 65
67#include "i915_drm.h" 66#include "i915_drm.h"
@@ -138,9 +137,6 @@ typedef struct _drm_intel_bufmgr_gem {
138 uint32_t handle; 137 uint32_t handle;
139 } userptr_active; 138 } userptr_active;
140 139
141 char *aub_filename;
142 FILE *aub_file;
143 uint32_t aub_offset;
144} drm_intel_bufmgr_gem; 140} drm_intel_bufmgr_gem;
145 141
146#define DRM_INTEL_RELOC_FENCE (1<<0) 142#define DRM_INTEL_RELOC_FENCE (1<<0)
@@ -256,11 +252,6 @@ struct _drm_intel_bo_gem {
256 252
257 /** Flags that we may need to do the SW_FINSIH ioctl on unmap. */ 253 /** Flags that we may need to do the SW_FINSIH ioctl on unmap. */
258 bool mapped_cpu_write; 254 bool mapped_cpu_write;
259
260 uint32_t aub_offset;
261
262 drm_intel_aub_annotation *aub_annotations;
263 unsigned aub_annotation_count;
264}; 255};
265 256
266static unsigned int 257static unsigned int
@@ -789,8 +780,6 @@ retry:
789 bo_gem->used_as_reloc_target = false; 780 bo_gem->used_as_reloc_target = false;
790 bo_gem->has_error = false; 781 bo_gem->has_error = false;
791 bo_gem->reusable = true; 782 bo_gem->reusable = true;
792 bo_gem->aub_annotations = NULL;
793 bo_gem->aub_annotation_count = 0;
794 783
795 drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, alignment); 784 drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, alignment);
796 785
@@ -1143,7 +1132,6 @@ drm_intel_gem_bo_free(drm_intel_bo *bo)
1143 DBG("DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n", 1132 DBG("DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n",
1144 bo_gem->gem_handle, bo_gem->name, strerror(errno)); 1133 bo_gem->gem_handle, bo_gem->name, strerror(errno));
1145 } 1134 }
1146 free(bo_gem->aub_annotations);
1147 free(bo); 1135 free(bo);
1148} 1136}
1149 1137
@@ -1822,7 +1810,6 @@ drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
1822 free(bufmgr_gem->exec2_objects); 1810 free(bufmgr_gem->exec2_objects);
1823 free(bufmgr_gem->exec_objects); 1811 free(bufmgr_gem->exec_objects);
1824 free(bufmgr_gem->exec_bos); 1812 free(bufmgr_gem->exec_bos);
1825 free(bufmgr_gem->aub_filename);
1826 1813
1827 pthread_mutex_destroy(&bufmgr_gem->lock); 1814 pthread_mutex_destroy(&bufmgr_gem->lock);
1828 1815
@@ -2116,297 +2103,12 @@ drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
2116 } 2103 }
2117} 2104}
2118 2105
2119static void
2120aub_out(drm_intel_bufmgr_gem *bufmgr_gem, uint32_t data)
2121{
2122 fwrite(&data, 1, 4, bufmgr_gem->aub_file);
2123}
2124
2125static void
2126aub_out_data(drm_intel_bufmgr_gem *bufmgr_gem, void *data, size_t size)
2127{
2128 fwrite(data, 1, size, bufmgr_gem->aub_file);
2129}
2130
2131static void
2132aub_write_bo_data(drm_intel_bo *bo, uint32_t offset, uint32_t size)
2133{
2134 drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2135 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2136 uint32_t *data;
2137 unsigned int i;
2138
2139 data = malloc(bo->size);
2140 drm_intel_bo_get_subdata(bo, offset, size, data);
2141
2142 /* Easy mode: write out bo with no relocations */
2143 if (!bo_gem->reloc_count) {
2144 aub_out_data(bufmgr_gem, data, size);
2145 free(data);
2146 return;
2147 }
2148
2149 /* Otherwise, handle the relocations while writing. */
2150 for (i = 0; i < size / 4; i++) {
2151 int r;
2152 for (r = 0; r < bo_gem->reloc_count; r++) {
2153 struct drm_i915_gem_relocation_entry *reloc;
2154 drm_intel_reloc_target *info;
2155
2156 reloc = &bo_gem->relocs[r];
2157 info = &bo_gem->reloc_target_info[r];
2158
2159 if (reloc->offset == offset + i * 4) {
2160 drm_intel_bo_gem *target_gem;
2161 uint32_t val;
2162
2163 target_gem = (drm_intel_bo_gem *)info->bo;
2164
2165 val = reloc->delta;
2166 val += target_gem->aub_offset;
2167
2168 aub_out(bufmgr_gem, val);
2169 data[i] = val;
2170 break;
2171 }
2172 }
2173 if (r == bo_gem->reloc_count) {
2174 /* no relocation, just the data */
2175 aub_out(bufmgr_gem, data[i]);
2176 }
2177 }
2178
2179 free(data);
2180}
2181
2182static void
2183aub_bo_get_address(drm_intel_bo *bo)
2184{
2185 drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2186 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2187
2188 /* Give the object a graphics address in the AUB file. We
2189 * don't just use the GEM object address because we do AUB
2190 * dumping before execution -- we want to successfully log
2191 * when the hardware might hang, and we might even want to aub
2192 * capture for a driver trying to execute on a different
2193 * generation of hardware by disabling the actual kernel exec
2194 * call.
2195 */
2196 bo_gem->aub_offset = bufmgr_gem->aub_offset;
2197 bufmgr_gem->aub_offset += bo->size;
2198 /* XXX: Handle aperture overflow. */
2199 assert(bufmgr_gem->aub_offset < 256 * 1024 * 1024);
2200}
2201
2202static void
2203aub_write_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype,
2204 uint32_t offset, uint32_t size)
2205{
2206 drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2207 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2208
2209 aub_out(bufmgr_gem,
2210 CMD_AUB_TRACE_HEADER_BLOCK |
2211 ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
2212 aub_out(bufmgr_gem,
2213 AUB_TRACE_MEMTYPE_GTT | type | AUB_TRACE_OP_DATA_WRITE);
2214 aub_out(bufmgr_gem, subtype);
2215 aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
2216 aub_out(bufmgr_gem, size);
2217 if (bufmgr_gem->gen >= 8)
2218 aub_out(bufmgr_gem, 0);
2219 aub_write_bo_data(bo, offset, size);
2220}
2221
2222/**
2223 * Break up large objects into multiple writes. Otherwise a 128kb VBO
2224 * would overflow the 16 bits of size field in the packet header and
2225 * everything goes badly after that.
2226 */
2227static void
2228aub_write_large_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype,
2229 uint32_t offset, uint32_t size)
2230{
2231 uint32_t block_size;
2232 uint32_t sub_offset;
2233
2234 for (sub_offset = 0; sub_offset < size; sub_offset += block_size) {
2235 block_size = size - sub_offset;
2236
2237 if (block_size > 8 * 4096)
2238 block_size = 8 * 4096;
2239
2240 aub_write_trace_block(bo, type, subtype, offset + sub_offset,
2241 block_size);
2242 }
2243}
2244
2245static void
2246aub_write_bo(drm_intel_bo *bo)
2247{
2248 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2249 uint32_t offset = 0;
2250 unsigned i;
2251
2252 aub_bo_get_address(bo);
2253
2254 /* Write out each annotated section separately. */
2255 for (i = 0; i < bo_gem->aub_annotation_count; ++i) {
2256 drm_intel_aub_annotation *annotation =
2257 &bo_gem->aub_annotations[i];
2258 uint32_t ending_offset = annotation->ending_offset;
2259 if (ending_offset > bo->size)
2260 ending_offset = bo->size;
2261 if (ending_offset > offset) {
2262 aub_write_large_trace_block(bo, annotation->type,
2263 annotation->subtype,
2264 offset,
2265 ending_offset - offset);
2266 offset = ending_offset;
2267 }
2268 }
2269
2270 /* Write out any remaining unannotated data */
2271 if (offset < bo->size) {
2272 aub_write_large_trace_block(bo, AUB_TRACE_TYPE_NOTYPE, 0,
2273 offset, bo->size - offset);
2274 }
2275}
2276
2277/*
2278 * Make a ringbuffer on fly and dump it
2279 */
2280static void
2281aub_build_dump_ringbuffer(drm_intel_bufmgr_gem *bufmgr_gem,
2282 uint32_t batch_buffer, int ring_flag)
2283{
2284 uint32_t ringbuffer[4096];
2285 int ring = AUB_TRACE_TYPE_RING_PRB0; /* The default ring */
2286 int ring_count = 0;
2287
2288 if (ring_flag == I915_EXEC_BSD)
2289 ring = AUB_TRACE_TYPE_RING_PRB1;
2290 else if (ring_flag == I915_EXEC_BLT)
2291 ring = AUB_TRACE_TYPE_RING_PRB2;
2292
2293 /* Make a ring buffer to execute our batchbuffer. */
2294 memset(ringbuffer, 0, sizeof(ringbuffer));
2295 if (bufmgr_gem->gen >= 8) {
2296 ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START | (3 - 2);
2297 ringbuffer[ring_count++] = batch_buffer;
2298 ringbuffer[ring_count++] = 0;
2299 } else {
2300 ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START;
2301 ringbuffer[ring_count++] = batch_buffer;
2302 }
2303
2304 /* Write out the ring. This appears to trigger execution of
2305 * the ring in the simulator.
2306 */
2307 aub_out(bufmgr_gem,
2308 CMD_AUB_TRACE_HEADER_BLOCK |
2309 ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
2310 aub_out(bufmgr_gem,
2311 AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE);
2312 aub_out(bufmgr_gem, 0); /* general/surface subtype */
2313 aub_out(bufmgr_gem, bufmgr_gem->aub_offset);
2314 aub_out(bufmgr_gem, ring_count * 4);
2315 if (bufmgr_gem->gen >= 8)
2316 aub_out(bufmgr_gem, 0);
2317
2318 /* FIXME: Need some flush operations here? */
2319 aub_out_data(bufmgr_gem, ringbuffer, ring_count * 4);
2320
2321 /* Update offset pointer */
2322 bufmgr_gem->aub_offset += 4096;
2323}
2324
2325void 2106void
2326drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo, 2107drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
2327 int x1, int y1, int width, int height, 2108 int x1, int y1, int width, int height,
2328 enum aub_dump_bmp_format format, 2109 enum aub_dump_bmp_format format,
2329 int pitch, int offset) 2110 int pitch, int offset)
2330{ 2111{
2331 drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2332 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
2333 uint32_t cpp;
2334
2335 switch (format) {
2336 case AUB_DUMP_BMP_FORMAT_8BIT:
2337 cpp = 1;
2338 break;
2339 case AUB_DUMP_BMP_FORMAT_ARGB_4444:
2340 cpp = 2;
2341 break;
2342 case AUB_DUMP_BMP_FORMAT_ARGB_0888:
2343 case AUB_DUMP_BMP_FORMAT_ARGB_8888:
2344 cpp = 4;
2345 break;
2346 default:
2347 printf("Unknown AUB dump format %d\n", format);
2348 return;
2349 }
2350
2351 if (!bufmgr_gem->aub_file)
2352 return;
2353
2354 aub_out(bufmgr_gem, CMD_AUB_DUMP_BMP | 4);
2355 aub_out(bufmgr_gem, (y1 << 16) | x1);
2356 aub_out(bufmgr_gem,
2357 (format << 24) |
2358 (cpp << 19) |
2359 pitch / 4);
2360 aub_out(bufmgr_gem, (height << 16) | width);
2361 aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
2362 aub_out(bufmgr_gem,
2363 ((bo_gem->tiling_mode != I915_TILING_NONE) ? (1 << 2) : 0) |
2364 ((bo_gem->tiling_mode == I915_TILING_Y) ? (1 << 3) : 0));
2365}
2366
2367static void
2368aub_exec(drm_intel_bo *bo, int ring_flag, int used)
2369{
2370 drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2371 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2372 int i;
2373 bool batch_buffer_needs_annotations;
2374
2375 if (!bufmgr_gem->aub_file)
2376 return;
2377
2378 /* If batch buffer is not annotated, annotate it the best we
2379 * can.
2380 */
2381 batch_buffer_needs_annotations = bo_gem->aub_annotation_count == 0;
2382 if (batch_buffer_needs_annotations) {
2383 drm_intel_aub_annotation annotations[2] = {
2384 { AUB_TRACE_TYPE_BATCH, 0, used },
2385 { AUB_TRACE_TYPE_NOTYPE, 0, bo->size }
2386 };
2387 drm_intel_bufmgr_gem_set_aub_annotations(bo, annotations, 2);
2388 }
2389
2390 /* Write out all buffers to AUB memory */
2391 for (i = 0; i < bufmgr_gem->exec_count; i++) {
2392 aub_write_bo(bufmgr_gem->exec_bos[i]);
2393 }
2394
2395 /* Remove any annotations we added */
2396 if (batch_buffer_needs_annotations)
2397 drm_intel_bufmgr_gem_set_aub_annotations(bo, NULL, 0);
2398
2399 /* Dump ring buffer */
2400 aub_build_dump_ringbuffer(bufmgr_gem, bo_gem->aub_offset, ring_flag);
2401
2402 fflush(bufmgr_gem->aub_file);
2403
2404 /*
2405 * One frame has been dumped. So reset the aub_offset for the next frame.
2406 *
2407 * FIXME: Can we do this?
2408 */
2409 bufmgr_gem->aub_offset = 0x10000;
2410} 2112}
2411 2113
2412static int 2114static int
@@ -2533,8 +2235,6 @@ do_exec2(drm_intel_bo *bo, int used, drm_intel_context *ctx,
2533 i915_execbuffer2_set_context_id(execbuf, ctx->ctx_id); 2235 i915_execbuffer2_set_context_id(execbuf, ctx->ctx_id);
2534 execbuf.rsvd2 = 0; 2236 execbuf.rsvd2 = 0;
2535 2237
2536 aub_exec(bo, flags, used);
2537
2538 if (bufmgr_gem->no_exec) 2238 if (bufmgr_gem->no_exec)
2539 goto skip_execution; 2239 goto skip_execution;
2540 2240
@@ -3210,11 +2910,6 @@ void
3210drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr, 2910drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr,
3211 const char *filename) 2911 const char *filename)
3212{ 2912{
3213 drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3214
3215 free(bufmgr_gem->aub_filename);
3216 if (filename)
3217 bufmgr_gem->aub_filename = strdup(filename);
3218} 2913}
3219 2914
3220/** 2915/**
@@ -3228,58 +2923,11 @@ drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr,
3228void 2923void
3229drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable) 2924drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable)
3230{ 2925{
3231 drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr; 2926 fprintf(stderr, "libdrm aub dumping is deprecated.\n\n"
3232 int entry = 0x200003; 2927 "Use intel_aubdump from intel-gpu-tools instead. Install intel-gpu-tools,\n"
3233 int i; 2928 "then run (for example)\n\n"
3234 int gtt_size = 0x10000; 2929 "\t$ intel_aubdump --output=trace.aub glxgears -geometry 500x500\n\n"
3235 const char *filename; 2930 "See the intel_aubdump man page for more details.\n");
3236
3237 if (!enable) {
3238 if (bufmgr_gem->aub_file) {
3239 fclose(bufmgr_gem->aub_file);
3240 bufmgr_gem->aub_file = NULL;
3241 }
3242 return;
3243 }
3244
3245 if (geteuid() != getuid())
3246 return;
3247
3248 if (bufmgr_gem->aub_filename)
3249 filename = bufmgr_gem->aub_filename;
3250 else
3251 filename = "intel.aub";
3252 bufmgr_gem->aub_file = fopen(filename, "w+");
3253 if (!bufmgr_gem->aub_file)
3254 return;
3255
3256 /* Start allocating objects from just after the GTT. */
3257 bufmgr_gem->aub_offset = gtt_size;
3258
3259 /* Start with a (required) version packet. */
3260 aub_out(bufmgr_gem, CMD_AUB_HEADER | (13 - 2));
3261 aub_out(bufmgr_gem,
3262 (4 << AUB_HEADER_MAJOR_SHIFT) |
3263 (0 << AUB_HEADER_MINOR_SHIFT));
3264 for (i = 0; i < 8; i++) {
3265 aub_out(bufmgr_gem, 0); /* app name */
3266 }
3267 aub_out(bufmgr_gem, 0); /* timestamp */
3268 aub_out(bufmgr_gem, 0); /* timestamp */
3269 aub_out(bufmgr_gem, 0); /* comment len */
3270
3271 /* Set up the GTT. The max we can handle is 256M */
3272 aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
3273 /* Need to use GTT_ENTRY type for recent emulator */
3274 aub_out(bufmgr_gem, AUB_TRACE_MEMTYPE_GTT_ENTRY | 0 | AUB_TRACE_OP_DATA_WRITE);
3275 aub_out(bufmgr_gem, 0); /* subtype */
3276 aub_out(bufmgr_gem, 0); /* offset */
3277 aub_out(bufmgr_gem, gtt_size); /* size */
3278 if (bufmgr_gem->gen >= 8)
3279 aub_out(bufmgr_gem, 0);
3280 for (i = 0x000; i < gtt_size; i += 4, entry += 0x1000) {
3281 aub_out(bufmgr_gem, entry);
3282 }
3283} 2931}
3284 2932
3285drm_intel_context * 2933drm_intel_context *
@@ -3442,19 +3090,6 @@ drm_intel_bufmgr_gem_set_aub_annotations(drm_intel_bo *bo,
3442 drm_intel_aub_annotation *annotations, 3090 drm_intel_aub_annotation *annotations,
3443 unsigned count) 3091 unsigned count)
3444{ 3092{
3445 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
3446 unsigned size = sizeof(*annotations) * count;
3447 drm_intel_aub_annotation *new_annotations =
3448 count > 0 ? realloc(bo_gem->aub_annotations, size) : NULL;
3449 if (new_annotations == NULL) {
3450 free(bo_gem->aub_annotations);
3451 bo_gem->aub_annotations = NULL;
3452 bo_gem->aub_annotation_count = 0;
3453 return;
3454 }
3455 memcpy(new_annotations, annotations, size);
3456 bo_gem->aub_annotations = new_annotations;
3457 bo_gem->aub_annotation_count = count;
3458} 3093}
3459 3094
3460static pthread_mutex_t bufmgr_list_mutex = PTHREAD_MUTEX_INITIALIZER; 3095static pthread_mutex_t bufmgr_list_mutex = PTHREAD_MUTEX_INITIALIZER;