mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-23 06:43:06 +07:00
a4872ba6d0
In the upcoming patches we plan to break the correlation between engine command streamers (a.k.a. rings) and ringbuffers, so it makes sense to refactor the code and make the change obvious. No functional changes. Signed-off-by: Oscar Mateo <oscar.mateo@intel.com> Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
596 lines
14 KiB
C
596 lines
14 KiB
C
#if !defined(_I915_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
|
|
#define _I915_TRACE_H_
|
|
|
|
#include <linux/stringify.h>
|
|
#include <linux/types.h>
|
|
#include <linux/tracepoint.h>
|
|
|
|
#include <drm/drmP.h>
|
|
#include "i915_drv.h"
|
|
#include "intel_drv.h"
|
|
#include "intel_ringbuffer.h"
|
|
|
|
#undef TRACE_SYSTEM
|
|
#define TRACE_SYSTEM i915
|
|
#define TRACE_SYSTEM_STRING __stringify(TRACE_SYSTEM)
|
|
#define TRACE_INCLUDE_FILE i915_trace
|
|
|
|
/* pipe updates */
|
|
|
|
TRACE_EVENT(i915_pipe_update_start,
|
|
TP_PROTO(struct intel_crtc *crtc, u32 min, u32 max),
|
|
TP_ARGS(crtc, min, max),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(enum pipe, pipe)
|
|
__field(u32, frame)
|
|
__field(u32, scanline)
|
|
__field(u32, min)
|
|
__field(u32, max)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->pipe = crtc->pipe;
|
|
__entry->frame = crtc->base.dev->driver->get_vblank_counter(crtc->base.dev,
|
|
crtc->pipe);
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
__entry->min = min;
|
|
__entry->max = max;
|
|
),
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u, min=%u, max=%u",
|
|
pipe_name(__entry->pipe), __entry->frame,
|
|
__entry->scanline, __entry->min, __entry->max)
|
|
);
|
|
|
|
TRACE_EVENT(i915_pipe_update_vblank_evaded,
|
|
TP_PROTO(struct intel_crtc *crtc, u32 min, u32 max, u32 frame),
|
|
TP_ARGS(crtc, min, max, frame),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(enum pipe, pipe)
|
|
__field(u32, frame)
|
|
__field(u32, scanline)
|
|
__field(u32, min)
|
|
__field(u32, max)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->pipe = crtc->pipe;
|
|
__entry->frame = frame;
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
__entry->min = min;
|
|
__entry->max = max;
|
|
),
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u, min=%u, max=%u",
|
|
pipe_name(__entry->pipe), __entry->frame,
|
|
__entry->scanline, __entry->min, __entry->max)
|
|
);
|
|
|
|
TRACE_EVENT(i915_pipe_update_end,
|
|
TP_PROTO(struct intel_crtc *crtc, u32 frame),
|
|
TP_ARGS(crtc, frame),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(enum pipe, pipe)
|
|
__field(u32, frame)
|
|
__field(u32, scanline)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->pipe = crtc->pipe;
|
|
__entry->frame = frame;
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
),
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u",
|
|
pipe_name(__entry->pipe), __entry->frame,
|
|
__entry->scanline)
|
|
);
|
|
|
|
/* object tracking */
|
|
|
|
TRACE_EVENT(i915_gem_object_create,
|
|
TP_PROTO(struct drm_i915_gem_object *obj),
|
|
TP_ARGS(obj),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
__field(u32, size)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->obj = obj;
|
|
__entry->size = obj->base.size;
|
|
),
|
|
|
|
TP_printk("obj=%p, size=%u", __entry->obj, __entry->size)
|
|
);
|
|
|
|
TRACE_EVENT(i915_vma_bind,
|
|
TP_PROTO(struct i915_vma *vma, unsigned flags),
|
|
TP_ARGS(vma, flags),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
__field(struct i915_address_space *, vm)
|
|
__field(u32, offset)
|
|
__field(u32, size)
|
|
__field(unsigned, flags)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->obj = vma->obj;
|
|
__entry->vm = vma->vm;
|
|
__entry->offset = vma->node.start;
|
|
__entry->size = vma->node.size;
|
|
__entry->flags = flags;
|
|
),
|
|
|
|
TP_printk("obj=%p, offset=%08x size=%x%s vm=%p",
|
|
__entry->obj, __entry->offset, __entry->size,
|
|
__entry->flags & PIN_MAPPABLE ? ", mappable" : "",
|
|
__entry->vm)
|
|
);
|
|
|
|
TRACE_EVENT(i915_vma_unbind,
|
|
TP_PROTO(struct i915_vma *vma),
|
|
TP_ARGS(vma),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
__field(struct i915_address_space *, vm)
|
|
__field(u32, offset)
|
|
__field(u32, size)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->obj = vma->obj;
|
|
__entry->vm = vma->vm;
|
|
__entry->offset = vma->node.start;
|
|
__entry->size = vma->node.size;
|
|
),
|
|
|
|
TP_printk("obj=%p, offset=%08x size=%x vm=%p",
|
|
__entry->obj, __entry->offset, __entry->size, __entry->vm)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_object_change_domain,
|
|
TP_PROTO(struct drm_i915_gem_object *obj, u32 old_read, u32 old_write),
|
|
TP_ARGS(obj, old_read, old_write),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
__field(u32, read_domains)
|
|
__field(u32, write_domain)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->obj = obj;
|
|
__entry->read_domains = obj->base.read_domains | (old_read << 16);
|
|
__entry->write_domain = obj->base.write_domain | (old_write << 16);
|
|
),
|
|
|
|
TP_printk("obj=%p, read=%02x=>%02x, write=%02x=>%02x",
|
|
__entry->obj,
|
|
__entry->read_domains >> 16,
|
|
__entry->read_domains & 0xffff,
|
|
__entry->write_domain >> 16,
|
|
__entry->write_domain & 0xffff)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_object_pwrite,
|
|
TP_PROTO(struct drm_i915_gem_object *obj, u32 offset, u32 len),
|
|
TP_ARGS(obj, offset, len),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
__field(u32, offset)
|
|
__field(u32, len)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->obj = obj;
|
|
__entry->offset = offset;
|
|
__entry->len = len;
|
|
),
|
|
|
|
TP_printk("obj=%p, offset=%u, len=%u",
|
|
__entry->obj, __entry->offset, __entry->len)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_object_pread,
|
|
TP_PROTO(struct drm_i915_gem_object *obj, u32 offset, u32 len),
|
|
TP_ARGS(obj, offset, len),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
__field(u32, offset)
|
|
__field(u32, len)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->obj = obj;
|
|
__entry->offset = offset;
|
|
__entry->len = len;
|
|
),
|
|
|
|
TP_printk("obj=%p, offset=%u, len=%u",
|
|
__entry->obj, __entry->offset, __entry->len)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_object_fault,
|
|
TP_PROTO(struct drm_i915_gem_object *obj, u32 index, bool gtt, bool write),
|
|
TP_ARGS(obj, index, gtt, write),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
__field(u32, index)
|
|
__field(bool, gtt)
|
|
__field(bool, write)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->obj = obj;
|
|
__entry->index = index;
|
|
__entry->gtt = gtt;
|
|
__entry->write = write;
|
|
),
|
|
|
|
TP_printk("obj=%p, %s index=%u %s",
|
|
__entry->obj,
|
|
__entry->gtt ? "GTT" : "CPU",
|
|
__entry->index,
|
|
__entry->write ? ", writable" : "")
|
|
);
|
|
|
|
DECLARE_EVENT_CLASS(i915_gem_object,
|
|
TP_PROTO(struct drm_i915_gem_object *obj),
|
|
TP_ARGS(obj),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->obj = obj;
|
|
),
|
|
|
|
TP_printk("obj=%p", __entry->obj)
|
|
);
|
|
|
|
DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush,
|
|
TP_PROTO(struct drm_i915_gem_object *obj),
|
|
TP_ARGS(obj)
|
|
);
|
|
|
|
DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy,
|
|
TP_PROTO(struct drm_i915_gem_object *obj),
|
|
TP_ARGS(obj)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_evict,
|
|
TP_PROTO(struct drm_device *dev, u32 size, u32 align, unsigned flags),
|
|
TP_ARGS(dev, size, align, flags),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(u32, size)
|
|
__field(u32, align)
|
|
__field(unsigned, flags)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = dev->primary->index;
|
|
__entry->size = size;
|
|
__entry->align = align;
|
|
__entry->flags = flags;
|
|
),
|
|
|
|
TP_printk("dev=%d, size=%d, align=%d %s",
|
|
__entry->dev, __entry->size, __entry->align,
|
|
__entry->flags & PIN_MAPPABLE ? ", mappable" : "")
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_evict_everything,
|
|
TP_PROTO(struct drm_device *dev),
|
|
TP_ARGS(dev),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = dev->primary->index;
|
|
),
|
|
|
|
TP_printk("dev=%d", __entry->dev)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_evict_vm,
|
|
TP_PROTO(struct i915_address_space *vm),
|
|
TP_ARGS(vm),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(struct i915_address_space *, vm)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = vm->dev->primary->index;
|
|
__entry->vm = vm;
|
|
),
|
|
|
|
TP_printk("dev=%d, vm=%p", __entry->dev, __entry->vm)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_ring_sync_to,
|
|
TP_PROTO(struct intel_engine_cs *from,
|
|
struct intel_engine_cs *to,
|
|
u32 seqno),
|
|
TP_ARGS(from, to, seqno),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(u32, sync_from)
|
|
__field(u32, sync_to)
|
|
__field(u32, seqno)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = from->dev->primary->index;
|
|
__entry->sync_from = from->id;
|
|
__entry->sync_to = to->id;
|
|
__entry->seqno = seqno;
|
|
),
|
|
|
|
TP_printk("dev=%u, sync-from=%u, sync-to=%u, seqno=%u",
|
|
__entry->dev,
|
|
__entry->sync_from, __entry->sync_to,
|
|
__entry->seqno)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_ring_dispatch,
|
|
TP_PROTO(struct intel_engine_cs *ring, u32 seqno, u32 flags),
|
|
TP_ARGS(ring, seqno, flags),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(u32, ring)
|
|
__field(u32, seqno)
|
|
__field(u32, flags)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = ring->dev->primary->index;
|
|
__entry->ring = ring->id;
|
|
__entry->seqno = seqno;
|
|
__entry->flags = flags;
|
|
i915_trace_irq_get(ring, seqno);
|
|
),
|
|
|
|
TP_printk("dev=%u, ring=%u, seqno=%u, flags=%x",
|
|
__entry->dev, __entry->ring, __entry->seqno, __entry->flags)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_ring_flush,
|
|
TP_PROTO(struct intel_engine_cs *ring, u32 invalidate, u32 flush),
|
|
TP_ARGS(ring, invalidate, flush),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(u32, ring)
|
|
__field(u32, invalidate)
|
|
__field(u32, flush)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = ring->dev->primary->index;
|
|
__entry->ring = ring->id;
|
|
__entry->invalidate = invalidate;
|
|
__entry->flush = flush;
|
|
),
|
|
|
|
TP_printk("dev=%u, ring=%x, invalidate=%04x, flush=%04x",
|
|
__entry->dev, __entry->ring,
|
|
__entry->invalidate, __entry->flush)
|
|
);
|
|
|
|
DECLARE_EVENT_CLASS(i915_gem_request,
|
|
TP_PROTO(struct intel_engine_cs *ring, u32 seqno),
|
|
TP_ARGS(ring, seqno),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(u32, ring)
|
|
__field(u32, seqno)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = ring->dev->primary->index;
|
|
__entry->ring = ring->id;
|
|
__entry->seqno = seqno;
|
|
),
|
|
|
|
TP_printk("dev=%u, ring=%u, seqno=%u",
|
|
__entry->dev, __entry->ring, __entry->seqno)
|
|
);
|
|
|
|
DEFINE_EVENT(i915_gem_request, i915_gem_request_add,
|
|
TP_PROTO(struct intel_engine_cs *ring, u32 seqno),
|
|
TP_ARGS(ring, seqno)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_request_complete,
|
|
TP_PROTO(struct intel_engine_cs *ring),
|
|
TP_ARGS(ring),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(u32, ring)
|
|
__field(u32, seqno)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = ring->dev->primary->index;
|
|
__entry->ring = ring->id;
|
|
__entry->seqno = ring->get_seqno(ring, false);
|
|
),
|
|
|
|
TP_printk("dev=%u, ring=%u, seqno=%u",
|
|
__entry->dev, __entry->ring, __entry->seqno)
|
|
);
|
|
|
|
DEFINE_EVENT(i915_gem_request, i915_gem_request_retire,
|
|
TP_PROTO(struct intel_engine_cs *ring, u32 seqno),
|
|
TP_ARGS(ring, seqno)
|
|
);
|
|
|
|
TRACE_EVENT(i915_gem_request_wait_begin,
|
|
TP_PROTO(struct intel_engine_cs *ring, u32 seqno),
|
|
TP_ARGS(ring, seqno),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(u32, ring)
|
|
__field(u32, seqno)
|
|
__field(bool, blocking)
|
|
),
|
|
|
|
/* NB: the blocking information is racy since mutex_is_locked
|
|
* doesn't check that the current thread holds the lock. The only
|
|
* other option would be to pass the boolean information of whether
|
|
* or not the class was blocking down through the stack which is
|
|
* less desirable.
|
|
*/
|
|
TP_fast_assign(
|
|
__entry->dev = ring->dev->primary->index;
|
|
__entry->ring = ring->id;
|
|
__entry->seqno = seqno;
|
|
__entry->blocking = mutex_is_locked(&ring->dev->struct_mutex);
|
|
),
|
|
|
|
TP_printk("dev=%u, ring=%u, seqno=%u, blocking=%s",
|
|
__entry->dev, __entry->ring, __entry->seqno,
|
|
__entry->blocking ? "yes (NB)" : "no")
|
|
);
|
|
|
|
DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end,
|
|
TP_PROTO(struct intel_engine_cs *ring, u32 seqno),
|
|
TP_ARGS(ring, seqno)
|
|
);
|
|
|
|
DECLARE_EVENT_CLASS(i915_ring,
|
|
TP_PROTO(struct intel_engine_cs *ring),
|
|
TP_ARGS(ring),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, dev)
|
|
__field(u32, ring)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->dev = ring->dev->primary->index;
|
|
__entry->ring = ring->id;
|
|
),
|
|
|
|
TP_printk("dev=%u, ring=%u", __entry->dev, __entry->ring)
|
|
);
|
|
|
|
DEFINE_EVENT(i915_ring, i915_ring_wait_begin,
|
|
TP_PROTO(struct intel_engine_cs *ring),
|
|
TP_ARGS(ring)
|
|
);
|
|
|
|
DEFINE_EVENT(i915_ring, i915_ring_wait_end,
|
|
TP_PROTO(struct intel_engine_cs *ring),
|
|
TP_ARGS(ring)
|
|
);
|
|
|
|
TRACE_EVENT(i915_flip_request,
|
|
TP_PROTO(int plane, struct drm_i915_gem_object *obj),
|
|
|
|
TP_ARGS(plane, obj),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(int, plane)
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->plane = plane;
|
|
__entry->obj = obj;
|
|
),
|
|
|
|
TP_printk("plane=%d, obj=%p", __entry->plane, __entry->obj)
|
|
);
|
|
|
|
TRACE_EVENT(i915_flip_complete,
|
|
TP_PROTO(int plane, struct drm_i915_gem_object *obj),
|
|
|
|
TP_ARGS(plane, obj),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(int, plane)
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->plane = plane;
|
|
__entry->obj = obj;
|
|
),
|
|
|
|
TP_printk("plane=%d, obj=%p", __entry->plane, __entry->obj)
|
|
);
|
|
|
|
TRACE_EVENT_CONDITION(i915_reg_rw,
|
|
TP_PROTO(bool write, u32 reg, u64 val, int len, bool trace),
|
|
|
|
TP_ARGS(write, reg, val, len, trace),
|
|
|
|
TP_CONDITION(trace),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u64, val)
|
|
__field(u32, reg)
|
|
__field(u16, write)
|
|
__field(u16, len)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->val = (u64)val;
|
|
__entry->reg = reg;
|
|
__entry->write = write;
|
|
__entry->len = len;
|
|
),
|
|
|
|
TP_printk("%s reg=0x%x, len=%d, val=(0x%x, 0x%x)",
|
|
__entry->write ? "write" : "read",
|
|
__entry->reg, __entry->len,
|
|
(u32)(__entry->val & 0xffffffff),
|
|
(u32)(__entry->val >> 32))
|
|
);
|
|
|
|
TRACE_EVENT(intel_gpu_freq_change,
|
|
TP_PROTO(u32 freq),
|
|
TP_ARGS(freq),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(u32, freq)
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->freq = freq;
|
|
),
|
|
|
|
TP_printk("new_freq=%u", __entry->freq)
|
|
);
|
|
|
|
#endif /* _I915_TRACE_H_ */
|
|
|
|
/* This part must be outside protection */
|
|
#undef TRACE_INCLUDE_PATH
|
|
#define TRACE_INCLUDE_PATH .
|
|
#include <trace/define_trace.h>
|