License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2009-08-25 10:15:50 +00:00
|
|
|
#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>
|
|
|
|
|
|
2019-01-17 21:03:34 +00:00
|
|
|
#include <drm/drm_drv.h>
|
|
|
|
|
|
2021-04-27 12:03:15 +00:00
|
|
|
#include "display/intel_crtc.h"
|
2019-08-06 11:39:33 +00:00
|
|
|
#include "display/intel_display_types.h"
|
2019-04-24 17:48:39 +00:00
|
|
|
#include "gt/intel_engine.h"
|
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
#include "i915_drv.h"
|
2019-04-29 12:29:27 +00:00
|
|
|
#include "i915_irq.h"
|
2009-08-25 10:15:50 +00:00
|
|
|
|
|
|
|
|
#undef TRACE_SYSTEM
|
|
|
|
|
#define TRACE_SYSTEM i915
|
|
|
|
|
#define TRACE_INCLUDE_FILE i915_trace
|
|
|
|
|
|
2017-03-02 17:15:06 +00:00
|
|
|
/* watermark/fifo updates */
|
|
|
|
|
|
2019-02-06 20:49:08 +00:00
|
|
|
TRACE_EVENT(intel_pipe_enable,
|
2019-06-19 17:08:39 +00:00
|
|
|
TP_PROTO(struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(crtc),
|
2019-02-06 20:49:08 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__array(u32, frame, 3)
|
|
|
|
|
__array(u32, scanline, 3)
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
),
|
|
|
|
|
TP_fast_assign(
|
2019-06-19 17:08:39 +00:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
|
|
|
|
|
struct intel_crtc *it__;
|
|
|
|
|
for_each_intel_crtc(&dev_priv->drm, it__) {
|
|
|
|
|
__entry->frame[it__->pipe] = intel_crtc_get_vblank_counter(it__);
|
|
|
|
|
__entry->scanline[it__->pipe] = intel_get_crtc_scanline(it__);
|
2019-02-06 20:49:08 +00:00
|
|
|
}
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->pipe = crtc->pipe;
|
2019-02-06 20:49:08 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c enable, pipe A: frame=%u, scanline=%u, pipe B: frame=%u, scanline=%u, pipe C: frame=%u, scanline=%u",
|
|
|
|
|
pipe_name(__entry->pipe),
|
|
|
|
|
__entry->frame[PIPE_A], __entry->scanline[PIPE_A],
|
|
|
|
|
__entry->frame[PIPE_B], __entry->scanline[PIPE_B],
|
|
|
|
|
__entry->frame[PIPE_C], __entry->scanline[PIPE_C])
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_pipe_disable,
|
2019-06-19 17:08:39 +00:00
|
|
|
TP_PROTO(struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(crtc),
|
2019-02-06 20:49:08 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__array(u32, frame, 3)
|
|
|
|
|
__array(u32, scanline, 3)
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2019-06-19 17:08:39 +00:00
|
|
|
struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
|
|
|
|
|
struct intel_crtc *it__;
|
|
|
|
|
for_each_intel_crtc(&dev_priv->drm, it__) {
|
|
|
|
|
__entry->frame[it__->pipe] = intel_crtc_get_vblank_counter(it__);
|
|
|
|
|
__entry->scanline[it__->pipe] = intel_get_crtc_scanline(it__);
|
2019-02-06 20:49:08 +00:00
|
|
|
}
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->pipe = crtc->pipe;
|
2019-02-06 20:49:08 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c disable, pipe A: frame=%u, scanline=%u, pipe B: frame=%u, scanline=%u, pipe C: frame=%u, scanline=%u",
|
|
|
|
|
pipe_name(__entry->pipe),
|
|
|
|
|
__entry->frame[PIPE_A], __entry->scanline[PIPE_A],
|
|
|
|
|
__entry->frame[PIPE_B], __entry->scanline[PIPE_B],
|
|
|
|
|
__entry->frame[PIPE_C], __entry->scanline[PIPE_C])
|
|
|
|
|
);
|
|
|
|
|
|
2019-02-06 20:49:07 +00:00
|
|
|
TRACE_EVENT(intel_pipe_crc,
|
|
|
|
|
TP_PROTO(struct intel_crtc *crtc, const u32 *crcs),
|
|
|
|
|
TP_ARGS(crtc, crcs),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
__array(u32, crcs, 5)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pipe = crtc->pipe;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
2019-02-06 20:49:07 +00:00
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
memcpy(__entry->crcs, crcs, sizeof(__entry->crcs));
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u crc=%08x %08x %08x %08x %08x",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame, __entry->scanline,
|
|
|
|
|
__entry->crcs[0], __entry->crcs[1], __entry->crcs[2],
|
|
|
|
|
__entry->crcs[3], __entry->crcs[4])
|
|
|
|
|
);
|
|
|
|
|
|
2017-03-02 17:15:08 +00:00
|
|
|
TRACE_EVENT(intel_cpu_fifo_underrun,
|
|
|
|
|
TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe),
|
|
|
|
|
TP_ARGS(dev_priv, pipe),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2019-06-19 17:08:39 +00:00
|
|
|
struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv, pipe);
|
2017-03-02 17:15:08 +00:00
|
|
|
__entry->pipe = pipe;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
|
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
2017-03-02 17:15:08 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u",
|
|
|
|
|
pipe_name(__entry->pipe),
|
|
|
|
|
__entry->frame, __entry->scanline)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_pch_fifo_underrun,
|
2017-09-01 14:31:23 +00:00
|
|
|
TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder),
|
2017-03-02 17:15:08 +00:00
|
|
|
TP_ARGS(dev_priv, pch_transcoder),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2017-09-01 14:31:23 +00:00
|
|
|
enum pipe pipe = pch_transcoder;
|
2019-06-19 17:08:39 +00:00
|
|
|
struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv, pipe);
|
2017-03-02 17:15:08 +00:00
|
|
|
__entry->pipe = pipe;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
|
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
2017-03-02 17:15:08 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pch transcoder %c, frame=%u, scanline=%u",
|
|
|
|
|
pipe_name(__entry->pipe),
|
|
|
|
|
__entry->frame, __entry->scanline)
|
|
|
|
|
);
|
|
|
|
|
|
2017-03-02 17:15:07 +00:00
|
|
|
TRACE_EVENT(intel_memory_cxsr,
|
|
|
|
|
TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new),
|
|
|
|
|
TP_ARGS(dev_priv, old, new),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__array(u32, frame, 3)
|
|
|
|
|
__array(u32, scanline, 3)
|
|
|
|
|
__field(bool, old)
|
|
|
|
|
__field(bool, new)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2019-06-19 17:08:39 +00:00
|
|
|
struct intel_crtc *crtc;
|
|
|
|
|
for_each_intel_crtc(&dev_priv->drm, crtc) {
|
|
|
|
|
__entry->frame[crtc->pipe] = intel_crtc_get_vblank_counter(crtc);
|
|
|
|
|
__entry->scanline[crtc->pipe] = intel_get_crtc_scanline(crtc);
|
2017-03-02 17:15:07 +00:00
|
|
|
}
|
|
|
|
|
__entry->old = old;
|
|
|
|
|
__entry->new = new;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("%s->%s, pipe A: frame=%u, scanline=%u, pipe B: frame=%u, scanline=%u, pipe C: frame=%u, scanline=%u",
|
|
|
|
|
onoff(__entry->old), onoff(__entry->new),
|
|
|
|
|
__entry->frame[PIPE_A], __entry->scanline[PIPE_A],
|
|
|
|
|
__entry->frame[PIPE_B], __entry->scanline[PIPE_B],
|
|
|
|
|
__entry->frame[PIPE_C], __entry->scanline[PIPE_C])
|
|
|
|
|
);
|
|
|
|
|
|
2017-04-21 18:14:31 +00:00
|
|
|
TRACE_EVENT(g4x_wm,
|
|
|
|
|
TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm),
|
|
|
|
|
TP_ARGS(crtc, wm),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
__field(u16, primary)
|
|
|
|
|
__field(u16, sprite)
|
|
|
|
|
__field(u16, cursor)
|
|
|
|
|
__field(u16, sr_plane)
|
|
|
|
|
__field(u16, sr_cursor)
|
|
|
|
|
__field(u16, sr_fbc)
|
|
|
|
|
__field(u16, hpll_plane)
|
|
|
|
|
__field(u16, hpll_cursor)
|
|
|
|
|
__field(u16, hpll_fbc)
|
|
|
|
|
__field(bool, cxsr)
|
|
|
|
|
__field(bool, hpll)
|
|
|
|
|
__field(bool, fbc)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pipe = crtc->pipe;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
2017-04-21 18:14:31 +00:00
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
__entry->primary = wm->pipe[crtc->pipe].plane[PLANE_PRIMARY];
|
|
|
|
|
__entry->sprite = wm->pipe[crtc->pipe].plane[PLANE_SPRITE0];
|
|
|
|
|
__entry->cursor = wm->pipe[crtc->pipe].plane[PLANE_CURSOR];
|
|
|
|
|
__entry->sr_plane = wm->sr.plane;
|
|
|
|
|
__entry->sr_cursor = wm->sr.cursor;
|
|
|
|
|
__entry->sr_fbc = wm->sr.fbc;
|
|
|
|
|
__entry->hpll_plane = wm->hpll.plane;
|
|
|
|
|
__entry->hpll_cursor = wm->hpll.cursor;
|
|
|
|
|
__entry->hpll_fbc = wm->hpll.fbc;
|
|
|
|
|
__entry->cxsr = wm->cxsr;
|
|
|
|
|
__entry->hpll = wm->hpll_en;
|
|
|
|
|
__entry->fbc = wm->fbc_en;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u, wm %d/%d/%d, sr %s/%d/%d/%d, hpll %s/%d/%d/%d, fbc %s",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame, __entry->scanline,
|
|
|
|
|
__entry->primary, __entry->sprite, __entry->cursor,
|
|
|
|
|
yesno(__entry->cxsr), __entry->sr_plane, __entry->sr_cursor, __entry->sr_fbc,
|
|
|
|
|
yesno(__entry->hpll), __entry->hpll_plane, __entry->hpll_cursor, __entry->hpll_fbc,
|
|
|
|
|
yesno(__entry->fbc))
|
|
|
|
|
);
|
|
|
|
|
|
2017-03-02 17:15:06 +00:00
|
|
|
TRACE_EVENT(vlv_wm,
|
|
|
|
|
TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm),
|
|
|
|
|
TP_ARGS(crtc, wm),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
__field(u32, level)
|
|
|
|
|
__field(u32, cxsr)
|
|
|
|
|
__field(u32, primary)
|
|
|
|
|
__field(u32, sprite0)
|
|
|
|
|
__field(u32, sprite1)
|
|
|
|
|
__field(u32, cursor)
|
|
|
|
|
__field(u32, sr_plane)
|
|
|
|
|
__field(u32, sr_cursor)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pipe = crtc->pipe;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
2017-03-02 17:15:06 +00:00
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
__entry->level = wm->level;
|
|
|
|
|
__entry->cxsr = wm->cxsr;
|
|
|
|
|
__entry->primary = wm->pipe[crtc->pipe].plane[PLANE_PRIMARY];
|
|
|
|
|
__entry->sprite0 = wm->pipe[crtc->pipe].plane[PLANE_SPRITE0];
|
|
|
|
|
__entry->sprite1 = wm->pipe[crtc->pipe].plane[PLANE_SPRITE1];
|
|
|
|
|
__entry->cursor = wm->pipe[crtc->pipe].plane[PLANE_CURSOR];
|
|
|
|
|
__entry->sr_plane = wm->sr.plane;
|
|
|
|
|
__entry->sr_cursor = wm->sr.cursor;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u, level=%d, cxsr=%d, wm %d/%d/%d/%d, sr %d/%d",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame,
|
|
|
|
|
__entry->scanline, __entry->level, __entry->cxsr,
|
|
|
|
|
__entry->primary, __entry->sprite0, __entry->sprite1, __entry->cursor,
|
|
|
|
|
__entry->sr_plane, __entry->sr_cursor)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(vlv_fifo_size,
|
|
|
|
|
TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size),
|
|
|
|
|
TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
__field(u32, sprite0_start)
|
|
|
|
|
__field(u32, sprite1_start)
|
|
|
|
|
__field(u32, fifo_size)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pipe = crtc->pipe;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
2017-03-02 17:15:06 +00:00
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
__entry->sprite0_start = sprite0_start;
|
|
|
|
|
__entry->sprite1_start = sprite1_start;
|
|
|
|
|
__entry->fifo_size = fifo_size;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u, %d/%d/%d",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame,
|
|
|
|
|
__entry->scanline, __entry->sprite0_start,
|
|
|
|
|
__entry->sprite1_start, __entry->fifo_size)
|
|
|
|
|
);
|
|
|
|
|
|
2017-03-02 17:15:05 +00:00
|
|
|
/* plane updates */
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_update_plane,
|
|
|
|
|
TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(plane, crtc),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
__array(int, src, 4)
|
|
|
|
|
__array(int, dst, 4)
|
2019-07-10 17:12:30 +00:00
|
|
|
__string(name, plane->name)
|
2017-03-02 17:15:05 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2019-07-10 17:12:30 +00:00
|
|
|
__assign_str(name, plane->name);
|
2017-03-02 17:15:05 +00:00
|
|
|
__entry->pipe = crtc->pipe;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
2017-03-02 17:15:05 +00:00
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
memcpy(__entry->src, &plane->state->src, sizeof(__entry->src));
|
|
|
|
|
memcpy(__entry->dst, &plane->state->dst, sizeof(__entry->dst));
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, plane %s, frame=%u, scanline=%u, " DRM_RECT_FP_FMT " -> " DRM_RECT_FMT,
|
2019-07-10 17:12:30 +00:00
|
|
|
pipe_name(__entry->pipe), __get_str(name),
|
2017-03-02 17:15:05 +00:00
|
|
|
__entry->frame, __entry->scanline,
|
|
|
|
|
DRM_RECT_FP_ARG((const struct drm_rect *)__entry->src),
|
|
|
|
|
DRM_RECT_ARG((const struct drm_rect *)__entry->dst))
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_disable_plane,
|
|
|
|
|
TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(plane, crtc),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
2019-07-10 17:12:30 +00:00
|
|
|
__string(name, plane->name)
|
2017-03-02 17:15:05 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2019-07-10 17:12:30 +00:00
|
|
|
__assign_str(name, plane->name);
|
2017-03-02 17:15:05 +00:00
|
|
|
__entry->pipe = crtc->pipe;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
2017-03-02 17:15:05 +00:00
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, plane %s, frame=%u, scanline=%u",
|
2019-07-10 17:12:30 +00:00
|
|
|
pipe_name(__entry->pipe), __get_str(name),
|
2017-03-02 17:15:05 +00:00
|
|
|
__entry->frame, __entry->scanline)
|
|
|
|
|
);
|
|
|
|
|
|
2019-12-13 13:34:52 +00:00
|
|
|
/* fbc */
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_fbc_activate,
|
|
|
|
|
TP_PROTO(struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(crtc),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pipe = crtc->pipe;
|
|
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
|
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame, __entry->scanline)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_fbc_deactivate,
|
|
|
|
|
TP_PROTO(struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(crtc),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pipe = crtc->pipe;
|
|
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
|
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame, __entry->scanline)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_fbc_nuke,
|
|
|
|
|
TP_PROTO(struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(crtc),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pipe = crtc->pipe;
|
|
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
|
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame, __entry->scanline)
|
|
|
|
|
);
|
|
|
|
|
|
2014-04-29 10:35:48 +00:00
|
|
|
/* pipe updates */
|
|
|
|
|
|
2019-12-13 13:34:53 +00:00
|
|
|
TRACE_EVENT(intel_pipe_update_start,
|
2015-09-17 15:08:32 +00:00
|
|
|
TP_PROTO(struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(crtc),
|
2014-04-29 10:35:48 +00:00
|
|
|
|
|
|
|
|
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;
|
2019-06-19 17:08:39 +00:00
|
|
|
__entry->frame = intel_crtc_get_vblank_counter(crtc);
|
2014-04-29 10:35:48 +00:00
|
|
|
__entry->scanline = intel_get_crtc_scanline(crtc);
|
2015-09-17 15:08:32 +00:00
|
|
|
__entry->min = crtc->debug.min_vbl;
|
|
|
|
|
__entry->max = crtc->debug.max_vbl;
|
2014-04-29 10:35:48 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u, min=%u, max=%u",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame,
|
|
|
|
|
__entry->scanline, __entry->min, __entry->max)
|
|
|
|
|
);
|
|
|
|
|
|
2019-12-13 13:34:53 +00:00
|
|
|
TRACE_EVENT(intel_pipe_update_vblank_evaded,
|
2015-09-17 15:08:32 +00:00
|
|
|
TP_PROTO(struct intel_crtc *crtc),
|
|
|
|
|
TP_ARGS(crtc),
|
2014-04-29 10:35:48 +00:00
|
|
|
|
|
|
|
|
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;
|
2015-09-17 15:08:32 +00:00
|
|
|
__entry->frame = crtc->debug.start_vbl_count;
|
|
|
|
|
__entry->scanline = crtc->debug.scanline_start;
|
|
|
|
|
__entry->min = crtc->debug.min_vbl;
|
|
|
|
|
__entry->max = crtc->debug.max_vbl;
|
2014-04-29 10:35:48 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u, min=%u, max=%u",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame,
|
|
|
|
|
__entry->scanline, __entry->min, __entry->max)
|
|
|
|
|
);
|
|
|
|
|
|
2019-12-13 13:34:53 +00:00
|
|
|
TRACE_EVENT(intel_pipe_update_end,
|
2015-09-17 15:08:32 +00:00
|
|
|
TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end),
|
|
|
|
|
TP_ARGS(crtc, frame, scanline_end),
|
2014-04-29 10:35:48 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(enum pipe, pipe)
|
|
|
|
|
__field(u32, frame)
|
|
|
|
|
__field(u32, scanline)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pipe = crtc->pipe;
|
|
|
|
|
__entry->frame = frame;
|
2015-09-17 15:08:32 +00:00
|
|
|
__entry->scanline = scanline_end;
|
2014-04-29 10:35:48 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pipe %c, frame=%u, scanline=%u",
|
|
|
|
|
pipe_name(__entry->pipe), __entry->frame,
|
|
|
|
|
__entry->scanline)
|
|
|
|
|
);
|
|
|
|
|
|
2021-04-14 02:23:02 +00:00
|
|
|
/* frontbuffer tracking */
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_frontbuffer_invalidate,
|
|
|
|
|
TP_PROTO(unsigned int frontbuffer_bits, unsigned int origin),
|
|
|
|
|
TP_ARGS(frontbuffer_bits, origin),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(unsigned int, frontbuffer_bits)
|
|
|
|
|
__field(unsigned int, origin)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->frontbuffer_bits = frontbuffer_bits;
|
|
|
|
|
__entry->origin = origin;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("frontbuffer_bits=0x%08x, origin=%u",
|
|
|
|
|
__entry->frontbuffer_bits, __entry->origin)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(intel_frontbuffer_flush,
|
|
|
|
|
TP_PROTO(unsigned int frontbuffer_bits, unsigned int origin),
|
|
|
|
|
TP_ARGS(frontbuffer_bits, origin),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(unsigned int, frontbuffer_bits)
|
|
|
|
|
__field(unsigned int, origin)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->frontbuffer_bits = frontbuffer_bits;
|
|
|
|
|
__entry->origin = origin;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("frontbuffer_bits=0x%08x, origin=%u",
|
|
|
|
|
__entry->frontbuffer_bits, __entry->origin)
|
|
|
|
|
);
|
|
|
|
|
|
2009-08-25 10:15:50 +00:00
|
|
|
/* object tracking */
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(i915_gem_object_create,
|
2010-11-08 19:18:58 +00:00
|
|
|
TP_PROTO(struct drm_i915_gem_object *obj),
|
2009-08-25 10:15:50 +00:00
|
|
|
TP_ARGS(obj),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
2010-11-08 19:18:58 +00:00
|
|
|
__field(struct drm_i915_gem_object *, obj)
|
2017-10-03 12:50:54 +00:00
|
|
|
__field(u64, size)
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->obj = obj;
|
2010-11-08 19:18:58 +00:00
|
|
|
__entry->size = obj->base.size;
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_printk("obj=%p, size=0x%llx", __entry->obj, __entry->size)
|
2009-08-25 10:15:50 +00:00
|
|
|
);
|
|
|
|
|
|
2015-10-01 11:18:26 +00:00
|
|
|
TRACE_EVENT(i915_gem_shrink,
|
|
|
|
|
TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags),
|
|
|
|
|
TP_ARGS(i915, target, flags),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(int, dev)
|
|
|
|
|
__field(unsigned long, target)
|
|
|
|
|
__field(unsigned, flags)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2016-07-05 09:40:23 +00:00
|
|
|
__entry->dev = i915->drm.primary->index;
|
2015-10-01 11:18:26 +00:00
|
|
|
__entry->target = target;
|
|
|
|
|
__entry->flags = flags;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("dev=%d, target=%lu, flags=%x",
|
|
|
|
|
__entry->dev, __entry->target, __entry->flags)
|
|
|
|
|
);
|
|
|
|
|
|
drm/i915: plumb VM into bind/unbind code
As alluded to in several patches, and it will be reiterated later... A
VMA is an abstraction for a GEM BO bound into an address space.
Therefore it stands to reason, that the existing bind, and unbind are
the ones which will be the most impacted. This patch implements this,
and updates all callers which weren't already updated in the series
(because it was too messy).
This patch represents the bulk of an earlier, larger patch. I've pulled
out a bunch of things by the request of Daniel. The history is preserved
for posterity with the email convention of ">" One big change from the
original patch aside from a bunch of cropping is I've created an
i915_vma_unbind() function. That is because we always have the VMA
anyway, and doing an extra lookup is useful. There is a caveat, we
retain an i915_gem_object_ggtt_unbind, for the global cases which might
not talk in VMAs.
> drm/i915: plumb VM into object operations
>
> This patch was formerly known as:
> "drm/i915: Create VMAs (part 3) - plumbing"
>
> This patch adds a VM argument, bind/unbind, and the object
> offset/size/color getters/setters. It preserves the old ggtt helper
> functions because things still need, and will continue to need them.
>
> Some code will still need to be ported over after this.
>
> v2: Fix purge to pick an object and unbind all vmas
> This was doable because of the global bound list change.
>
> v3: With the commit to actually pin/unpin pages in place, there is no
> longer a need to check if unbind succeeded before calling put_pages().
> Make put_pages only BUG() after checking pin count.
>
> v4: Rebased on top of the new hangcheck work by Mika
> plumbed eb_destroy also
> Many checkpatch related fixes
>
> v5: Very large rebase
>
> v6:
> Change BUG_ON to WARN_ON (Daniel)
> Rename vm to ggtt in preallocate stolen, since it is always ggtt when
> dealing with stolen memory. (Daniel)
> list_for_each will short-circuit already (Daniel)
> remove superflous space (Daniel)
> Use per object list of vmas (Daniel)
> Make obj_bound_any() use obj_bound for each vm (Ben)
> s/bind_to_gtt/bind_to_vm/ (Ben)
>
> Fixed up the inactive shrinker. As Daniel noticed the code could
> potentially count the same object multiple times. While it's not
> possible in the current case, since 1 object can only ever be bound into
> 1 address space thus far - we may as well try to get something more
> future proof in place now. With a prep patch before this to switch over
> to using the bound list + inactive check, we're now able to carry that
> forward for every address space an object is bound into.
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
[danvet: Rebase on top of the loss of "drm/i915: Cleanup more of VMA
in destroy".]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-08-01 00:00:10 +00:00
|
|
|
TRACE_EVENT(i915_vma_bind,
|
2014-02-14 13:01:11 +00:00
|
|
|
TP_PROTO(struct i915_vma *vma, unsigned flags),
|
|
|
|
|
TP_ARGS(vma, flags),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
2010-11-08 19:18:58 +00:00
|
|
|
__field(struct drm_i915_gem_object *, obj)
|
drm/i915: plumb VM into bind/unbind code
As alluded to in several patches, and it will be reiterated later... A
VMA is an abstraction for a GEM BO bound into an address space.
Therefore it stands to reason, that the existing bind, and unbind are
the ones which will be the most impacted. This patch implements this,
and updates all callers which weren't already updated in the series
(because it was too messy).
This patch represents the bulk of an earlier, larger patch. I've pulled
out a bunch of things by the request of Daniel. The history is preserved
for posterity with the email convention of ">" One big change from the
original patch aside from a bunch of cropping is I've created an
i915_vma_unbind() function. That is because we always have the VMA
anyway, and doing an extra lookup is useful. There is a caveat, we
retain an i915_gem_object_ggtt_unbind, for the global cases which might
not talk in VMAs.
> drm/i915: plumb VM into object operations
>
> This patch was formerly known as:
> "drm/i915: Create VMAs (part 3) - plumbing"
>
> This patch adds a VM argument, bind/unbind, and the object
> offset/size/color getters/setters. It preserves the old ggtt helper
> functions because things still need, and will continue to need them.
>
> Some code will still need to be ported over after this.
>
> v2: Fix purge to pick an object and unbind all vmas
> This was doable because of the global bound list change.
>
> v3: With the commit to actually pin/unpin pages in place, there is no
> longer a need to check if unbind succeeded before calling put_pages().
> Make put_pages only BUG() after checking pin count.
>
> v4: Rebased on top of the new hangcheck work by Mika
> plumbed eb_destroy also
> Many checkpatch related fixes
>
> v5: Very large rebase
>
> v6:
> Change BUG_ON to WARN_ON (Daniel)
> Rename vm to ggtt in preallocate stolen, since it is always ggtt when
> dealing with stolen memory. (Daniel)
> list_for_each will short-circuit already (Daniel)
> remove superflous space (Daniel)
> Use per object list of vmas (Daniel)
> Make obj_bound_any() use obj_bound for each vm (Ben)
> s/bind_to_gtt/bind_to_vm/ (Ben)
>
> Fixed up the inactive shrinker. As Daniel noticed the code could
> potentially count the same object multiple times. While it's not
> possible in the current case, since 1 object can only ever be bound into
> 1 address space thus far - we may as well try to get something more
> future proof in place now. With a prep patch before this to switch over
> to using the bound list + inactive check, we're now able to carry that
> forward for every address space an object is bound into.
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
[danvet: Rebase on top of the loss of "drm/i915: Cleanup more of VMA
in destroy".]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-08-01 00:00:10 +00:00
|
|
|
__field(struct i915_address_space *, vm)
|
2015-01-22 17:01:23 +00:00
|
|
|
__field(u64, offset)
|
2017-10-03 12:50:54 +00:00
|
|
|
__field(u64, size)
|
2014-02-14 13:01:11 +00:00
|
|
|
__field(unsigned, flags)
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
drm/i915: plumb VM into bind/unbind code
As alluded to in several patches, and it will be reiterated later... A
VMA is an abstraction for a GEM BO bound into an address space.
Therefore it stands to reason, that the existing bind, and unbind are
the ones which will be the most impacted. This patch implements this,
and updates all callers which weren't already updated in the series
(because it was too messy).
This patch represents the bulk of an earlier, larger patch. I've pulled
out a bunch of things by the request of Daniel. The history is preserved
for posterity with the email convention of ">" One big change from the
original patch aside from a bunch of cropping is I've created an
i915_vma_unbind() function. That is because we always have the VMA
anyway, and doing an extra lookup is useful. There is a caveat, we
retain an i915_gem_object_ggtt_unbind, for the global cases which might
not talk in VMAs.
> drm/i915: plumb VM into object operations
>
> This patch was formerly known as:
> "drm/i915: Create VMAs (part 3) - plumbing"
>
> This patch adds a VM argument, bind/unbind, and the object
> offset/size/color getters/setters. It preserves the old ggtt helper
> functions because things still need, and will continue to need them.
>
> Some code will still need to be ported over after this.
>
> v2: Fix purge to pick an object and unbind all vmas
> This was doable because of the global bound list change.
>
> v3: With the commit to actually pin/unpin pages in place, there is no
> longer a need to check if unbind succeeded before calling put_pages().
> Make put_pages only BUG() after checking pin count.
>
> v4: Rebased on top of the new hangcheck work by Mika
> plumbed eb_destroy also
> Many checkpatch related fixes
>
> v5: Very large rebase
>
> v6:
> Change BUG_ON to WARN_ON (Daniel)
> Rename vm to ggtt in preallocate stolen, since it is always ggtt when
> dealing with stolen memory. (Daniel)
> list_for_each will short-circuit already (Daniel)
> remove superflous space (Daniel)
> Use per object list of vmas (Daniel)
> Make obj_bound_any() use obj_bound for each vm (Ben)
> s/bind_to_gtt/bind_to_vm/ (Ben)
>
> Fixed up the inactive shrinker. As Daniel noticed the code could
> potentially count the same object multiple times. While it's not
> possible in the current case, since 1 object can only ever be bound into
> 1 address space thus far - we may as well try to get something more
> future proof in place now. With a prep patch before this to switch over
> to using the bound list + inactive check, we're now able to carry that
> forward for every address space an object is bound into.
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
[danvet: Rebase on top of the loss of "drm/i915: Cleanup more of VMA
in destroy".]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-08-01 00:00:10 +00:00
|
|
|
__entry->obj = vma->obj;
|
|
|
|
|
__entry->vm = vma->vm;
|
|
|
|
|
__entry->offset = vma->node.start;
|
|
|
|
|
__entry->size = vma->node.size;
|
2014-02-14 13:01:11 +00:00
|
|
|
__entry->flags = flags;
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_printk("obj=%p, offset=0x%016llx size=0x%llx%s vm=%p",
|
2011-02-03 11:57:46 +00:00
|
|
|
__entry->obj, __entry->offset, __entry->size,
|
2014-02-14 13:01:11 +00:00
|
|
|
__entry->flags & PIN_MAPPABLE ? ", mappable" : "",
|
drm/i915: plumb VM into bind/unbind code
As alluded to in several patches, and it will be reiterated later... A
VMA is an abstraction for a GEM BO bound into an address space.
Therefore it stands to reason, that the existing bind, and unbind are
the ones which will be the most impacted. This patch implements this,
and updates all callers which weren't already updated in the series
(because it was too messy).
This patch represents the bulk of an earlier, larger patch. I've pulled
out a bunch of things by the request of Daniel. The history is preserved
for posterity with the email convention of ">" One big change from the
original patch aside from a bunch of cropping is I've created an
i915_vma_unbind() function. That is because we always have the VMA
anyway, and doing an extra lookup is useful. There is a caveat, we
retain an i915_gem_object_ggtt_unbind, for the global cases which might
not talk in VMAs.
> drm/i915: plumb VM into object operations
>
> This patch was formerly known as:
> "drm/i915: Create VMAs (part 3) - plumbing"
>
> This patch adds a VM argument, bind/unbind, and the object
> offset/size/color getters/setters. It preserves the old ggtt helper
> functions because things still need, and will continue to need them.
>
> Some code will still need to be ported over after this.
>
> v2: Fix purge to pick an object and unbind all vmas
> This was doable because of the global bound list change.
>
> v3: With the commit to actually pin/unpin pages in place, there is no
> longer a need to check if unbind succeeded before calling put_pages().
> Make put_pages only BUG() after checking pin count.
>
> v4: Rebased on top of the new hangcheck work by Mika
> plumbed eb_destroy also
> Many checkpatch related fixes
>
> v5: Very large rebase
>
> v6:
> Change BUG_ON to WARN_ON (Daniel)
> Rename vm to ggtt in preallocate stolen, since it is always ggtt when
> dealing with stolen memory. (Daniel)
> list_for_each will short-circuit already (Daniel)
> remove superflous space (Daniel)
> Use per object list of vmas (Daniel)
> Make obj_bound_any() use obj_bound for each vm (Ben)
> s/bind_to_gtt/bind_to_vm/ (Ben)
>
> Fixed up the inactive shrinker. As Daniel noticed the code could
> potentially count the same object multiple times. While it's not
> possible in the current case, since 1 object can only ever be bound into
> 1 address space thus far - we may as well try to get something more
> future proof in place now. With a prep patch before this to switch over
> to using the bound list + inactive check, we're now able to carry that
> forward for every address space an object is bound into.
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
[danvet: Rebase on top of the loss of "drm/i915: Cleanup more of VMA
in destroy".]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-08-01 00:00:10 +00:00
|
|
|
__entry->vm)
|
2009-08-25 10:15:50 +00:00
|
|
|
);
|
|
|
|
|
|
drm/i915: plumb VM into bind/unbind code
As alluded to in several patches, and it will be reiterated later... A
VMA is an abstraction for a GEM BO bound into an address space.
Therefore it stands to reason, that the existing bind, and unbind are
the ones which will be the most impacted. This patch implements this,
and updates all callers which weren't already updated in the series
(because it was too messy).
This patch represents the bulk of an earlier, larger patch. I've pulled
out a bunch of things by the request of Daniel. The history is preserved
for posterity with the email convention of ">" One big change from the
original patch aside from a bunch of cropping is I've created an
i915_vma_unbind() function. That is because we always have the VMA
anyway, and doing an extra lookup is useful. There is a caveat, we
retain an i915_gem_object_ggtt_unbind, for the global cases which might
not talk in VMAs.
> drm/i915: plumb VM into object operations
>
> This patch was formerly known as:
> "drm/i915: Create VMAs (part 3) - plumbing"
>
> This patch adds a VM argument, bind/unbind, and the object
> offset/size/color getters/setters. It preserves the old ggtt helper
> functions because things still need, and will continue to need them.
>
> Some code will still need to be ported over after this.
>
> v2: Fix purge to pick an object and unbind all vmas
> This was doable because of the global bound list change.
>
> v3: With the commit to actually pin/unpin pages in place, there is no
> longer a need to check if unbind succeeded before calling put_pages().
> Make put_pages only BUG() after checking pin count.
>
> v4: Rebased on top of the new hangcheck work by Mika
> plumbed eb_destroy also
> Many checkpatch related fixes
>
> v5: Very large rebase
>
> v6:
> Change BUG_ON to WARN_ON (Daniel)
> Rename vm to ggtt in preallocate stolen, since it is always ggtt when
> dealing with stolen memory. (Daniel)
> list_for_each will short-circuit already (Daniel)
> remove superflous space (Daniel)
> Use per object list of vmas (Daniel)
> Make obj_bound_any() use obj_bound for each vm (Ben)
> s/bind_to_gtt/bind_to_vm/ (Ben)
>
> Fixed up the inactive shrinker. As Daniel noticed the code could
> potentially count the same object multiple times. While it's not
> possible in the current case, since 1 object can only ever be bound into
> 1 address space thus far - we may as well try to get something more
> future proof in place now. With a prep patch before this to switch over
> to using the bound list + inactive check, we're now able to carry that
> forward for every address space an object is bound into.
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
[danvet: Rebase on top of the loss of "drm/i915: Cleanup more of VMA
in destroy".]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-08-01 00:00:10 +00:00
|
|
|
TRACE_EVENT(i915_vma_unbind,
|
|
|
|
|
TP_PROTO(struct i915_vma *vma),
|
|
|
|
|
TP_ARGS(vma),
|
2011-02-03 11:57:46 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(struct drm_i915_gem_object *, obj)
|
drm/i915: plumb VM into bind/unbind code
As alluded to in several patches, and it will be reiterated later... A
VMA is an abstraction for a GEM BO bound into an address space.
Therefore it stands to reason, that the existing bind, and unbind are
the ones which will be the most impacted. This patch implements this,
and updates all callers which weren't already updated in the series
(because it was too messy).
This patch represents the bulk of an earlier, larger patch. I've pulled
out a bunch of things by the request of Daniel. The history is preserved
for posterity with the email convention of ">" One big change from the
original patch aside from a bunch of cropping is I've created an
i915_vma_unbind() function. That is because we always have the VMA
anyway, and doing an extra lookup is useful. There is a caveat, we
retain an i915_gem_object_ggtt_unbind, for the global cases which might
not talk in VMAs.
> drm/i915: plumb VM into object operations
>
> This patch was formerly known as:
> "drm/i915: Create VMAs (part 3) - plumbing"
>
> This patch adds a VM argument, bind/unbind, and the object
> offset/size/color getters/setters. It preserves the old ggtt helper
> functions because things still need, and will continue to need them.
>
> Some code will still need to be ported over after this.
>
> v2: Fix purge to pick an object and unbind all vmas
> This was doable because of the global bound list change.
>
> v3: With the commit to actually pin/unpin pages in place, there is no
> longer a need to check if unbind succeeded before calling put_pages().
> Make put_pages only BUG() after checking pin count.
>
> v4: Rebased on top of the new hangcheck work by Mika
> plumbed eb_destroy also
> Many checkpatch related fixes
>
> v5: Very large rebase
>
> v6:
> Change BUG_ON to WARN_ON (Daniel)
> Rename vm to ggtt in preallocate stolen, since it is always ggtt when
> dealing with stolen memory. (Daniel)
> list_for_each will short-circuit already (Daniel)
> remove superflous space (Daniel)
> Use per object list of vmas (Daniel)
> Make obj_bound_any() use obj_bound for each vm (Ben)
> s/bind_to_gtt/bind_to_vm/ (Ben)
>
> Fixed up the inactive shrinker. As Daniel noticed the code could
> potentially count the same object multiple times. While it's not
> possible in the current case, since 1 object can only ever be bound into
> 1 address space thus far - we may as well try to get something more
> future proof in place now. With a prep patch before this to switch over
> to using the bound list + inactive check, we're now able to carry that
> forward for every address space an object is bound into.
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
[danvet: Rebase on top of the loss of "drm/i915: Cleanup more of VMA
in destroy".]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-08-01 00:00:10 +00:00
|
|
|
__field(struct i915_address_space *, vm)
|
2015-01-22 17:01:23 +00:00
|
|
|
__field(u64, offset)
|
2017-10-03 12:50:54 +00:00
|
|
|
__field(u64, size)
|
2011-02-03 11:57:46 +00:00
|
|
|
),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_fast_assign(
|
drm/i915: plumb VM into bind/unbind code
As alluded to in several patches, and it will be reiterated later... A
VMA is an abstraction for a GEM BO bound into an address space.
Therefore it stands to reason, that the existing bind, and unbind are
the ones which will be the most impacted. This patch implements this,
and updates all callers which weren't already updated in the series
(because it was too messy).
This patch represents the bulk of an earlier, larger patch. I've pulled
out a bunch of things by the request of Daniel. The history is preserved
for posterity with the email convention of ">" One big change from the
original patch aside from a bunch of cropping is I've created an
i915_vma_unbind() function. That is because we always have the VMA
anyway, and doing an extra lookup is useful. There is a caveat, we
retain an i915_gem_object_ggtt_unbind, for the global cases which might
not talk in VMAs.
> drm/i915: plumb VM into object operations
>
> This patch was formerly known as:
> "drm/i915: Create VMAs (part 3) - plumbing"
>
> This patch adds a VM argument, bind/unbind, and the object
> offset/size/color getters/setters. It preserves the old ggtt helper
> functions because things still need, and will continue to need them.
>
> Some code will still need to be ported over after this.
>
> v2: Fix purge to pick an object and unbind all vmas
> This was doable because of the global bound list change.
>
> v3: With the commit to actually pin/unpin pages in place, there is no
> longer a need to check if unbind succeeded before calling put_pages().
> Make put_pages only BUG() after checking pin count.
>
> v4: Rebased on top of the new hangcheck work by Mika
> plumbed eb_destroy also
> Many checkpatch related fixes
>
> v5: Very large rebase
>
> v6:
> Change BUG_ON to WARN_ON (Daniel)
> Rename vm to ggtt in preallocate stolen, since it is always ggtt when
> dealing with stolen memory. (Daniel)
> list_for_each will short-circuit already (Daniel)
> remove superflous space (Daniel)
> Use per object list of vmas (Daniel)
> Make obj_bound_any() use obj_bound for each vm (Ben)
> s/bind_to_gtt/bind_to_vm/ (Ben)
>
> Fixed up the inactive shrinker. As Daniel noticed the code could
> potentially count the same object multiple times. While it's not
> possible in the current case, since 1 object can only ever be bound into
> 1 address space thus far - we may as well try to get something more
> future proof in place now. With a prep patch before this to switch over
> to using the bound list + inactive check, we're now able to carry that
> forward for every address space an object is bound into.
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
[danvet: Rebase on top of the loss of "drm/i915: Cleanup more of VMA
in destroy".]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-08-01 00:00:10 +00:00
|
|
|
__entry->obj = vma->obj;
|
|
|
|
|
__entry->vm = vma->vm;
|
|
|
|
|
__entry->offset = vma->node.start;
|
|
|
|
|
__entry->size = vma->node.size;
|
2011-02-03 11:57:46 +00:00
|
|
|
),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_printk("obj=%p, offset=0x%016llx size=0x%llx vm=%p",
|
drm/i915: plumb VM into bind/unbind code
As alluded to in several patches, and it will be reiterated later... A
VMA is an abstraction for a GEM BO bound into an address space.
Therefore it stands to reason, that the existing bind, and unbind are
the ones which will be the most impacted. This patch implements this,
and updates all callers which weren't already updated in the series
(because it was too messy).
This patch represents the bulk of an earlier, larger patch. I've pulled
out a bunch of things by the request of Daniel. The history is preserved
for posterity with the email convention of ">" One big change from the
original patch aside from a bunch of cropping is I've created an
i915_vma_unbind() function. That is because we always have the VMA
anyway, and doing an extra lookup is useful. There is a caveat, we
retain an i915_gem_object_ggtt_unbind, for the global cases which might
not talk in VMAs.
> drm/i915: plumb VM into object operations
>
> This patch was formerly known as:
> "drm/i915: Create VMAs (part 3) - plumbing"
>
> This patch adds a VM argument, bind/unbind, and the object
> offset/size/color getters/setters. It preserves the old ggtt helper
> functions because things still need, and will continue to need them.
>
> Some code will still need to be ported over after this.
>
> v2: Fix purge to pick an object and unbind all vmas
> This was doable because of the global bound list change.
>
> v3: With the commit to actually pin/unpin pages in place, there is no
> longer a need to check if unbind succeeded before calling put_pages().
> Make put_pages only BUG() after checking pin count.
>
> v4: Rebased on top of the new hangcheck work by Mika
> plumbed eb_destroy also
> Many checkpatch related fixes
>
> v5: Very large rebase
>
> v6:
> Change BUG_ON to WARN_ON (Daniel)
> Rename vm to ggtt in preallocate stolen, since it is always ggtt when
> dealing with stolen memory. (Daniel)
> list_for_each will short-circuit already (Daniel)
> remove superflous space (Daniel)
> Use per object list of vmas (Daniel)
> Make obj_bound_any() use obj_bound for each vm (Ben)
> s/bind_to_gtt/bind_to_vm/ (Ben)
>
> Fixed up the inactive shrinker. As Daniel noticed the code could
> potentially count the same object multiple times. While it's not
> possible in the current case, since 1 object can only ever be bound into
> 1 address space thus far - we may as well try to get something more
> future proof in place now. With a prep patch before this to switch over
> to using the bound list + inactive check, we're now able to carry that
> forward for every address space an object is bound into.
Signed-off-by: Ben Widawsky <ben@bwidawsk.net>
[danvet: Rebase on top of the loss of "drm/i915: Cleanup more of VMA
in destroy".]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2013-08-01 00:00:10 +00:00
|
|
|
__entry->obj, __entry->offset, __entry->size, __entry->vm)
|
2011-02-03 11:57:46 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(i915_gem_object_pwrite,
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len),
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_ARGS(obj, offset, len),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(struct drm_i915_gem_object *, obj)
|
2017-10-03 12:50:54 +00:00
|
|
|
__field(u64, offset)
|
|
|
|
|
__field(u64, len)
|
2011-02-03 11:57:46 +00:00
|
|
|
),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->obj = obj;
|
|
|
|
|
__entry->offset = offset;
|
|
|
|
|
__entry->len = len;
|
|
|
|
|
),
|
|
|
|
|
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_printk("obj=%p, offset=0x%llx, len=0x%llx",
|
2011-02-03 11:57:46 +00:00
|
|
|
__entry->obj, __entry->offset, __entry->len)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(i915_gem_object_pread,
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len),
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_ARGS(obj, offset, len),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
2010-11-08 19:18:58 +00:00
|
|
|
__field(struct drm_i915_gem_object *, obj)
|
2017-10-03 12:50:54 +00:00
|
|
|
__field(u64, offset)
|
|
|
|
|
__field(u64, len)
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->obj = obj;
|
2011-02-03 11:57:46 +00:00
|
|
|
__entry->offset = offset;
|
|
|
|
|
__entry->len = len;
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_printk("obj=%p, offset=0x%llx, len=0x%llx",
|
2011-02-03 11:57:46 +00:00
|
|
|
__entry->obj, __entry->offset, __entry->len)
|
2009-08-25 10:15:50 +00:00
|
|
|
);
|
|
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
TRACE_EVENT(i915_gem_object_fault,
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write),
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_ARGS(obj, index, gtt, write),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(struct drm_i915_gem_object *, obj)
|
2017-10-03 12:50:54 +00:00
|
|
|
__field(u64, index)
|
2011-02-03 11:57:46 +00:00
|
|
|
__field(bool, gtt)
|
|
|
|
|
__field(bool, write)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->obj = obj;
|
|
|
|
|
__entry->index = index;
|
|
|
|
|
__entry->gtt = gtt;
|
|
|
|
|
__entry->write = write;
|
|
|
|
|
),
|
2010-05-24 08:25:44 +00:00
|
|
|
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_printk("obj=%p, %s index=%llu %s",
|
2011-02-03 11:57:46 +00:00
|
|
|
__entry->obj,
|
|
|
|
|
__entry->gtt ? "GTT" : "CPU",
|
|
|
|
|
__entry->index,
|
|
|
|
|
__entry->write ? ", writable" : "")
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DECLARE_EVENT_CLASS(i915_gem_object,
|
2010-11-08 19:18:58 +00:00
|
|
|
TP_PROTO(struct drm_i915_gem_object *obj),
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_ARGS(obj),
|
2010-05-24 08:25:44 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(struct drm_i915_gem_object *, obj)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->obj = obj;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("obj=%p", __entry->obj)
|
2010-05-24 08:25:44 +00:00
|
|
|
);
|
|
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush,
|
|
|
|
|
TP_PROTO(struct drm_i915_gem_object *obj),
|
|
|
|
|
TP_ARGS(obj)
|
|
|
|
|
);
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy,
|
2010-11-08 19:18:58 +00:00
|
|
|
TP_PROTO(struct drm_i915_gem_object *obj),
|
2010-03-11 08:41:45 +00:00
|
|
|
TP_ARGS(obj)
|
|
|
|
|
);
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
TRACE_EVENT(i915_gem_evict,
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags),
|
2016-08-04 15:32:18 +00:00
|
|
|
TP_ARGS(vm, size, align, flags),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(u32, dev)
|
2016-08-04 15:32:18 +00:00
|
|
|
__field(struct i915_address_space *, vm)
|
2017-10-03 12:50:54 +00:00
|
|
|
__field(u64, size)
|
|
|
|
|
__field(u64, align)
|
2016-08-04 15:32:18 +00:00
|
|
|
__field(unsigned int, flags)
|
2011-02-03 11:57:46 +00:00
|
|
|
),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2011-02-03 11:57:46 +00:00
|
|
|
TP_fast_assign(
|
2016-11-29 12:42:05 +00:00
|
|
|
__entry->dev = vm->i915->drm.primary->index;
|
2016-08-04 15:32:18 +00:00
|
|
|
__entry->vm = vm;
|
2011-02-03 11:57:46 +00:00
|
|
|
__entry->size = size;
|
|
|
|
|
__entry->align = align;
|
2014-02-14 13:01:11 +00:00
|
|
|
__entry->flags = flags;
|
2011-02-03 11:57:46 +00:00
|
|
|
),
|
|
|
|
|
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_printk("dev=%d, vm=%p, size=0x%llx, align=0x%llx %s",
|
2016-08-04 15:32:18 +00:00
|
|
|
__entry->dev, __entry->vm, __entry->size, __entry->align,
|
2014-02-14 13:01:11 +00:00
|
|
|
__entry->flags & PIN_MAPPABLE ? ", mappable" : "")
|
2009-08-25 10:15:50 +00:00
|
|
|
);
|
|
|
|
|
|
2017-01-11 11:23:11 +00:00
|
|
|
TRACE_EVENT(i915_gem_evict_node,
|
|
|
|
|
TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags),
|
|
|
|
|
TP_ARGS(vm, node, flags),
|
2016-12-05 14:29:37 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(u32, dev)
|
|
|
|
|
__field(struct i915_address_space *, vm)
|
|
|
|
|
__field(u64, start)
|
|
|
|
|
__field(u64, size)
|
|
|
|
|
__field(unsigned long, color)
|
|
|
|
|
__field(unsigned int, flags)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2017-01-11 11:23:11 +00:00
|
|
|
__entry->dev = vm->i915->drm.primary->index;
|
|
|
|
|
__entry->vm = vm;
|
|
|
|
|
__entry->start = node->start;
|
|
|
|
|
__entry->size = node->size;
|
|
|
|
|
__entry->color = node->color;
|
2016-12-05 14:29:37 +00:00
|
|
|
__entry->flags = flags;
|
|
|
|
|
),
|
|
|
|
|
|
2017-10-03 12:50:54 +00:00
|
|
|
TP_printk("dev=%d, vm=%p, start=0x%llx size=0x%llx, color=0x%lx, flags=%x",
|
2016-12-05 14:29:37 +00:00
|
|
|
__entry->dev, __entry->vm,
|
|
|
|
|
__entry->start, __entry->size,
|
|
|
|
|
__entry->color, __entry->flags)
|
|
|
|
|
);
|
|
|
|
|
|
2017-10-03 12:50:55 +00:00
|
|
|
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->i915->drm.primary->index;
|
|
|
|
|
__entry->vm = vm;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("dev=%d, vm=%p", __entry->dev, __entry->vm)
|
|
|
|
|
);
|
|
|
|
|
|
2018-02-21 09:56:36 +00:00
|
|
|
TRACE_EVENT(i915_request_queue,
|
|
|
|
|
TP_PROTO(struct i915_request *rq, u32 flags),
|
|
|
|
|
TP_ARGS(rq, flags),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
2009-09-23 23:23:33 +00:00
|
|
|
__field(u32, dev)
|
2018-06-05 13:41:24 +00:00
|
|
|
__field(u64, ctx)
|
2018-05-25 08:26:40 +00:00
|
|
|
__field(u16, class)
|
|
|
|
|
__field(u16, instance)
|
2009-08-25 10:15:50 +00:00
|
|
|
__field(u32, seqno)
|
2012-10-17 11:09:54 +00:00
|
|
|
__field(u32, flags)
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2020-06-02 22:09:53 +00:00
|
|
|
__entry->dev = rq->engine->i915->drm.primary->index;
|
2018-05-25 08:26:40 +00:00
|
|
|
__entry->class = rq->engine->uabi_class;
|
2019-08-06 12:43:00 +00:00
|
|
|
__entry->instance = rq->engine->uabi_instance;
|
2018-02-21 09:56:36 +00:00
|
|
|
__entry->ctx = rq->fence.context;
|
|
|
|
|
__entry->seqno = rq->fence.seqno;
|
2012-10-17 11:09:54 +00:00
|
|
|
__entry->flags = flags;
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
2019-10-04 13:40:08 +00:00
|
|
|
TP_printk("dev=%u, engine=%u:%u, ctx=%llu, seqno=%u, flags=0x%x",
|
2018-05-25 08:26:41 +00:00
|
|
|
__entry->dev, __entry->class, __entry->instance,
|
2019-10-04 13:40:08 +00:00
|
|
|
__entry->ctx, __entry->seqno, __entry->flags)
|
2009-08-25 10:15:50 +00:00
|
|
|
);
|
|
|
|
|
|
2018-02-21 09:56:36 +00:00
|
|
|
DECLARE_EVENT_CLASS(i915_request,
|
|
|
|
|
TP_PROTO(struct i915_request *rq),
|
|
|
|
|
TP_ARGS(rq),
|
2009-08-25 10:15:50 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
2009-09-23 23:23:33 +00:00
|
|
|
__field(u32, dev)
|
2018-06-05 13:41:24 +00:00
|
|
|
__field(u64, ctx)
|
2018-05-25 08:26:40 +00:00
|
|
|
__field(u16, class)
|
|
|
|
|
__field(u16, instance)
|
2009-08-25 10:15:50 +00:00
|
|
|
__field(u32, seqno)
|
2021-07-21 21:51:00 +00:00
|
|
|
__field(u32, tail)
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2020-06-02 22:09:53 +00:00
|
|
|
__entry->dev = rq->engine->i915->drm.primary->index;
|
2018-05-25 08:26:40 +00:00
|
|
|
__entry->class = rq->engine->uabi_class;
|
2019-08-06 12:43:00 +00:00
|
|
|
__entry->instance = rq->engine->uabi_instance;
|
2018-02-21 09:56:36 +00:00
|
|
|
__entry->ctx = rq->fence.context;
|
|
|
|
|
__entry->seqno = rq->fence.seqno;
|
2021-07-21 21:51:00 +00:00
|
|
|
__entry->tail = rq->tail;
|
2009-08-25 10:15:50 +00:00
|
|
|
),
|
|
|
|
|
|
2021-10-27 09:32:55 +00:00
|
|
|
TP_printk("dev=%u, engine=%u:%u, ctx=%llu, seqno=%u, tail=%u",
|
2018-05-25 08:26:41 +00:00
|
|
|
__entry->dev, __entry->class, __entry->instance,
|
2021-10-27 09:32:55 +00:00
|
|
|
__entry->ctx, __entry->seqno, __entry->tail)
|
2009-08-25 10:15:50 +00:00
|
|
|
);
|
|
|
|
|
|
2018-02-21 09:56:36 +00:00
|
|
|
DEFINE_EVENT(i915_request, i915_request_add,
|
2021-07-21 21:51:00 +00:00
|
|
|
TP_PROTO(struct i915_request *rq),
|
|
|
|
|
TP_ARGS(rq)
|
2011-02-03 11:57:46 +00:00
|
|
|
);
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2017-02-21 11:01:42 +00:00
|
|
|
#if defined(CONFIG_DRM_I915_LOW_LEVEL_TRACEPOINTS)
|
2021-07-21 21:51:00 +00:00
|
|
|
DEFINE_EVENT(i915_request, i915_request_guc_submit,
|
|
|
|
|
TP_PROTO(struct i915_request *rq),
|
|
|
|
|
TP_ARGS(rq)
|
|
|
|
|
);
|
|
|
|
|
|
2018-02-21 09:56:36 +00:00
|
|
|
DEFINE_EVENT(i915_request, i915_request_submit,
|
|
|
|
|
TP_PROTO(struct i915_request *rq),
|
|
|
|
|
TP_ARGS(rq)
|
2017-02-21 11:01:42 +00:00
|
|
|
);
|
|
|
|
|
|
2018-02-21 09:56:36 +00:00
|
|
|
DEFINE_EVENT(i915_request, i915_request_execute,
|
|
|
|
|
TP_PROTO(struct i915_request *rq),
|
|
|
|
|
TP_ARGS(rq)
|
2017-02-21 11:01:42 +00:00
|
|
|
);
|
2017-02-21 11:03:00 +00:00
|
|
|
|
2018-05-04 11:56:43 +00:00
|
|
|
TRACE_EVENT(i915_request_in,
|
|
|
|
|
TP_PROTO(struct i915_request *rq, unsigned int port),
|
|
|
|
|
TP_ARGS(rq, port),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(u32, dev)
|
2018-06-05 13:41:24 +00:00
|
|
|
__field(u64, ctx)
|
2018-05-25 08:26:40 +00:00
|
|
|
__field(u16, class)
|
|
|
|
|
__field(u16, instance)
|
2018-05-04 11:56:43 +00:00
|
|
|
__field(u32, seqno)
|
|
|
|
|
__field(u32, port)
|
2020-01-28 15:16:47 +00:00
|
|
|
__field(s32, prio)
|
2018-05-04 11:56:43 +00:00
|
|
|
),
|
2017-02-21 11:03:00 +00:00
|
|
|
|
2018-05-04 11:56:43 +00:00
|
|
|
TP_fast_assign(
|
2020-06-02 22:09:53 +00:00
|
|
|
__entry->dev = rq->engine->i915->drm.primary->index;
|
2018-05-25 08:26:40 +00:00
|
|
|
__entry->class = rq->engine->uabi_class;
|
2019-08-06 12:43:00 +00:00
|
|
|
__entry->instance = rq->engine->uabi_instance;
|
2018-05-04 11:56:43 +00:00
|
|
|
__entry->ctx = rq->fence.context;
|
|
|
|
|
__entry->seqno = rq->fence.seqno;
|
|
|
|
|
__entry->prio = rq->sched.attr.priority;
|
|
|
|
|
__entry->port = port;
|
|
|
|
|
),
|
|
|
|
|
|
2020-01-28 15:16:47 +00:00
|
|
|
TP_printk("dev=%u, engine=%u:%u, ctx=%llu, seqno=%u, prio=%d, port=%u",
|
2018-05-25 08:26:41 +00:00
|
|
|
__entry->dev, __entry->class, __entry->instance,
|
2019-10-04 13:40:08 +00:00
|
|
|
__entry->ctx, __entry->seqno,
|
2019-02-26 09:49:21 +00:00
|
|
|
__entry->prio, __entry->port)
|
2017-02-21 11:03:00 +00:00
|
|
|
);
|
|
|
|
|
|
2018-05-04 11:56:43 +00:00
|
|
|
TRACE_EVENT(i915_request_out,
|
|
|
|
|
TP_PROTO(struct i915_request *rq),
|
|
|
|
|
TP_ARGS(rq),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(u32, dev)
|
2018-06-05 13:41:24 +00:00
|
|
|
__field(u64, ctx)
|
2018-05-25 08:26:40 +00:00
|
|
|
__field(u16, class)
|
|
|
|
|
__field(u16, instance)
|
2018-05-04 11:56:43 +00:00
|
|
|
__field(u32, seqno)
|
|
|
|
|
__field(u32, completed)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2020-06-02 22:09:53 +00:00
|
|
|
__entry->dev = rq->engine->i915->drm.primary->index;
|
2018-05-25 08:26:40 +00:00
|
|
|
__entry->class = rq->engine->uabi_class;
|
2019-08-06 12:43:00 +00:00
|
|
|
__entry->instance = rq->engine->uabi_instance;
|
2018-05-04 11:56:43 +00:00
|
|
|
__entry->ctx = rq->fence.context;
|
|
|
|
|
__entry->seqno = rq->fence.seqno;
|
|
|
|
|
__entry->completed = i915_request_completed(rq);
|
|
|
|
|
),
|
|
|
|
|
|
2019-10-04 13:40:08 +00:00
|
|
|
TP_printk("dev=%u, engine=%u:%u, ctx=%llu, seqno=%u, completed?=%u",
|
2018-05-25 08:26:41 +00:00
|
|
|
__entry->dev, __entry->class, __entry->instance,
|
2019-10-04 13:40:08 +00:00
|
|
|
__entry->ctx, __entry->seqno, __entry->completed)
|
2017-02-21 11:03:00 +00:00
|
|
|
);
|
2018-05-04 11:56:43 +00:00
|
|
|
|
2021-07-21 21:51:01 +00:00
|
|
|
DECLARE_EVENT_CLASS(intel_context,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(u32, guc_id)
|
|
|
|
|
__field(int, pin_count)
|
|
|
|
|
__field(u32, sched_state)
|
2021-07-27 00:23:47 +00:00
|
|
|
__field(u8, guc_prio)
|
2021-07-21 21:51:01 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2021-09-09 16:47:42 +00:00
|
|
|
__entry->guc_id = ce->guc_id.id;
|
2021-07-21 21:51:01 +00:00
|
|
|
__entry->pin_count = atomic_read(&ce->pin_count);
|
|
|
|
|
__entry->sched_state = ce->guc_state.sched_state;
|
2021-09-09 16:47:43 +00:00
|
|
|
__entry->guc_prio = ce->guc_state.prio;
|
2021-07-21 21:51:01 +00:00
|
|
|
),
|
|
|
|
|
|
2021-09-09 16:47:38 +00:00
|
|
|
TP_printk("guc_id=%d, pin_count=%d sched_state=0x%x, guc_prio=%u",
|
2021-07-21 21:51:01 +00:00
|
|
|
__entry->guc_id, __entry->pin_count,
|
|
|
|
|
__entry->sched_state,
|
2021-07-27 00:23:47 +00:00
|
|
|
__entry->guc_prio)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_set_prio,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
2021-07-21 21:51:01 +00:00
|
|
|
);
|
|
|
|
|
|
2021-07-27 00:23:27 +00:00
|
|
|
DEFINE_EVENT(intel_context, intel_context_reset,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
2021-07-27 00:23:39 +00:00
|
|
|
DEFINE_EVENT(intel_context, intel_context_ban,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
2021-07-21 21:51:01 +00:00
|
|
|
DEFINE_EVENT(intel_context, intel_context_register,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_deregister,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_deregister_done,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_sched_enable,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_sched_disable,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_sched_done,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_create,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_fence_release,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_free,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_steal_guc_id,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_do_pin,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(intel_context, intel_context_do_unpin,
|
|
|
|
|
TP_PROTO(struct intel_context *ce),
|
|
|
|
|
TP_ARGS(ce)
|
|
|
|
|
);
|
|
|
|
|
|
2017-02-21 11:01:42 +00:00
|
|
|
#else
|
|
|
|
|
#if !defined(TRACE_HEADER_MULTI_READ)
|
2021-07-21 21:51:00 +00:00
|
|
|
static inline void
|
|
|
|
|
trace_i915_request_guc_submit(struct i915_request *rq)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-21 11:01:42 +00:00
|
|
|
static inline void
|
2018-02-21 09:56:36 +00:00
|
|
|
trace_i915_request_submit(struct i915_request *rq)
|
2017-02-21 11:01:42 +00:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
2018-02-21 09:56:36 +00:00
|
|
|
trace_i915_request_execute(struct i915_request *rq)
|
2017-02-21 11:01:42 +00:00
|
|
|
{
|
|
|
|
|
}
|
2017-02-21 11:03:00 +00:00
|
|
|
|
|
|
|
|
static inline void
|
2018-02-21 09:56:36 +00:00
|
|
|
trace_i915_request_in(struct i915_request *rq, unsigned int port)
|
2017-02-21 11:03:00 +00:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
2018-02-21 09:56:36 +00:00
|
|
|
trace_i915_request_out(struct i915_request *rq)
|
2017-02-21 11:03:00 +00:00
|
|
|
{
|
|
|
|
|
}
|
2021-07-21 21:51:01 +00:00
|
|
|
|
2021-07-27 00:23:47 +00:00
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_set_prio(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-27 00:23:27 +00:00
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_reset(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-27 00:23:39 +00:00
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_ban(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-21 21:51:01 +00:00
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_register(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_deregister(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_deregister_done(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_sched_enable(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_sched_disable(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_sched_done(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_create(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_fence_release(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_free(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_steal_guc_id(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_do_pin(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
trace_intel_context_do_unpin(struct intel_context *ce)
|
|
|
|
|
{
|
|
|
|
|
}
|
2017-02-21 11:01:42 +00:00
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-02-21 09:56:36 +00:00
|
|
|
DEFINE_EVENT(i915_request, i915_request_retire,
|
|
|
|
|
TP_PROTO(struct i915_request *rq),
|
|
|
|
|
TP_ARGS(rq)
|
2009-08-25 10:15:50 +00:00
|
|
|
);
|
|
|
|
|
|
2018-02-21 09:56:36 +00:00
|
|
|
TRACE_EVENT(i915_request_wait_begin,
|
|
|
|
|
TP_PROTO(struct i915_request *rq, unsigned int flags),
|
|
|
|
|
TP_ARGS(rq, flags),
|
2012-05-24 22:03:09 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(u32, dev)
|
2018-06-05 13:41:24 +00:00
|
|
|
__field(u64, ctx)
|
2018-05-25 08:26:40 +00:00
|
|
|
__field(u16, class)
|
|
|
|
|
__field(u16, instance)
|
2012-05-24 22:03:09 +00:00
|
|
|
__field(u32, seqno)
|
2017-02-21 11:00:24 +00:00
|
|
|
__field(unsigned int, flags)
|
2012-05-24 22:03:09 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
/* 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(
|
2020-06-02 22:09:53 +00:00
|
|
|
__entry->dev = rq->engine->i915->drm.primary->index;
|
2018-05-25 08:26:40 +00:00
|
|
|
__entry->class = rq->engine->uabi_class;
|
2019-08-06 12:43:00 +00:00
|
|
|
__entry->instance = rq->engine->uabi_instance;
|
2018-02-21 09:56:36 +00:00
|
|
|
__entry->ctx = rq->fence.context;
|
|
|
|
|
__entry->seqno = rq->fence.seqno;
|
2017-02-21 11:00:24 +00:00
|
|
|
__entry->flags = flags;
|
2012-05-24 22:03:09 +00:00
|
|
|
),
|
|
|
|
|
|
2019-10-04 13:40:08 +00:00
|
|
|
TP_printk("dev=%u, engine=%u:%u, ctx=%llu, seqno=%u, flags=0x%x",
|
2018-05-25 08:26:41 +00:00
|
|
|
__entry->dev, __entry->class, __entry->instance,
|
2019-10-04 13:40:08 +00:00
|
|
|
__entry->ctx, __entry->seqno,
|
2018-05-25 08:26:40 +00:00
|
|
|
__entry->flags)
|
2010-03-11 08:41:45 +00:00
|
|
|
);
|
2009-08-25 10:15:50 +00:00
|
|
|
|
2018-02-21 09:56:36 +00:00
|
|
|
DEFINE_EVENT(i915_request, i915_request_wait_end,
|
|
|
|
|
TP_PROTO(struct i915_request *rq),
|
|
|
|
|
TP_ARGS(rq)
|
2009-08-25 10:15:50 +00:00
|
|
|
);
|
|
|
|
|
|
2013-07-19 19:36:56 +00:00
|
|
|
TRACE_EVENT_CONDITION(i915_reg_rw,
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 13:33:26 +00:00
|
|
|
TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace),
|
2011-08-16 19:34:10 +00:00
|
|
|
|
2013-07-19 19:36:56 +00:00
|
|
|
TP_ARGS(write, reg, val, len, trace),
|
|
|
|
|
|
|
|
|
|
TP_CONDITION(trace),
|
2011-08-16 19:34:10 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(u64, val)
|
|
|
|
|
__field(u32, reg)
|
|
|
|
|
__field(u16, write)
|
|
|
|
|
__field(u16, len)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->val = (u64)val;
|
drm/i915: Type safe register read/write
Make I915_READ and I915_WRITE more type safe by wrapping the register
offset in a struct. This should eliminate most of the fumbles we've had
with misplaced parens.
This only takes care of normal mmio registers. We could extend the idea
to other register types and define each with its own struct. That way
you wouldn't be able to accidentally pass the wrong thing to a specific
register access function.
The gpio_reg setup is probably the ugliest thing left. But I figure I'd
just leave it for now, and wait for some divine inspiration to strike
before making it nice.
As for the generated code, it's actually a bit better sometimes. Eg.
looking at i915_irq_handler(), we can see the following change:
lea 0x70024(%rdx,%rax,1),%r9d
mov $0x1,%edx
- movslq %r9d,%r9
- mov %r9,%rsi
- mov %r9,-0x58(%rbp)
- callq *0xd8(%rbx)
+ mov %r9d,%esi
+ mov %r9d,-0x48(%rbp)
callq *0xd8(%rbx)
So previously gcc thought the register offset might be signed and
decided to sign extend it, just in case. The rest appears to be
mostly just minor shuffling of instructions.
v2: i915_mmio_reg_{offset,equal,valid}() helpers added
s/_REG/_MMIO/ in the register defines
mo more switch statements left to worry about
ring_emit stuff got sorted in a prep patch
cmd parser, lrc context and w/a batch buildup also in prep patch
vgpu stuff cleaned up and moved to a prep patch
all other unrelated changes split out
v3: Rebased due to BXT DSI/BLC, MOCS, etc.
v4: Rebased due to churn, s/i915_mmio_reg_t/i915_reg_t/
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: http://patchwork.freedesktop.org/patch/msgid/1447853606-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-11-18 13:33:26 +00:00
|
|
|
__entry->reg = i915_mmio_reg_offset(reg);
|
2011-08-16 19:34:10 +00:00
|
|
|
__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))
|
2010-11-08 09:09:41 +00:00
|
|
|
);
|
|
|
|
|
|
2012-08-30 11:26:48 +00:00
|
|
|
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)
|
|
|
|
|
);
|
|
|
|
|
|
2014-11-10 13:44:31 +00:00
|
|
|
/**
|
|
|
|
|
* DOC: i915_ppgtt_create and i915_ppgtt_release tracepoints
|
|
|
|
|
*
|
|
|
|
|
* With full ppgtt enabled each process using drm will allocate at least one
|
|
|
|
|
* translation table. With these traces it is possible to keep track of the
|
|
|
|
|
* allocation and of the lifetime of the tables; this can be used during
|
|
|
|
|
* testing/debug to verify that we are not leaking ppgtts.
|
|
|
|
|
* These traces identify the ppgtt through the vm pointer, which is also printed
|
|
|
|
|
* by the i915_vma_bind and i915_vma_unbind tracepoints.
|
|
|
|
|
*/
|
|
|
|
|
DECLARE_EVENT_CLASS(i915_ppgtt,
|
|
|
|
|
TP_PROTO(struct i915_address_space *vm),
|
|
|
|
|
TP_ARGS(vm),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(struct i915_address_space *, vm)
|
|
|
|
|
__field(u32, dev)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->vm = vm;
|
2016-11-29 12:42:05 +00:00
|
|
|
__entry->dev = vm->i915->drm.primary->index;
|
2014-11-10 13:44:31 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("dev=%u, vm=%p", __entry->dev, __entry->vm)
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create,
|
|
|
|
|
TP_PROTO(struct i915_address_space *vm),
|
|
|
|
|
TP_ARGS(vm)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release,
|
|
|
|
|
TP_PROTO(struct i915_address_space *vm),
|
|
|
|
|
TP_ARGS(vm)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* DOC: i915_context_create and i915_context_free tracepoints
|
|
|
|
|
*
|
|
|
|
|
* These tracepoints are used to track creation and deletion of contexts.
|
|
|
|
|
* If full ppgtt is enabled, they also print the address of the vm assigned to
|
|
|
|
|
* the context.
|
|
|
|
|
*/
|
|
|
|
|
DECLARE_EVENT_CLASS(i915_context,
|
2016-05-24 13:53:34 +00:00
|
|
|
TP_PROTO(struct i915_gem_context *ctx),
|
2014-11-10 13:44:31 +00:00
|
|
|
TP_ARGS(ctx),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field(u32, dev)
|
2016-05-24 13:53:34 +00:00
|
|
|
__field(struct i915_gem_context *, ctx)
|
2014-11-10 13:44:31 +00:00
|
|
|
__field(struct i915_address_space *, vm)
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
2017-02-21 09:13:50 +00:00
|
|
|
__entry->dev = ctx->i915->drm.primary->index;
|
2014-11-10 13:44:31 +00:00
|
|
|
__entry->ctx = ctx;
|
2021-09-02 14:20:55 +00:00
|
|
|
__entry->vm = ctx->vm;
|
2014-11-10 13:44:31 +00:00
|
|
|
),
|
|
|
|
|
|
2019-10-04 13:40:08 +00:00
|
|
|
TP_printk("dev=%u, ctx=%p, ctx_vm=%p",
|
|
|
|
|
__entry->dev, __entry->ctx, __entry->vm)
|
2014-11-10 13:44:31 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(i915_context, i915_context_create,
|
2016-05-24 13:53:34 +00:00
|
|
|
TP_PROTO(struct i915_gem_context *ctx),
|
2014-11-10 13:44:31 +00:00
|
|
|
TP_ARGS(ctx)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(i915_context, i915_context_free,
|
2016-05-24 13:53:34 +00:00
|
|
|
TP_PROTO(struct i915_gem_context *ctx),
|
2014-11-10 13:44:31 +00:00
|
|
|
TP_ARGS(ctx)
|
|
|
|
|
);
|
|
|
|
|
|
2009-08-25 10:15:50 +00:00
|
|
|
#endif /* _I915_TRACE_H_ */
|
|
|
|
|
|
|
|
|
|
/* This part must be outside protection */
|
|
|
|
|
#undef TRACE_INCLUDE_PATH
|
2017-09-01 14:49:52 +00:00
|
|
|
#define TRACE_INCLUDE_PATH ../../drivers/gpu/drm/i915
|
2009-08-25 10:15:50 +00:00
|
|
|
#include <trace/define_trace.h>
|