[PATCH v3 00/23] drm/xe: Add structured SIGID error logging infrastructure

[PATCH v3 00/23] drm/xe: Add structured SIGID error logging infrastructure

[Michal Wajdeczko]

Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
strings that have no stable shape. That is readable for a human, but it
gives fleet tooling nothing durable to match on: the wording changes
between releases, lines can be rate-limited or dropped under an error
storm, and there is no consistent way to ask "which recognised fault
just happened?".

Introduce a signature identifier (SIGID): a small, stable integer that
names one recognised Xe fault situation and serves as the primary handle
for triage. A SIGID maps, through published end-user documentation, to a
description and a recommended action; the driver only has to emit the
right SIGID next to the usual human-readable text.

Design decisions:

 - Software-emitted signatures only. This header enumerates just the
   situations the driver detects and reports itself. Signatures that
   originate in firmware or hardware are identified by those layers (via
   their own records/counters) and are logged as received -- minting a
   driver-side id for them would duplicate an id the reporting layer
   already owns.

 - Flat catalogue, chosen per report site. Each site emits the single
   most specific situation for that site, so a multi-layer failure
   produces a chain of reports rather than one ambiguous classification
   (e.g. a failed GT reset reports GT_TDR and then WEDGED). A site that
   matches no defined situation keeps using ordinary xe_err() /
   xe_gt_err() rather than forcing a wrong id.

 - Stable numbering. A single flat list numbered sequentially from 1, in
   introduction order. Values are only ever appended, never renumbered
   or reused.

 - First-order action. Each SIGID carries a coarse, in-tree resolution
   bucket (COLLECT / RETRY / UPDATE / RECOVER) so it is actionable
   without an external reference, and so every new id must declare what
   to do about it.

 - Severity is decoupled from the SIGID and chosen at the call site via
   xe_ras_log_fatal() / _recoverable() / _info(); the same situation can
   be reported at different severities depending on the instance.

 - dmesg stays close to a normal xe error line by reusing xe_err() /
   xe_gt_err() (and their Tile/GT decoration); the only stable,
   machine-matchable token added is SIGID=<n>. dmesg is not an ABI --
   the durable machine record is the CPER carrying the same SIGID (a
   planned follow-up, left as a TODO).

Wire up a representative site for each software signature so the set is
exercised rather than merely declared:

 - PROBE: xe workqueue allocation failure during early init
 - WEDGED: xe_device_declare_wedged() (drop redundant "CRITICAL" + BDF)
 - SURVIVABILITY: entering boot survivability mode
 - RUNTIME_FW: GuC mmio request failure
 - DEVICE_FW: PCODE mailbox failure
 - GT_TDR: GT reset failure (which then chains into a WEDGED report)
 - MEM_FAULT: page-fault queue overflow
 - IO_BUS: PCI re-enable failure after a bus reset

Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Cc: Matthew Brost <matthew.brost@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Riana Tauro <riana.tauro@intel.com>
Cc: Raag Jadav <raag.jadav@intel.com>
Cc: Badal Nilawar <badal.nilawar@intel.com>

v1: https://patchwork.freedesktop.org/series/171022/#rev1
v2: https://patchwork.freedesktop.org/series/171022/#rev2
    component/location dmesg decorations moved away from macros
    HW component identifiers related to RAS/FW enum values
    CORRECTED severity rendered as an error
    more support for const pointers
    log 'probe blocked' as INFO
    fix kunit device setup
    more tests
v3: fix typos, args list and to_dev() corner case (Sashiko)
    use assoc macros in xe_any (Jani)
    add xe_any kunit test suite (Michal)
    add more xe_log test cases (Michal)

Mallesh Koujalagi (1):
  drm/xe/log: Add structured SIGID error logging infrastructure

Michal Wajdeczko (22):
  drm/xe: Introduce xe_any helpers
  drm/xe/log: Introduce structured component/location identifiers
  drm/xe/log: Add component/location decorations to dmesg
  drm/xe/log: Add SIGID log helpers for severity
  drm/xe/log: Add SIGID log helpers for location
  drm/xe/log: Add SIGID log helpers for location & severity
  drm/xe/log: Add SIGID log helpers for components
  drm/xe/log: Add SIGID log helpers for errno-only
  drm/xe/log: Add hardware error signatures
  drm/xe/log: Extend components list with hardware items
  drm/xe/ras: Check RAS and LOG component definitions
  drm/xe/kunit: Setup driver data in the test device
  drm/xe/tests: Add Kunit tests for xe_log
  drm/xe/tests: Add kunit tests for xe_any
  drm/xe: Report 'probe blocked' error using SIGID
  drm/xe: Report 'device wedged' errors using SIGID
  drm/xe: Report 'Survivability Mode' errors using SIGID
  drm/xe/guc: Report 'GuC mmio' errors using SIGID
  drm/xe/pcode: Report 'Mailbox failed' error using SIGID
  drm/xe/gt: Report 'reset failed' errors using SIGID
  drm/xe/gt: Report 'pagefault' errors using SIGID
  drm/xe/pci: Report 'cannot re-enable' error using SIGID

 Documentation/gpu/xe/index.rst              |   1 +
 Documentation/gpu/xe/xe_sigid.rst           |  14 +
 drivers/gpu/drm/xe/Makefile                 |   1 +
 drivers/gpu/drm/xe/abi/xe_log_abi.h         | 198 +++++++
 drivers/gpu/drm/xe/abi/xe_sigid_abi.h       | 195 +++++++
 drivers/gpu/drm/xe/tests/Makefile           |   1 +
 drivers/gpu/drm/xe/tests/xe_any_kunit.c     | 188 +++++++
 drivers/gpu/drm/xe/tests/xe_kunit_helpers.c |   4 +
 drivers/gpu/drm/xe/tests/xe_log_kunit.c     | 545 ++++++++++++++++++++
 drivers/gpu/drm/xe/xe_any.h                 | 137 +++++
 drivers/gpu/drm/xe/xe_device.c              |  16 +-
 drivers/gpu/drm/xe/xe_gt.c                  |   7 +-
 drivers/gpu/drm/xe/xe_guc.c                 |  18 +-
 drivers/gpu/drm/xe/xe_log.c                 | 232 +++++++++
 drivers/gpu/drm/xe/xe_log.h                 | 158 ++++++
 drivers/gpu/drm/xe/xe_pagefault.c           |  10 +-
 drivers/gpu/drm/xe/xe_pci.c                 |   5 +-
 drivers/gpu/drm/xe/xe_pci_error.c           |   7 +-
 drivers/gpu/drm/xe/xe_pcode.c               |   5 +-
 drivers/gpu/drm/xe/xe_ras.c                 |  11 +
 drivers/gpu/drm/xe/xe_survivability_mode.c  |  24 +-
 21 files changed, 1738 insertions(+), 39 deletions(-)
 create mode 100644 Documentation/gpu/xe/xe_sigid.rst
 create mode 100644 drivers/gpu/drm/xe/abi/xe_log_abi.h
 create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
 create mode 100644 drivers/gpu/drm/xe/tests/xe_any_kunit.c
 create mode 100644 drivers/gpu/drm/xe/tests/xe_log_kunit.c
 create mode 100644 drivers/gpu/drm/xe/xe_any.h
 create mode 100644 drivers/gpu/drm/xe/xe_log.c
 create mode 100644 drivers/gpu/drm/xe/xe_log.h

-- 
2.47.1

[PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Michal Wajdeczko]

From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>

Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
strings that have no stable shape. That is readable for a human, but it
gives fleet tooling nothing durable to match on: the wording changes
between releases, lines can be rate-limited or dropped under an error
storm, and there is no consistent way to ask "which recognised fault
just happened?".

Introduce a signature identifier (SIGID): a small, stable integer that
names one recognised Xe fault situation and serves as the primary handle
for triage. A SIGID maps, through published end-user documentation, to a
description and a recommended action; the driver only has to emit the
right SIGID next to the usual human-readable text.

Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
Assisted-by: Copilot:Opus-4.8
Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
Cc: Yoni Levitt <yoni.levitt@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Raag Jadav <raag.jadav@intel.com>
Cc: Riana Tauro <riana.tauro@intel.com>
---
v2: CORRECTED is still an error (Michal)
    prepare to decorate dmesg with comp/loc (Michal)
---
 Documentation/gpu/xe/index.rst        |   1 +
 Documentation/gpu/xe/xe_sigid.rst     |  14 ++
 drivers/gpu/drm/xe/Makefile           |   1 +
 drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183 ++++++++++++++++++++++++++
 drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
 drivers/gpu/drm/xe/xe_log.h           |  20 +++
 6 files changed, 354 insertions(+)
 create mode 100644 Documentation/gpu/xe/xe_sigid.rst
 create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
 create mode 100644 drivers/gpu/drm/xe/xe_log.c
 create mode 100644 drivers/gpu/drm/xe/xe_log.h

diff --git a/Documentation/gpu/xe/index.rst b/Documentation/gpu/xe/index.rst
index 665c0e93601c..0247a255f7e6 100644
--- a/Documentation/gpu/xe/index.rst
+++ b/Documentation/gpu/xe/index.rst
@@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for drm/xe is provided by
    xe-drm-usage-stats.rst
    xe_configfs
    xe_gt_stats
+   xe_sigid
diff --git a/Documentation/gpu/xe/xe_sigid.rst b/Documentation/gpu/xe/xe_sigid.rst
new file mode 100644
index 000000000000..45d84a62f185
--- /dev/null
+++ b/Documentation/gpu/xe/xe_sigid.rst
@@ -0,0 +1,14 @@
+.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
+
+========
+Xe SIGID
+========
+
+.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
+   :doc: Xe Error Signatures (SIGID)
+
+Signature Identifiers
+=====================
+
+.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
+   :internal:
diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
index 67ada1d6c2fb..7ac3954737f9 100644
--- a/drivers/gpu/drm/xe/Makefile
+++ b/drivers/gpu/drm/xe/Makefile
@@ -87,6 +87,7 @@ xe-y += xe_bb.o \
 	xe_hw_fence.o \
 	xe_irq.o \
 	xe_late_bind_fw.o \
+	xe_log.o \
 	xe_lrc.o \
 	xe_mem_pool.o \
 	xe_migrate.o \
diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
new file mode 100644
index 000000000000..99717fdf74a6
--- /dev/null
+++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
@@ -0,0 +1,183 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#ifndef _ABI_XE_SIGID_ABI_H_
+#define _ABI_XE_SIGID_ABI_H_
+
+/**
+ * DOC: Xe Error Signatures (SIGID)
+ *
+ * What SIGID stands for
+ * ---------------------
+ *
+ * SIGID is short for *Signature Identifier*. A SIGID is a small, stable integer
+ * that names one *recognised Xe fault situation* -- nothing more. It is the
+ * primary handle used for triage: a SIGID maps to a human description and a
+ * recommended first action. A coarse first-order action is documented in-tree
+ * per SIGID (see "First-order action" below) so the id is actionable on its
+ * own; published end-user documentation refines it with finer, cross-product
+ * detail. The driver's only job is to emit the right SIGID next to the usual
+ * human-readable text.
+ *
+ * Why this exists
+ * ---------------
+ *
+ * Today the driver reports faults with ad-hoc ``drm_err()`` / ``xe_gt_err()``
+ * strings that have no stable shape. That is fine for a human reading dmesg,
+ * but it gives fleet tooling nothing durable to match on: the wording changes
+ * between releases, lines can be rate-limited or dropped under an error storm,
+ * and there is no consistent way to ask "which recognised fault just happened?"
+ * A SIGID answers exactly that one question, identically across driver and
+ * firmware versions, and (eventually) across other Intel devices in a node.
+ *
+ * What a SIGID is (and is not)
+ * ----------------------------
+ *
+ * A SIGID names *which situation* is being reported. It deliberately does not
+ * encode the detailed reason or the outcome. Those are carried alongside it::
+ *
+ *   SIGID    -> which recognised situation is being reported
+ *   severity -> how serious this instance is (see below -- not fixed per SIGID)
+ *   errno    -> the failing operation's error, shown with %pe
+ *   message  -> free-form human-readable context
+ *
+ * Severity is independent of the SIGID. The same situation can be reported at
+ * different severities depending on the instance and the recovery taken, so a
+ * SIGID is never tied to one severity; the reporting site chooses it by calling
+ * the matching xe_log_*() helper (see xe_log.h).
+ *
+ * How to pick a SIGID (the uniqueness rule)
+ * -----------------------------------------
+ *
+ * Pick per *report site*, not per incident. Each site emits the single most
+ * specific recognised situation *for that site* -- so the question is never
+ * "classify this whole failure", it is "what does this site detect?", which has
+ * one answer. A single underlying failure therefore legitimately produces a
+ * *chain* of reports from different layers, each with its own SIGID -- e.g. a
+ * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by the firmware
+ * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path, and an
+ * aborted bind as %XE_SIGID_PROBE by the probe path. That chain lets triage
+ * follow a fault from origin to final effect; it is not a duplicate.
+ *
+ * If a site does not match any defined situation, keep using the ordinary
+ * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a SIGID: a wrong
+ * or over-broad classification is harder to retire than a missing one. When a
+ * new situation is genuinely worth triaging, add it to the list below.
+ *
+ * Scope: software-emitted signatures only
+ * ---------------------------------------
+ *
+ * This header enumerates only the situations that the *driver itself* detects
+ * and reports from software: probe abort, wedged, survivability, driver-
+ * detected firmware failures, engine TDR, memory faults and IO/bus faults.
+ * These are the only values the driver assigns.
+ *
+ * Signatures that *originate* in firmware or hardware are a different thing:
+ * they are produced and identified by the firmware or the hardware itself
+ * (e.g. via their own records or error counters), and the driver merely logs
+ * them as they are given to us. They are deliberately *not* enumerated here --
+ * minting a driver-side id for a firmware/hardware-reported error would only
+ * duplicate an identifier the reporting layer already owns. The two
+ * driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
+ * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the driver*
+ * observed a firmware problem, not a signature reported by the firmware.
+ *
+ * Numbering
+ * ---------
+ *
+ * SIGIDs are a single flat list numbered sequentially within the assigned range,
+ * in the order the situations were introduced. Values are stable: once assigned
+ * they are only ever appended, never renumbered or reused.
+ *
+ * A retired situation is deprecated in place, never re-purposed.
+ *
+ * First-order action (resolution buckets)
+ * ---------------------------------------
+ *
+ * So that a SIGID is actionable on its own, each one is tagged with a coarse
+ * *resolution bucket*: the first thing an operator should do on seeing it. The
+ * bucket is a stable, driver-owned hint; external documentation may refine it,
+ * but the in-tree value always stands on its own. Every new SIGID must pick a
+ * bucket, which forces the question "what should someone do about this?" to be
+ * answered up front. The buckets are::
+ *
+ *   COLLECT  -- capture logs and open a bug report
+ *   RETRY    -- transient or already recovered; watch for recurrence
+ *   UPDATE   -- a firmware update / flash is required
+ *   RECOVER  -- an explicit recovery step is needed (rebind, bus reset)
+ *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
+ *
+ * The bucket is documentation only -- it is recorded per SIGID in the enum
+ * kernel-doc below and is not printed on the (deliberately lean) dmesg line.
+ *
+ * When to use SIGID logging
+ * -------------------------
+ *
+ * The xe_log_*() helpers are for these recognised fault situations only --
+ * important, operator-relevant faults and events. They are not a replacement
+ * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off diagnostics;
+ * using them for ordinary logging would dilute the fault stream. Not every
+ * ``xe_err()`` needs to become a SIGID report -- only those that correspond to
+ * a published situation.
+ *
+ * dmesg vs. the machine record
+ * ----------------------------
+ *
+ * The dmesg line stays close to a normal xe error message so it remains
+ * readable for admins; the only stable, machine-matchable token on it is
+ * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI: the surrounding
+ * text may change freely, and lines may be dropped. The durable record for
+ * tooling is the CPER record carrying the same SIGID (generation is a planned
+ * follow-up).
+ */
+
+/*
+ * Top level Intel Error Signature Identifiers.
+ */
+#define INTEL_SIGID_INVALID			0
+#define INTEL_SIGID_GPU_START			100
+#define INTEL_SIGID_GPU_END			999
+
+#define INTEL_SIGID_GPU_XE_START		100
+#define INTEL_SIGID_GPU_XE_END			299
+
+#define INTEL_SIGID_GPU_XE_SOFTWARE_START	100
+#define INTEL_SIGID_GPU_XE_SOFTWARE_END		199
+#define INTEL_SIGID_GPU_XE_HARDWARE_START	200
+#define INTEL_SIGID_GPU_XE_HARDWARE_END		299
+
+/**
+ * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
+ * @XE_SIGID_SW: Software component failure. [COLLECT]
+ * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
+ * @XE_SIGID_WEDGED: Device was declared wedged and is no longer usable. [RECOVER]
+ * @XE_SIGID_SURVIVABILITY: Device entered survivability mode. [UPDATE]
+ * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure, GuC/HuC/GSC. [RETRY]
+ * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure, PCODE/sysctrl. [RETRY]
+ * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery (reset). [RETRY]
+ * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault. [COLLECT]
+ * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault. [RECOVER]
+ *
+ * The situations the driver detects and reports in software. Values are
+ * numbered sequentially, are only ever appended, and are never renumbered or
+ * reused. The tag in brackets is the default resolution bucket (see the `Xe
+ * Error Signatures (SIGID)`_ section).
+ *
+ * Firmware- and hardware-originated signatures are not listed here; they are
+ * logged as reported by those layers.
+ */
+enum xe_sigid {
+	XE_SIGID_SW			= INTEL_SIGID_GPU_XE_SOFTWARE_START,
+	XE_SIGID_PROBE			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 1,
+	XE_SIGID_WEDGED			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 2,
+	XE_SIGID_SURVIVABILITY		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 3,
+	XE_SIGID_RUNTIME_FW		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 4,
+	XE_SIGID_DEVICE_FW		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 5,
+	XE_SIGID_GT_TDR			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
+	XE_SIGID_MEM_FAULT		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
+	XE_SIGID_IO_BUS			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
+};
+
+#endif
diff --git a/drivers/gpu/drm/xe/xe_log.c b/drivers/gpu/drm/xe/xe_log.c
new file mode 100644
index 000000000000..70a41bdf1a01
--- /dev/null
+++ b/drivers/gpu/drm/xe/xe_log.c
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#include "xe_log.h"
+#include "xe_printk.h"
+
+static void log_emit_cper(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
+			  u32 component, u32 location, const void *data, size_t len,
+			  struct va_format *vaf)
+{
+	/* TODO */
+}
+
+static bool is_hw_sigid(enum xe_sigid sigid)
+{
+	return (int)sigid >= INTEL_SIGID_GPU_XE_HARDWARE_START;
+}
+
+static bool is_sev_error(int cper_sev)
+{
+	return cper_sev != CPER_SEV_INFORMATIONAL;
+}
+
+static const char *log_hwe_prefix(int cper_sev, enum xe_sigid sigid)
+{
+	return is_sev_error(cper_sev) && is_hw_sigid(sigid) ? HW_ERR : "";
+}
+
+static const char *log_sev_prefix(int cper_sev)
+{
+	switch (cper_sev) {
+	case CPER_SEV_FATAL:
+		return "FATAL ";
+	case CPER_SEV_RECOVERABLE:
+		return "";
+	case CPER_SEV_CORRECTED:
+		return "CORRECTED ";
+	default:
+		return "";
+	}
+}
+
+#define __LOG_DRM_PRINTK_FMT(fmt, args...)	"[drm] " fmt, ##args
+#define __LOG_DRM_PRINTK_ERR_FMT(fmt, args...)	__LOG_DRM_PRINTK_FMT("*ERROR* " fmt, args)
+
+static void log_dmesg_vprintk(struct pci_dev *pdev, int cper_sev, struct va_format *vaf)
+{
+	if (cper_sev == CPER_SEV_INFORMATIONAL)
+		pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
+	else
+		pci_err(pdev, __LOG_DRM_PRINTK_ERR_FMT("%pV", vaf));
+}
+
+static void log_dmesg_printf(struct pci_dev *pdev, int cper_sev, const char *fmt, ...)
+{
+	struct va_format vaf;
+	va_list args;
+
+	va_start(args, fmt);
+	vaf.fmt = fmt;
+	vaf.va = &args;
+
+	log_dmesg_vprintk(pdev, cper_sev, &vaf);
+
+	va_end(args);
+}
+
+static void log_emit_dmesg(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
+			   u32 component, u32 location, const void *data, size_t len,
+			   struct va_format *vaf)
+{
+	const char *hwe_prefix = log_hwe_prefix(cper_sev, sigid);
+	const char *sev_prefix = log_sev_prefix(cper_sev);
+
+	/* TODO: add component/location details */
+
+	if (IS_ERR(data))
+		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%pe) %s%pV",
+				 sigid, sev_prefix, data, hwe_prefix, vaf);
+	else if (data && len)
+		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%*phN) %s%pV",
+				 sigid, sev_prefix, (int)len, data, hwe_prefix, vaf);
+	else
+		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s%s%pV",
+				 sigid, sev_prefix, hwe_prefix, vaf);
+}
+
+/**
+ * xe_log_emit() - Emit a structured SIGID log entry
+ * @pdev: the &pci_dev device
+ * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE, ...)
+ * @sigid: signature identifier, see &enum xe_sigid
+ * @component: component identifer
+ * @location: location details of the @component
+ * @data: pointer to the additional details, or ERR_PTR, or NULL if not applicable
+ * @len: length of the @data in bytes, or 0 if not applicable
+ * @fmt: printf-style format string
+ * @...: format arguments
+ *
+ * Emits a dmesg line that includes a single stable, machine-matchable token
+ * ``SIGID=<n>`` followed by the optional severity token (like ``FATAL``) and,
+ * when @data pointer is set, either the error printed with %pe or a packed hex
+ * dump of the @data binary blob. The dmesg line will also include printf-style
+ * text message.
+ *
+ * Note that the full dmesg line, with the free text message, is only a debugging
+ * aid, not an interface! Only the ``SIGID=<n>`` token is stable there.
+ * The durable machine record is the CPER carrying the same SIGID.
+ *
+ * Note: generation of the CPER record is a planned follow-up.
+ *
+ * Examples::
+ *
+ *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=104 FATAL (-EPROTO) Invalid GuC reply
+ *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=106 (-ETIMEDOUT) Engine 'rcs0' hung
+ *   <6> xe 0000:03:00.0: [drm] *ERROR* SIGID=103 In survivability mode
+ */
+void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
+		 u32 component, u32 location, const void *data, size_t len,
+		 const char *fmt, ...)
+{
+	struct va_format vaf;
+	va_list args;
+
+	va_start(args, fmt);
+	vaf.fmt = fmt;
+	vaf.va = &args;
+
+	log_emit_dmesg(pdev, cper_sev, sigid, component, location, data, len, &vaf);
+	log_emit_cper(pdev, cper_sev, sigid, component, location, data, len, &vaf);
+
+	va_end(args);
+}
diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
new file mode 100644
index 000000000000..d475e816ee0b
--- /dev/null
+++ b/drivers/gpu/drm/xe/xe_log.h
@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#ifndef _XE_LOG_H_
+#define _XE_LOG_H_
+
+#include <linux/cper.h>
+
+#include "abi/xe_sigid_abi.h"
+
+struct pci_dev;
+
+__printf(8, 9)
+void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
+		 u32 component, u32 location, const void *data, size_t len,
+		 const char *fmt, ...);
+
+#endif
-- 
2.47.1

[PATCH v3 05/23] drm/xe/log: Add SIGID log helpers for severity

[Michal Wajdeczko]

There are only few CPER severity levels defined, add simple helper
for each of them, to avoid forcing developers to write full severity
name in every function call.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
---
v2: drop support for any_to_pdev (Michal)
---
 drivers/gpu/drm/xe/xe_log.h | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
index d475e816ee0b..73daf37d6463 100644
--- a/drivers/gpu/drm/xe/xe_log.h
+++ b/drivers/gpu/drm/xe/xe_log.h
@@ -17,4 +17,20 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
 		 u32 component, u32 location, const void *data, size_t len,
 		 const char *fmt, ...);
 
+#define xe_log_emit_fatal(pdev, sig, comp, loc, data, len, fmt, args...) \
+	xe_log_emit((pdev), CPER_SEV_FATAL, (sig), (comp), (loc), \
+		    (data), (len), fmt, ##args)
+
+#define xe_log_emit_recoverable(pdev, sig, comp, loc, data, len, fmt, args...) \
+	xe_log_emit((pdev), CPER_SEV_RECOVERABLE, (sig), (comp), (loc), \
+		    (data), (len), fmt, ##args)
+
+#define xe_log_emit_corrected(pdev, sig, comp, loc, data, len, fmt, args...) \
+	xe_log_emit((pdev), CPER_SEV_CORRECTED, (sig), (comp), (loc), \
+		    (data), (len), fmt, ##args)
+
+#define xe_log_emit_info(pdev, sig, comp, loc, data, len, fmt, args...) \
+	xe_log_emit((pdev), CPER_SEV_INFORMATIONAL, (sig), (comp), (loc), \
+		    (data), (len), fmt, ##args)
+
 #endif
-- 
2.47.1

[PATCH v3 06/23] drm/xe/log: Add SIGID log helpers for location

[Michal Wajdeczko]

We can determine the location of the SIGID error source based on the
type of the xe pointer being currently available. Add helper macros
that will accept any of xe_device, xe_tile or xe_gt pointers instead
of plain pci_dev to generate valid XE_LOG_LOCATION identifier and then
call low-level xe_log_emit(pdev) function.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
---
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
 drivers/gpu/drm/xe/xe_log.h | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
index 73daf37d6463..510cedae6e14 100644
--- a/drivers/gpu/drm/xe/xe_log.h
+++ b/drivers/gpu/drm/xe/xe_log.h
@@ -8,7 +8,9 @@
 
 #include <linux/cper.h>
 
+#include "abi/xe_log_abi.h"
 #include "abi/xe_sigid_abi.h"
+#include "xe_any.h"
 
 struct pci_dev;
 
@@ -33,4 +35,38 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
 	xe_log_emit((pdev), CPER_SEV_INFORMATIONAL, (sig), (comp), (loc), \
 		    (data), (len), fmt, ##args)
 
+#define xe_log_location_type(any)							\
+	_Generic((any),									\
+		 struct xe_gt * : XE_LOG_LOCATION_TYPE_GT,				\
+		 const struct xe_gt * : XE_LOG_LOCATION_TYPE_GT,			\
+		 struct xe_tile * : XE_LOG_LOCATION_TYPE_TILE,				\
+		 const struct xe_tile * : XE_LOG_LOCATION_TYPE_TILE,			\
+		 struct xe_device * : XE_LOG_LOCATION_TYPE_DEVICE,			\
+		 const struct xe_device * : XE_LOG_LOCATION_TYPE_DEVICE,		\
+		 struct pci_dev * : XE_LOG_LOCATION_TYPE_DEVICE,			\
+		 struct device * : XE_LOG_LOCATION_TYPE_DEVICE)
+
+#define xe_log_location(any) \
+	PREP_XE_LOG_LOCATION(xe_log_location_type(any), xe_any_id(any))
+
+/**
+ * xe_log_from() - Emit a structured SIGID log entry using @any pointer as location.
+ * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
+ * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE, ...)
+ * @sigid: signature identifier, see &enum xe_sigid
+ * @component: component identifer
+ * @data: pointer to the additional details, or ERR_PTR, or NULL if not applicable
+ * @len: length of the @data in bytes, or 0 if not applicable
+ * @fmt: printf-style format string
+ * @args: arguments for the @fmt format string
+ *
+ * The location used to emit SIGID entry will be based on the @any pointer type.
+ * See xe_log_emit() for more details.
+ */
+#define xe_log_from(any, cper_sev, sigid, component, data, len, fmt, args...) do {	\
+	typeof(any) ___any = (any);							\
+	xe_log_emit(xe_any_to_pdev(___any), (cper_sev), (sigid), (component),		\
+		    xe_log_location(___any), (data), (len), fmt, ##args);		\
+} while (0)
+
 #endif
-- 
2.47.1

[PATCH v3 07/23] drm/xe/log: Add SIGID log helpers for location & severity

[Michal Wajdeczko]

There are only few CPER severity levels defined, add more helpers
to avoid forcing developers to write full CPER severity name in
every function call.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
---
v2: fix argument list (Sashiko)
---
 drivers/gpu/drm/xe/xe_log.h | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
index 510cedae6e14..916218560297 100644
--- a/drivers/gpu/drm/xe/xe_log.h
+++ b/drivers/gpu/drm/xe/xe_log.h
@@ -69,4 +69,20 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
 		    xe_log_location(___any), (data), (len), fmt, ##args);		\
 } while (0)
 
+#define xe_log_from_fatal(any, sig, comp, data, len, fmt, args...) \
+	xe_log_from((any), CPER_SEV_FATAL, (sig), (comp), \
+		    (data), (len), fmt, ##args)
+
+#define xe_log_from_recoverable(any, sig, comp, data, len, fmt, args...) \
+	xe_log_from((any), CPER_SEV_RECOVERABLE, (sig), (comp), \
+		    (data), (len), fmt, ##args)
+
+#define xe_log_from_corrected(any, sig, comp, data, len, fmt, args...) \
+	xe_log_from((any), CPER_SEV_CORRECTED, (sig), (comp), \
+		    (data), (len), fmt, ##args)
+
+#define xe_log_from_info(any, sig, comp, data, len, fmt, args...) \
+	xe_log_from((any), CPER_SEV_INFORMATIONAL, (sig), (comp), \
+		    (data), (len), fmt, ##args)
+
 #endif
-- 
2.47.1

[PATCH v3 08/23] drm/xe/log: Add SIGID log helpers for components

[Michal Wajdeczko]

Our component list already defines relation between the component
name, identified by the TAG, and its numerical identifier and the
assigned SIGID. We can also already prepare location identifier
based on the pointer type used to emit the log entry. Add helper
that will prepare SIGID, COMPONENT and LOCATION parameters for
xe_log_emit() using provided components TAG and the pointer.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
---
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
v2: rebased/simplified (Michal)
---
 drivers/gpu/drm/xe/xe_log.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
index 916218560297..c30db02950b0 100644
--- a/drivers/gpu/drm/xe/xe_log.h
+++ b/drivers/gpu/drm/xe/xe_log.h
@@ -85,4 +85,22 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
 	xe_log_from((any), CPER_SEV_INFORMATIONAL, (sig), (comp), \
 		    (data), (len), fmt, ##args)
 
+/**
+ * xe_log_comp() - Emit a structured SIGID log entry on the component behalf.
+ * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
+ * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE, ...)
+ * @TAG: the component tag to use
+ * @data: pointer to the additional details, or ERR_PTR, or NULL if not applicable
+ * @len: length of the @data in bytes, or 0 if not applicable
+ * @fmt: printf-style free text format string (not a stable interface)
+ * @args: arguments for the @fmt format string
+ *
+ * The SIGID will be determined from the component's @TAG.
+ * The component identifier will be determined from the component's @TAG.
+ * The location used to emit SIGID entry will be based on the @any pointer type.
+ */
+#define xe_log_comp(any, cper_sev, TAG, data, len, fmt, args...) \
+	xe_log_from((any), (cper_sev), (int)XE_LOG_COMPONENT_##TAG##_SIGID, \
+		    XE_LOG_COMPONENT_##TAG, (data), (len), fmt, ##args)
+
 #endif
-- 
2.47.1

[PATCH v3 09/23] drm/xe/log: Add SIGID log helpers for errno-only

[Michal Wajdeczko]

For the software based SIGID errors, we will usually want to pass
only the errno value as the data to be logged in the dmesg line or
the CPER record. Add simple wrappers for that.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
---
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
v2: include linux/err.h (Sashiko)
    add xe_log_err_corrected (Michal)
---
 drivers/gpu/drm/xe/xe_log.h | 52 +++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
index c30db02950b0..5716fb7eeb31 100644
--- a/drivers/gpu/drm/xe/xe_log.h
+++ b/drivers/gpu/drm/xe/xe_log.h
@@ -7,6 +7,7 @@
 #define _XE_LOG_H_
 
 #include <linux/cper.h>
+#include <linux/err.h>
 
 #include "abi/xe_log_abi.h"
 #include "abi/xe_sigid_abi.h"
@@ -103,4 +104,55 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
 	xe_log_from((any), (cper_sev), (int)XE_LOG_COMPONENT_##TAG##_SIGID, \
 		    XE_LOG_COMPONENT_##TAG, (data), (len), fmt, ##args)
 
+/**
+ * xe_log_err() - Emit a structured SIGID error log entry on the component behalf.
+ * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
+ * @TAG: the component tag to use
+ * @err: negative errno for the failing operation, or 0 if not applicable
+ * @fmt: printf-style free text format string (not a stable interface)
+ * @args: arguments for the @fmt format string
+ *
+ * The log entry will be emitted with @CPER_SEV_RECOVERABLE severity.
+ */
+#define xe_log_err(any, TAG, err, fmt, args...) \
+	xe_log_comp((any), CPER_SEV_RECOVERABLE, TAG, ERR_PTR(err), 0, fmt, ##args)
+
+/**
+ * xe_log_err_fatal() - Emit a structured SIGID error log entry on the component behalf.
+ * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
+ * @TAG: the component tag to use
+ * @err: negative errno for the failing operation, or 0 if not applicable
+ * @fmt: printf-style free text format string (not a stable interface)
+ * @args: arguments for the @fmt format string
+ *
+ * The log entry will be emitted with @CPER_SEV_FATAL severity.
+ */
+#define xe_log_err_fatal(any, TAG, err, fmt, args...) \
+	xe_log_comp((any), CPER_SEV_FATAL, TAG, ERR_PTR(err), 0, fmt, ##args)
+
+/**
+ * xe_log_err_corrected() - Emit a structured SIGID error log entry on the component behalf.
+ * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
+ * @TAG: the component tag to use
+ * @err: negative errno for the failing operation, or 0 if not applicable
+ * @fmt: printf-style free text format string (not a stable interface)
+ * @args: arguments for the @fmt format string
+ *
+ * The log entry will be emitted with @CPER_SEV_CORRECTED severity.
+ */
+#define xe_log_err_corrected(any, TAG, err, fmt, args...) \
+	xe_log_comp((any), CPER_SEV_CORRECTED, TAG, ERR_PTR(err), 0, fmt, ##args)
+
+/**
+ * xe_log_info() - Emit a structured SIGID information log entry on the component behalf.
+ * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
+ * @TAG: the component tag to use
+ * @fmt: printf-style free text format string (not a stable interface)
+ * @args: arguments for the @fmt format string
+ *
+ * The log entry will be emitted with @CPER_SEV_INFORMATIONAL severity.
+ */
+#define xe_log_info(any, TAG, fmt, args...) \
+	xe_log_comp((any), CPER_SEV_INFORMATIONAL, TAG, NULL, 0, fmt, ##args)
+
 #endif
-- 
2.47.1

[PATCH v3 10/23] drm/xe/log: Add hardware error signatures

[Michal Wajdeczko]

Extend our error signatures definitions xe_sigid to cover also
hardware-originated errors and make them distinguishable from
initially defined software-initiated errors.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Yoni Levitt <yoni.levitt@intel.com>
---
v2: update comment (Sashiko)
---
 drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
index 99717fdf74a6..69cce4b45635 100644
--- a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
+++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
@@ -159,14 +159,19 @@
  * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery (reset). [RETRY]
  * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault. [COLLECT]
  * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault. [RECOVER]
+ * @XE_SIGID_HW: Generic hardware failure.
+ * @XE_SIGID_PCIE: PCIe interface errors.
+ * @XE_SIGID_DEVICE_MEMORY: Device memory errors
+ * @XE_SIGID_CORE_COMPUTE: Compute/shader core errors.
+ * @XE_SIGID_FABRIC: Fabric errors.
+ * @XE_SIGID_SOC_INTERNAL: SoC-internal errors.
  *
  * The situations the driver detects and reports in software. Values are
  * numbered sequentially, are only ever appended, and are never renumbered or
  * reused. The tag in brackets is the default resolution bucket (see the `Xe
  * Error Signatures (SIGID)`_ section).
  *
- * Firmware- and hardware-originated signatures are not listed here; they are
- * logged as reported by those layers.
+ * Firmware- and hardware-originated signatures are numbered separately.
  */
 enum xe_sigid {
 	XE_SIGID_SW			= INTEL_SIGID_GPU_XE_SOFTWARE_START,
@@ -178,6 +183,13 @@ enum xe_sigid {
 	XE_SIGID_GT_TDR			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
 	XE_SIGID_MEM_FAULT		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
 	XE_SIGID_IO_BUS			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
+
+	XE_SIGID_HW			= INTEL_SIGID_GPU_XE_HARDWARE_START,
+	XE_SIGID_PCIE			= INTEL_SIGID_GPU_XE_HARDWARE_START + 1,
+	XE_SIGID_DEVICE_MEMORY		= INTEL_SIGID_GPU_XE_HARDWARE_START + 2,
+	XE_SIGID_CORE_COMPUTE		= INTEL_SIGID_GPU_XE_HARDWARE_START + 3,
+	XE_SIGID_FABRIC			= INTEL_SIGID_GPU_XE_HARDWARE_START + 4,
+	XE_SIGID_SOC_INTERNAL		= INTEL_SIGID_GPU_XE_HARDWARE_START + 5,
 };
 
 #endif
-- 
2.47.1

[PATCH v3 12/23] drm/xe/ras: Check RAS and LOG component definitions

[Michal Wajdeczko]

While not strictly required, we want to make sure that components
definitions used by the RAS firmware are in the same fixed relation
with HW components definitions used by the LOG infrastructure to
allow code simplification. Add static asserts to enforce that.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
---
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
 drivers/gpu/drm/xe/xe_ras.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_ras.c b/drivers/gpu/drm/xe/xe_ras.c
index a31e06b8aa67..56c0c31e46fb 100644
--- a/drivers/gpu/drm/xe/xe_ras.c
+++ b/drivers/gpu/drm/xe/xe_ras.c
@@ -5,6 +5,7 @@
 
 #include "xe_device.h"
 #include "xe_drm_ras.h"
+#include "xe_log.h"
 #include "xe_pm.h"
 #include "xe_printk.h"
 #include "xe_ras.h"
@@ -45,6 +46,16 @@ enum xe_ras_component {
 	XE_RAS_COMP_MAX
 };
 
+#define CHECK_COMPONENT(RAS_COMP, LOG_COMP) \
+	static_assert(MAKE_XE_LOG_COMPONENT(HARDWARE, (RAS_COMP)) == (LOG_COMP))
+	/* make sure components definitions maintain stable relation */
+	CHECK_COMPONENT(XE_RAS_COMP_DEVICE_MEMORY, XE_LOG_COMPONENT_DEVMEM);
+	CHECK_COMPONENT(XE_RAS_COMP_CORE_COMPUTE, XE_LOG_COMPONENT_HWCORE);
+	CHECK_COMPONENT(XE_RAS_COMP_PCIE, XE_LOG_COMPONENT_PCIE);
+	CHECK_COMPONENT(XE_RAS_COMP_FABRIC, XE_LOG_COMPONENT_FABRIC);
+	CHECK_COMPONENT(XE_RAS_COMP_SOC_INTERNAL, XE_LOG_COMPONENT_SOC);
+#undef CHECK_COMPONENT
+
 /* RAS response status codes */
 enum xe_ras_response_status {
 	XE_RAS_STATUS_SUCCESS = 0,
-- 
2.47.1

[PATCH v3 13/23] drm/xe/kunit: Setup driver data in the test device

[Michal Wajdeczko]

While we have helpers pdev_to_xe_device() and kdev_to_xe_device()
to obtain the xe_device pointer from the struct device pointer or
from the struct pci_dev pointer, we must also setup the drm_device
pointer as driver data in the device to make them work.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_kunit_helpers.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/drivers/gpu/drm/xe/tests/xe_kunit_helpers.c b/drivers/gpu/drm/xe/tests/xe_kunit_helpers.c
index bc5156966ce9..27740b40c8ae 100644
--- a/drivers/gpu/drm/xe/tests/xe_kunit_helpers.c
+++ b/drivers/gpu/drm/xe/tests/xe_kunit_helpers.c
@@ -39,6 +39,10 @@ struct xe_device *xe_kunit_helper_alloc_xe_device(struct kunit *test,
 					       struct xe_device,
 					       drm, DRIVER_GEM);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xe);
+
+	dev_set_drvdata(xe->drm.dev, &xe->drm);
+	KUNIT_ASSERT_PTR_EQ(test, xe, kdev_to_xe_device(dev));
+
 	return xe;
 }
 EXPORT_SYMBOL_IF_KUNIT(xe_kunit_helper_alloc_xe_device);
-- 
2.47.1

[PATCH v3 14/23] drm/xe/tests: Add Kunit tests for xe_log

[Michal Wajdeczko]

All dmesg log lines generated by the xe_log() functions or helper
macros are expected to have a stable format. Add tests to verify
that generated output is not accidentally changed. Add demo pseudo
tests to show how to use all variants of the xe_log() helpers.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
---
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Yoni Levitt <yoni.levitt@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
v2: less demos/more tests (Michal)
v3: expect tile.id is already set (Michal)
    add invalid params test (Michal)
---
 drivers/gpu/drm/xe/tests/xe_log_kunit.c | 545 ++++++++++++++++++++++++
 drivers/gpu/drm/xe/xe_log.c             |  11 +
 2 files changed, 556 insertions(+)
 create mode 100644 drivers/gpu/drm/xe/tests/xe_log_kunit.c

diff --git a/drivers/gpu/drm/xe/tests/xe_log_kunit.c b/drivers/gpu/drm/xe/tests/xe_log_kunit.c
new file mode 100644
index 000000000000..27f3c322cc26
--- /dev/null
+++ b/drivers/gpu/drm/xe/tests/xe_log_kunit.c
@@ -0,0 +1,545 @@
+// SPDX-License-Identifier: GPL-2.0 AND MIT
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#include <kunit/static_stub.h>
+#include <kunit/test.h>
+#include <kunit/test-bug.h>
+
+#include "tests/xe_kunit_helpers.h"
+#include "tests/xe_pci_test.h"
+#include "xe_device.h"
+#include "xe_log.h"
+
+static void nop_dmesg_vprintk(struct pci_dev *pdev, int cper_sev, struct va_format *vaf)
+{
+}
+
+static void nop_emit_cper(struct pci_dev *pdev, int cper_sev,
+			  enum xe_sigid sigid, u32 component, u32 location,
+			  const void *data, size_t len, struct va_format *vaf)
+{
+}
+
+static const char *component_name(u32 component)
+{
+	switch (component) {
+#define make_component_tag_case(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return _NAME;
+	DEFINE_XE_LOG_COMPONENTS(make_component_tag_case)
+#undef make_component_tag_case
+	}
+	return component ? "???" : "";
+}
+
+static const char *location_type(u32 location)
+{
+	u32 type = FIELD_GET(XE_LOG_LOCATION_TYPE_MASK, location);
+
+	return type == XE_LOG_LOCATION_TYPE_DEVICE ? "DEVICE" :
+	       type == XE_LOG_LOCATION_TYPE_TILE ? "TILE" :
+	       type == XE_LOG_LOCATION_TYPE_GT ? "GT" :
+	       location ? "?" : "";
+}
+
+static void fake_emit_cper(struct pci_dev *pdev, int cper_sev,
+			   enum xe_sigid sigid, u32 component, u32 location,
+			   const void *data, size_t len, struct va_format *vaf)
+{
+	char msg[64];
+	int n, err;
+
+	pr_info("\n");
+	pr_info("CPER SEV=%u SIGID=%u\n", cper_sev, sigid);
+	pr_info("CPER DEVICE=%s\n", dev_name(&pdev->dev));
+	if (location)
+		pr_info("CPER LOCATION=%#x \t# %s.%u\n",
+			location, location_type(location),
+			FIELD_GET(XE_LOG_LOCATION_ID_MASK, location));
+	if (component)
+		pr_info("CPER COMPONENT=%#x \t# %s\n",
+			component, component_name(component));
+	if (IS_ERR(data)) {
+		err = PTR_ERR(data);
+		pr_info("CPER ERR=%d \t\t# %pe\n", err, data);
+	} else if (len) {
+		print_hex_dump(KERN_INFO, "CPER BIN=", DUMP_PREFIX_OFFSET,
+			       16, 1, data, len, false);
+	}
+
+	n = vscnprintf(msg, sizeof(msg), vaf->fmt, *vaf->va);
+	print_hex_dump(KERN_INFO, "CPER MSG=", DUMP_PREFIX_OFFSET, 16, 1, msg, n, true);
+	pr_info("CPER END\n");
+}
+
+static const u8 blob[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+static const u8 dead[] = { 0xde, 0xad, 0xbe, 0xef };
+
+static struct xe_tile *to_tile_safe(struct xe_device *xe)
+{
+	return xe ? &xe->tiles[1] : NULL;
+}
+
+static struct xe_gt *to_gt_safe(struct xe_device *xe)
+{
+	return xe ? to_tile_safe(xe)->primary_gt : NULL;
+}
+
+static struct pci_dev *to_pdev_safe(struct xe_device *xe)
+{
+	return xe ? xe_any_to_pdev(xe) : NULL;
+}
+
+static void demo(struct xe_device *xe)
+{
+	struct pci_dev *pdev = xe_any_to_pdev(xe);
+	struct xe_tile *tile = to_tile_safe(xe);
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	/* SW errno */
+	xe_log_emit(pdev, CPER_SEV_FATAL, XE_SIGID_PROBE,
+		    XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+		    ERR_PTR(-ENODEV), 0, "testing %s signature\n", "software");
+
+	xe_log_err(tile, PROBE, -ENODEV, "testing %s signature\n", "software");
+	xe_log_err_corrected(gt, PROBE, -ENODEV, "testing %s signature\n", "software");
+	xe_log_info(gt, PROBE, "testing %s signature\n", "software");
+
+	/* HW data */
+	xe_log_emit(pdev, CPER_SEV_FATAL, XE_SIGID_PCIE,
+		    XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+		    blob, sizeof(blob), "testing %s signature\n", "HARDWARE");
+	xe_log_emit_recoverable(pdev, XE_SIGID_FABRIC,
+				XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+				blob, sizeof(blob), "testing %s signature\n", "HARDWARE");
+	xe_log_from_corrected(tile, XE_SIGID_DEVICE_MEMORY, XE_LOG_COMPONENT_NONE,
+			      blob, sizeof(blob), "testing %s signature\n", "HARDWARE");
+	xe_log_from_info(gt, XE_SIGID_CORE_COMPUTE, XE_LOG_COMPONENT_NONE,
+			 blob, sizeof(blob), "testing %s signature\n", "HARDWARE");
+}
+
+static void demo_dmesg(struct kunit *test)
+{
+	kunit_activate_static_stub(test, log_emit_cper, nop_emit_cper);
+	demo(test->priv);
+}
+
+static void demo_cper(struct kunit *test)
+{
+	kunit_activate_static_stub(test, log_emit_cper, fake_emit_cper);
+	kunit_activate_static_stub(test, log_dmesg_vprintk, nop_dmesg_vprintk);
+	demo(test->priv);
+}
+
+static const char *test_fatal(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_emit_fatal(pdev, XE_SIGID_PROBE,
+				  XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+				  NULL, 0, "testing %d\n", 123);
+	return "SIGID=101 FATAL testing 123\n";
+}
+
+static const char *test_fatal_tile(struct xe_device *xe)
+{
+	struct xe_tile *tile = to_tile_safe(xe);
+
+	if (tile)
+		xe_log_from_fatal(tile, XE_SIGID_PROBE, XE_LOG_COMPONENT_NONE,
+				  ERR_PTR(-ENODEV), 0, "testing %d\n", 123);
+	return "SIGID=101 FATAL (-ENODEV) Tile1: testing 123\n";
+}
+
+static const char *test_fatal_gt(struct xe_device *xe)
+{
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (gt)
+		xe_log_from_fatal(gt, XE_SIGID_PROBE, XE_LOG_COMPONENT_NONE,
+				  ERR_PTR(-ENODEV), 0, "testing %d\n", 123);
+	return "SIGID=101 FATAL (-ENODEV) Tile1: GT1: testing 123\n";
+}
+
+static const char *test_fatal_comp(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_err_fatal(pdev, PROBE, -ENODEV, "testing %d\n", 123);
+	return "SIGID=101 FATAL (-ENODEV) PROBE: testing 123\n";
+}
+
+static const char *test_fatal_comp_tile(struct xe_device *xe)
+{
+	struct xe_tile *tile = to_tile_safe(xe);
+
+	if (tile)
+		xe_log_err_fatal(tile, PROBE, -ENODEV, "testing %d\n", 123);
+	return "SIGID=101 FATAL (-ENODEV) Tile1: PROBE: testing 123\n";
+}
+
+static const char *test_fatal_comp_gt(struct xe_device *xe)
+{
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (gt)
+		xe_log_err_fatal(gt, PROBE, -ENODEV, "testing %d\n", 123);
+	return "SIGID=101 FATAL (-ENODEV) Tile1: GT1: PROBE: testing 123\n";
+}
+
+static const char *test_fatal_all(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (pdev)
+		xe_log_emit(pdev, CPER_SEV_FATAL, XE_SIGID_PROBE,
+			    XE_LOG_COMPONENT_PROBE, MAKE_XE_LOG_LOCATION(GT, gt->info.id),
+			    ERR_PTR(-ENODEV), 0, "testing %d\n", 123);
+	return "SIGID=101 FATAL (-ENODEV) Tile1: GT1: PROBE: testing 123\n";
+}
+
+static const char *test_recoverable(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_emit_recoverable(pdev, XE_SIGID_RUNTIME_FW,
+					XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+					ERR_PTR(-EIO), 0, "testing %d\n", 123);
+	return "SIGID=104 (-EIO) testing 123\n";
+}
+
+static const char *test_recoverable_tile(struct xe_device *xe)
+{
+	struct xe_tile *tile = to_tile_safe(xe);
+
+	if (tile)
+		xe_log_from_recoverable(tile, XE_SIGID_RUNTIME_FW, XE_LOG_COMPONENT_NONE,
+					ERR_PTR(-EIO), 0, "testing %d\n", 123);
+	return "SIGID=104 (-EIO) Tile1: testing 123\n";
+}
+
+static const char *test_recoverable_gt(struct xe_device *xe)
+{
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (gt)
+		xe_log_from_recoverable(gt, XE_SIGID_RUNTIME_FW, XE_LOG_COMPONENT_NONE,
+					ERR_PTR(-EIO), 0, "testing %d\n", 123);
+	return "SIGID=104 (-EIO) Tile1: GT1: testing 123\n";
+}
+
+static const char *test_recoverable_comp(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_err(pdev, GUC, -EIO, "testing %d\n", 123);
+	return "SIGID=104 (-EIO) GUC: testing 123\n";
+}
+
+static const char *test_recoverable_comp_tile(struct xe_device *xe)
+{
+	struct xe_tile *tile = to_tile_safe(xe);
+
+	if (tile)
+		xe_log_err(tile, GUC, -EIO, "testing %d\n", 123);
+	return "SIGID=104 (-EIO) Tile1: GUC: testing 123\n";
+}
+
+static const char *test_recoverable_comp_gt(struct xe_device *xe)
+{
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (gt)
+		xe_log_err(gt, GUC, -EIO, "testing %d\n", 123);
+	return "SIGID=104 (-EIO) Tile1: GT1: GUC: testing 123\n";
+}
+
+static const char *test_recoverable_all(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (pdev)
+		xe_log_emit(pdev, CPER_SEV_RECOVERABLE, XE_SIGID_RUNTIME_FW,
+			    XE_LOG_COMPONENT_GUC, MAKE_XE_LOG_LOCATION(GT, gt->info.id),
+			    ERR_PTR(-EIO), 0, "testing %d\n", 123);
+	return "SIGID=104 (-EIO) Tile1: GT1: GUC: testing 123\n";
+}
+
+static const char *test_info(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_emit(pdev, CPER_SEV_INFORMATIONAL, XE_SIGID_DEVICE_FW,
+			    XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+			    NULL, 0, "testing %d\n", 123);
+	return "SIGID=105 testing 123\n";
+}
+
+static const char *test_info_tile(struct xe_device *xe)
+{
+	struct xe_tile *tile = to_tile_safe(xe);
+
+	if (tile)
+		xe_log_from_info(tile, XE_SIGID_DEVICE_FW, XE_LOG_COMPONENT_NONE,
+				 NULL, 0, "testing %d\n", 123);
+	return "SIGID=105 Tile1: testing 123\n";
+}
+
+static const char *test_info_gt(struct xe_device *xe)
+{
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (gt)
+		xe_log_from_info(gt, XE_SIGID_DEVICE_FW, XE_LOG_COMPONENT_NONE,
+				 NULL, 0, "testing %d\n", 123);
+	return "SIGID=105 Tile1: GT1: testing 123\n";
+}
+
+static const char *test_info_comp(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_info(pdev, PCODE, "testing %d\n", 123);
+	return "SIGID=105 PCODE: testing 123\n";
+}
+
+static const char *test_info_comp_tile(struct xe_device *xe)
+{
+	struct xe_tile *tile = to_tile_safe(xe);
+
+	if (tile)
+		xe_log_info(tile, PCODE, "testing %d\n", 123);
+	return "SIGID=105 Tile1: PCODE: testing 123\n";
+}
+
+static const char *test_info_comp_gt(struct xe_device *xe)
+{
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (gt)
+		xe_log_info(gt, PCODE, "testing %d\n", 123);
+	return "SIGID=105 Tile1: GT1: PCODE: testing 123\n";
+}
+
+static const char *test_info_all(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+	struct xe_gt *gt = to_gt_safe(xe);
+
+	if (pdev)
+		xe_log_emit(pdev, CPER_SEV_INFORMATIONAL, XE_SIGID_DEVICE_FW,
+			    XE_LOG_COMPONENT_PCODE, MAKE_XE_LOG_LOCATION(GT, gt->info.id),
+			    NULL, 0, "testing %d\n", 123);
+	return "SIGID=105 Tile1: GT1: PCODE: testing 123\n";
+}
+
+static const char *test_hw_fatal(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_emit_fatal(pdev, XE_SIGID_PCIE,
+				  XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+				  dead, sizeof(dead), "testing %d\n", 123);
+	return "SIGID=201 FATAL (deadbeef) " HW_ERR "testing 123\n";
+}
+
+static const char *test_hw_recoverable(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_emit_recoverable(pdev, XE_SIGID_DEVICE_MEMORY,
+					XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+					dead, sizeof(dead), "testing %d\n", 123);
+	return "SIGID=202 (deadbeef) " HW_ERR "testing 123\n";
+}
+
+static const char *test_hw_corrected(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_emit_corrected(pdev, XE_SIGID_DEVICE_MEMORY,
+				      XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+				      dead, sizeof(dead), "testing %d\n", 123);
+	return "SIGID=202 CORRECTED (deadbeef) " HW_ERR "testing 123\n";
+}
+
+static const char *test_hw_informational(struct xe_device *xe)
+{
+	struct pci_dev *pdev = to_pdev_safe(xe);
+
+	if (pdev)
+		xe_log_emit_info(pdev, XE_SIGID_DEVICE_MEMORY,
+				 XE_LOG_COMPONENT_NONE, XE_LOG_LOCATION_NONE,
+				 dead, sizeof(dead), "testing %d\n", 123);
+	return "SIGID=202 (deadbeef) testing 123\n";
+}
+
+static const struct log_test_param {
+	const char *(*func)(struct xe_device *xe);
+} log_test_params[] = {
+	{ .func = test_fatal },
+	{ .func = test_fatal_tile },
+	{ .func = test_fatal_gt },
+	{ .func = test_fatal_comp },
+	{ .func = test_fatal_comp_tile },
+	{ .func = test_fatal_comp_gt },
+	{ .func = test_fatal_all },
+	{ .func = test_recoverable },
+	{ .func = test_recoverable_tile },
+	{ .func = test_recoverable_gt },
+	{ .func = test_recoverable_comp },
+	{ .func = test_recoverable_comp_tile },
+	{ .func = test_recoverable_comp_gt },
+	{ .func = test_recoverable_all },
+	{ .func = test_info },
+	{ .func = test_info_tile },
+	{ .func = test_info_gt },
+	{ .func = test_info_comp },
+	{ .func = test_info_comp_tile },
+	{ .func = test_info_comp_gt },
+	{ .func = test_info_all },
+	{ .func = test_hw_fatal },
+	{ .func = test_hw_recoverable },
+	{ .func = test_hw_corrected },
+	{ .func = test_hw_informational },
+};
+
+static void log_param_get_desc(const struct log_test_param *p, char *desc)
+{
+	snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%ps", p->func);
+}
+
+KUNIT_ARRAY_PARAM(log, log_test_params, log_param_get_desc);
+
+static void check_dmesg_vprintk(struct pci_dev *pdev, int cper_sev, struct va_format *vaf)
+{
+	struct kunit *test = kunit_get_current_test();
+	const struct log_test_param *param = test->param_value;
+	const char *exp = param->func(NULL);
+	char msg[64];
+	int n;
+
+	n = vsnprintf(msg, sizeof(msg), vaf->fmt, *vaf->va);
+	KUNIT_EXPECT_LT(test, n, sizeof(msg));
+	KUNIT_EXPECT_STREQ(test, msg, exp);
+}
+
+static void test_dmesg(struct kunit *test)
+{
+	const struct log_test_param *param = test->param_value;
+
+	kunit_activate_static_stub(test, log_emit_cper, nop_emit_cper);
+	kunit_activate_static_stub(test, log_dmesg_vprintk, check_dmesg_vprintk);
+
+	param->func(test->priv);
+}
+
+#define INVALID_TILEID	(XE_MAX_TILES_PER_DEVICE + 1)
+#define INVALID_GTID	(XE_MAX_TILES_PER_DEVICE * XE_MAX_GT_PER_TILE + 1)
+
+#define PREP_TEST_LOCATION(type, id) \
+	(FIELD_PREP_CONST(XE_LOG_LOCATION_TYPE_MASK, (type)) | \
+	 FIELD_PREP_CONST(XE_LOG_LOCATION_ID_MASK, (id)))
+#define PREP_TEST_COMPONENT(class, type) \
+	(FIELD_PREP_CONST(XE_LOG_COMPONENT_CLASS_MASK, (class)) | \
+	 FIELD_PREP_CONST(XE_LOG_COMPONENT_TYPE_MASK, (type)))
+
+static const struct {
+	u32 comp;
+	u32 loc;
+	const char *name;
+} invalid_params[] = {
+	{	.name = "no-component no-location no-warn" },
+	{	.loc = PREP_TEST_LOCATION(0, 1),
+		.name = "reserved location" },
+	{	.loc = PREP_TEST_LOCATION(255, 0),
+		.name = "unknown location" },
+	{	.loc = PREP_TEST_LOCATION(XE_LOG_LOCATION_TYPE_DEVICE, 1),
+		.name = "nonzero-device-id location" },
+	{	.loc = PREP_TEST_LOCATION(XE_LOG_LOCATION_TYPE_TILE, INVALID_TILEID),
+		.name = "invalid-tile-id location" },
+	{	.loc = PREP_TEST_LOCATION(XE_LOG_LOCATION_TYPE_GT, INVALID_GTID),
+		.name = "invalid-gt-id location" },
+	{	.comp = PREP_TEST_COMPONENT(255, 0),
+		.name = "unknown component class" },
+	{	.comp = PREP_TEST_COMPONENT(XE_LOG_COMPONENT_CLASS_SYSTEM, 255),
+		.name = "unknown system component" },
+	{	.comp = PREP_TEST_COMPONENT(XE_LOG_COMPONENT_CLASS_HARDWARE, 255),
+		.name = "unknown hardware component" },
+	{	.comp = PREP_TEST_COMPONENT(255, 1),
+		.loc = PREP_TEST_LOCATION(255, 1),
+		.name = "unknown component and location" },
+};
+
+KUNIT_ARRAY_PARAM_DESC(invalid_param, invalid_params, name);
+
+static void test_invalid(struct kunit *test)
+{
+	struct xe_device *xe = test->priv;
+	typeof(invalid_params[0]) *param = test->param_value;
+
+	struct pci_dev *pdev = xe_any_to_pdev(xe);
+
+	if (!IS_ENABLED(CONFIG_DRM_XE_DEBUG))
+		kunit_skip(test, "requires CONFIG_DRM_XE_DEBUG\n");
+
+	kunit_activate_static_stub(test, log_emit_cper, nop_emit_cper);
+	kunit_activate_static_stub(test, log_dmesg_vprintk, nop_dmesg_vprintk);
+
+	kunit_warning_suppress(test) {
+		xe_log_emit(pdev, CPER_SEV_FATAL, XE_SIGID_PROBE,
+			param->comp, param->loc,
+			NULL, 0, "testing %s\n", param->name);
+		KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, !!param->comp + !!param->loc);
+	}
+}
+
+static int xe_log_test_init(struct kunit *test)
+{
+	struct xe_pci_fake_data fake = {
+		.platform = XE_PVC, /* with max_remote_tiles != 0 */
+		.subplatform = XE_SUBPLATFORM_NONE,
+		.graphics_verx100 = 2001,
+		.media_verx100 = 2001,
+	};
+	struct xe_device *xe;
+
+	test->priv = &fake;
+	xe_kunit_helper_xe_device_test_init(test);
+	xe = test->priv;
+
+	KUNIT_ASSERT_NOT_NULL(test, to_tile_safe(xe));
+	KUNIT_ASSERT_NOT_NULL(test, to_gt_safe(xe));
+	KUNIT_EXPECT_EQ(test, 1, xe_any_id(to_tile_safe(xe)));
+	KUNIT_EXPECT_EQ(test, 1, xe_any_id(to_gt_safe(xe)));
+
+	return 0;
+}
+
+static struct kunit_case xe_log_test_cases[] = {
+	KUNIT_CASE(demo_cper),
+	KUNIT_CASE(demo_dmesg),
+	KUNIT_CASE_PARAM(test_dmesg, log_gen_params),
+	KUNIT_CASE_PARAM(test_invalid, invalid_param_gen_params),
+	{}
+};
+
+static struct kunit_suite xe_log_suite = {
+	.name = "xe_log",
+	.test_cases = xe_log_test_cases,
+	.init = xe_log_test_init,
+};
+
+kunit_test_suites(&xe_log_suite);
diff --git a/drivers/gpu/drm/xe/xe_log.c b/drivers/gpu/drm/xe/xe_log.c
index ff6a61f1ac7c..b462e75d4ad0 100644
--- a/drivers/gpu/drm/xe/xe_log.c
+++ b/drivers/gpu/drm/xe/xe_log.c
@@ -3,6 +3,9 @@
  * Copyright © 2026 Intel Corporation
  */
 
+#include <kunit/static_stub.h>
+#include <kunit/visibility.h>
+
 #include "abi/xe_log_abi.h"
 
 #include "xe_device.h"
@@ -13,6 +16,8 @@ static void log_emit_cper(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigi
 			  u32 component, u32 location, const void *data, size_t len,
 			  struct va_format *vaf)
 {
+	KUNIT_STATIC_STUB_REDIRECT(log_emit_cper, pdev, cper_sev, sigid,
+				   component, location, data, len, vaf);
 	/* TODO */
 }
 
@@ -129,6 +134,8 @@ static const char *log_sev_prefix(int cper_sev)
 
 static void log_dmesg_vprintk(struct pci_dev *pdev, int cper_sev, struct va_format *vaf)
 {
+	KUNIT_STATIC_STUB_REDIRECT(log_dmesg_vprintk, pdev, cper_sev, vaf);
+
 	if (cper_sev == CPER_SEV_INFORMATIONAL)
 		pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
 	else
@@ -219,3 +226,7 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
 
 	va_end(args);
 }
+
+#if IS_BUILTIN(CONFIG_DRM_XE_KUNIT_TEST)
+#include "tests/xe_log_kunit.c"
+#endif
-- 
2.47.1

[PATCH v3 16/23] drm/xe: Report 'probe blocked' error using SIGID

[Michal Wajdeczko]

Report 'probe blocked' error using xe_log_info() helper.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
v2: use info severity (Aravind)
---
 drivers/gpu/drm/xe/xe_pci.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_pci.c b/drivers/gpu/drm/xe/xe_pci.c
index 36d62927b969..a3c4046b56cf 100644
--- a/drivers/gpu/drm/xe/xe_pci.c
+++ b/drivers/gpu/drm/xe/xe_pci.c
@@ -25,6 +25,7 @@
 #include "xe_gt_printk.h"
 #include "xe_gt_sriov_vf.h"
 #include "xe_guc.h"
+#include "xe_log.h"
 #include "xe_mmio.h"
 #include "xe_module.h"
 #include "xe_pci_error.h"
@@ -1172,8 +1173,8 @@ static int xe_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 	}
 
 	if (id_blocked(pdev->device)) {
-		dev_info(&pdev->dev, "Probe blocked for device [%04x:%04x].\n",
-			 pdev->vendor, pdev->device);
+		xe_log_info(pdev, PROBE, "Probe blocked for device [%04x:%04x]\n",
+			    pdev->vendor, pdev->device);
 		return -ENODEV;
 	}
 
-- 
2.47.1

[PATCH v3 17/23] drm/xe: Report 'device wedged' errors using SIGID

[Michal Wajdeczko]

Report 'device wedged' error using xe_log_err_fatal() helper.
Use -EIO as the error cause, as nothing else is provided here.
The hints about the recovery method and bug filling are now
separated as it only needs to be printed once.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
 drivers/gpu/drm/xe/xe_device.c | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_device.c b/drivers/gpu/drm/xe/xe_device.c
index 4eed9a251e65..b1e9bcd9f5b4 100644
--- a/drivers/gpu/drm/xe/xe_device.c
+++ b/drivers/gpu/drm/xe/xe_device.c
@@ -48,6 +48,7 @@
 #include "xe_i2c.h"
 #include "xe_irq.h"
 #include "xe_late_bind_fw.h"
+#include "xe_log.h"
 #include "xe_mmio.h"
 #include "xe_module.h"
 #include "xe_nvm.h"
@@ -1396,6 +1397,9 @@ void xe_device_set_wedged_method(struct xe_device *xe, unsigned long method)
 	xe->wedged.method = method;
 }
 
+#define WEDGED_URL	"https://docs.kernel.org/gpu/drm-uapi.html#device-wedging"
+#define XE_BUG_URL	"https://gitlab.freedesktop.org/drm/xe/kernel/issues/new"
+
 /**
  * xe_device_declare_wedged - Declare device wedged
  * @xe: xe device instance
@@ -1427,12 +1431,12 @@ void xe_device_declare_wedged(struct xe_device *xe)
 	if (!atomic_xchg(&xe->wedged.flag, 1)) {
 		xe->needs_flr_on_fini = true;
 		xe_pm_runtime_get_noresume(xe);
-		drm_err(&xe->drm,
-			"CRITICAL: Xe has declared device %s as wedged.\n"
-			"IOCTLs and executions are blocked.\n"
-			"For recovery procedure, refer to https://docs.kernel.org/gpu/drm-uapi.html#device-wedging\n"
-			"Please file a _new_ bug report at https://gitlab.freedesktop.org/drm/xe/kernel/issues/new\n",
-			dev_name(xe->drm.dev));
+
+		xe_log_err_fatal(xe, WEDGED, -EIO, "Device declared wedged!\n");
+		xe_err_once(xe, "IOCTLs and executions are now blocked!\n"
+			    "For recovery procedure, refer to %s\n"
+			    "Please file a _new_ bug report at %s\n",
+			    WEDGED_URL, XE_BUG_URL);
 	}
 
 	for_each_gt(gt, xe, id)
-- 
2.47.1

[PATCH v3 18/23] drm/xe: Report 'Survivability Mode' errors using SIGID

[Michal Wajdeczko]

Report various 'Survivability Mode' errors using xe_log() helpers.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Riana Tauro <riana.tauro@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
 drivers/gpu/drm/xe/xe_survivability_mode.c | 24 +++++++++++++---------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_survivability_mode.c b/drivers/gpu/drm/xe/xe_survivability_mode.c
index 4c506027fa94..788b7e8137a9 100644
--- a/drivers/gpu/drm/xe/xe_survivability_mode.c
+++ b/drivers/gpu/drm/xe/xe_survivability_mode.c
@@ -14,9 +14,11 @@
 #include "xe_device.h"
 #include "xe_heci_gsc.h"
 #include "xe_i2c.h"
+#include "xe_log.h"
 #include "xe_mmio.h"
 #include "xe_nvm.h"
 #include "xe_pcode_api.h"
+#include "xe_printk.h"
 #include "xe_vsec.h"
 
 /**
@@ -179,11 +181,11 @@ static void log_survivability_info(struct pci_dev *pdev)
 	u32 *info = survivability->info;
 	int id;
 
-	dev_info(&pdev->dev, "Survivability Boot Status : Critical Failure (%d)\n",
-		 survivability->boot_status);
+	xe_log_info(xe, SURVIVABILITY, "Boot Status : Critical Failure (%d)\n",
+		    survivability->boot_status);
 	for (id = 0; id < MAX_SCRATCH_REG; id++) {
 		if (info[id])
-			dev_info(&pdev->dev, "%s: 0x%x\n", reg_map[id], info[id]);
+			xe_log_info(xe, SURVIVABILITY, "%s: 0x%x\n", reg_map[id], info[id]);
 	}
 }
 
@@ -316,7 +318,6 @@ static int create_survivability_sysfs(struct pci_dev *pdev)
 
 static int enable_boot_survivability_mode(struct pci_dev *pdev)
 {
-	struct device *dev = &pdev->dev;
 	struct xe_device *xe = pdev_to_xe_device(pdev);
 	struct xe_survivability *survivability = &xe->survivability;
 	int ret = 0;
@@ -342,12 +343,12 @@ static int enable_boot_survivability_mode(struct pci_dev *pdev)
 	if (ret)
 		goto err;
 
-	dev_err(dev, "In Survivability Mode\n");
-
+	xe_log_emit(pdev, check_boot_failure(xe) ? CPER_SEV_FATAL : CPER_SEV_INFORMATIONAL,
+		    XE_SIGID_SURVIVABILITY, 0, 0, 0, 0, "In Survivability Boot Mode\n");
 	return 0;
 
 err:
-	dev_err(dev, "Failed to enable Survivability Mode\n");
+	xe_log_err_fatal(xe, SURVIVABILITY, ret, "Failed to enable Survivability Mode\n");
 	survivability->mode = false;
 	return ret;
 }
@@ -412,7 +413,7 @@ void xe_survivability_mode_runtime_enable(struct xe_device *xe)
 	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
 
 	if (!IS_DGFX(xe) || IS_SRIOV_VF(xe) || xe->info.platform < XE_BATTLEMAGE) {
-		dev_err(&pdev->dev, "Runtime Survivability Mode not supported\n");
+		xe_log_info(xe, SURVIVABILITY, "Runtime Mode not supported!\n");
 		return;
 	}
 
@@ -422,11 +423,14 @@ void xe_survivability_mode_runtime_enable(struct xe_device *xe)
 		dev_err(&pdev->dev, "Failed to create survivability sysfs\n");
 
 	survivability->type = XE_SURVIVABILITY_TYPE_RUNTIME;
-	dev_err(&pdev->dev, "Runtime Survivability mode enabled\n");
+	xe_log_err_fatal(xe, SURVIVABILITY, 0, "Runtime Mode enabled!\n");
 
 	xe_device_set_wedged_method(xe, DRM_WEDGE_RECOVERY_VENDOR);
 	xe_device_declare_wedged(xe);
-	dev_err(&pdev->dev, "Firmware flash required, Please refer to the userspace documentation for more details!\n");
+
+	xe_log_err_fatal(xe, SURVIVABILITY, 0, "Firmware flash required!\n");
+	xe_info(xe, "Please refer to the userspace documentation for more details how to flash the firmware on %s!\n",
+		xe->info.platform_name);
 }
 
 /**
-- 
2.47.1

[PATCH v3 20/23] drm/xe/pcode: Report 'Mailbox failed' error using SIGID

[Michal Wajdeczko]

Report 'Mailbox failed' error using xe_log() helper.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Riana Tauro <riana.tauro@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
 drivers/gpu/drm/xe/xe_pcode.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_pcode.c b/drivers/gpu/drm/xe/xe_pcode.c
index ccc3bdeed6bb..014632e11338 100644
--- a/drivers/gpu/drm/xe/xe_pcode.c
+++ b/drivers/gpu/drm/xe/xe_pcode.c
@@ -14,6 +14,7 @@
 #include "regs/xe_pmt.h"
 #include "xe_assert.h"
 #include "xe_device.h"
+#include "xe_log.h"
 #include "xe_mmio.h"
 #include "xe_pcode_api.h"
 #include "xe_pm.h"
@@ -61,9 +62,7 @@ static int pcode_mailbox_status(struct xe_tile *tile)
 	}
 
 	if (err) {
-		drm_err(&tile_to_xe(tile)->drm, "PCODE Mailbox failed: %d %s",
-			err_decode, err_str);
-
+		xe_log_err(tile, PCODE, err_decode, "Mailbox failed: %s\n", err_str);
 		return err_decode;
 	}
 
-- 
2.47.1

[PATCH v3 22/23] drm/xe/gt: Report 'pagefault' errors using SIGID

[Michal Wajdeczko]

Report 'Queue full/Unsuccessful response' pagefault errors using
xe_log() helpers.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Matthew Brost <matthew.brost@intel.com>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
 drivers/gpu/drm/xe/xe_pagefault.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_pagefault.c b/drivers/gpu/drm/xe/xe_pagefault.c
index dd3c068e1a39..e78c855759e1 100644
--- a/drivers/gpu/drm/xe/xe_pagefault.c
+++ b/drivers/gpu/drm/xe/xe_pagefault.c
@@ -14,6 +14,7 @@
 #include "xe_gt_types.h"
 #include "xe_gt_stats.h"
 #include "xe_hw_engine.h"
+#include "xe_log.h"
 #include "xe_pagefault.h"
 #include "xe_pagefault_types.h"
 #include "xe_svm.h"
@@ -309,8 +310,7 @@ static void xe_pagefault_queue_work(struct work_struct *w)
 			xe_pagefault_save_to_vm(gt_to_xe(pf.gt), &pf);
 			if (!(pf.consumer.access_type & XE_PAGEFAULT_ACCESS_PREFETCH)) {
 				xe_pagefault_print(&pf);
-				xe_gt_info(pf.gt, "Fault response: Unsuccessful %pe\n",
-					   ERR_PTR(err));
+				xe_log_err(pf.gt, PAGEFAULT, err, "Fault response: Unsuccessful\n");
 			} else {
 				xe_gt_stats_incr(pf.gt, XE_GT_STATS_ID_INVALID_PREFETCH_PAGEFAULT_COUNT, 1);
 				xe_gt_dbg(pf.gt, "Prefetch Fault response: Unsuccessful %pe\n",
@@ -487,9 +487,9 @@ int xe_pagefault_handler(struct xe_device *xe, struct xe_pagefault *pf)
 			pf_queue->size;
 		queue_work(xe->usm.pf_wq, &pf_queue->worker);
 	} else {
-		drm_warn(&xe->drm,
-			 "PageFault Queue (%d) full, shouldn't be possible\n",
-			 pf->consumer.asid % XE_PAGEFAULT_QUEUE_COUNT);
+		xe_log_err(xe, PAGEFAULT, -ENOSPC,
+			   "Queue (%d) full, shouldn't be possible\n",
+			   pf->consumer.asid % XE_PAGEFAULT_QUEUE_COUNT);
 	}
 	spin_unlock_irqrestore(&pf_queue->lock, flags);
 
-- 
2.47.1

[PATCH v3 23/23] drm/xe/pci: Report 'cannot re-enable' error using SIGID

[Michal Wajdeczko]

Report 'cannot re-enable PCI device' error using xe_log() helper.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Riana Tauro <riana.tauro@intel.com>
Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
---
 drivers/gpu/drm/xe/xe_pci_error.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_pci_error.c b/drivers/gpu/drm/xe/xe_pci_error.c
index e41af2ac7f23..fb965f52be5e 100644
--- a/drivers/gpu/drm/xe/xe_pci_error.c
+++ b/drivers/gpu/drm/xe/xe_pci_error.c
@@ -7,6 +7,7 @@
 
 #include "xe_device.h"
 #include "xe_gt.h"
+#include "xe_log.h"
 #include "xe_pci.h"
 #include "xe_pm.h"
 #include "xe_printk.h"
@@ -90,13 +91,15 @@ static pci_ers_result_t xe_pci_error_slot_reset(struct pci_dev *pdev)
 {
 	const struct pci_device_id *ent = pci_match_id(pdev->driver->id_table, pdev);
 	struct xe_device *xe = pdev_to_xe_device(pdev);
+	int err;
 
 	xe_info(xe, "PCI error: slot reset\n");
 
 	pci_restore_state(pdev);
 
-	if (pci_enable_device(pdev)) {
-		xe_err(xe, "Cannot re-enable PCI device after reset\n");
+	err = pci_enable_device(pdev);
+	if (err) {
+		xe_log_err_fatal(xe, PCI, err, "Cannot re-enable PCI device after reset\n");
 		return PCI_ERS_RESULT_DISCONNECT;
 	}
 
-- 
2.47.1

✗ CI.checkpatch: warning for drm/xe: Add structured SIGID error logging infrastructure (rev3)

[Patchwork]

== Series Details ==

Series: drm/xe: Add structured SIGID error logging infrastructure (rev3)
URL   : https://patchwork.freedesktop.org/series/171022/
State : warning

== Summary ==

+ KERNEL=/kernel
+ git clone https://gitlab.freedesktop.org/drm/maintainer-tools mt
Cloning into 'mt'...
warning: redirecting to https://gitlab.freedesktop.org/drm/maintainer-tools.git/
+ git -C mt rev-list -n1 origin/master
061140b9bc586ae7f40abc1249c97e1cc72d1b9d
+ cd /kernel
+ git config --global --add safe.directory /kernel
+ git log -n1
commit 134863cf20fd6c0391fd8f7ea3dca2b4c6d42d8a
Author: Michal Wajdeczko <michal.wajdeczko@intel.com>
Date:   Thu Jul 30 17:21:19 2026 +0200

    drm/xe/pci: Report 'cannot re-enable' error using SIGID
    
    Report 'cannot re-enable PCI device' error using xe_log() helper.
    
    Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
    Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
    Cc: Riana Tauro <riana.tauro@intel.com>
    Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
    Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
+ /mt/dim checkpatch 5e24f68d311764bf343f9def49b752b509dfd5fd drm-intel
1104637ebb9d drm/xe: Introduce xe_any helpers
-:24: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#24: 
new file mode 100644

-:39: ERROR:COMPLEX_MACRO: Macros with complex values should be enclosed in parentheses
#39: FILE: drivers/gpu/drm/xe/xe_any.h:11:
+#define __xe_any_to_self_assoc(type, any) \
+	const type * : (any), \
+	type * : (any)

BUT SEE:

   do {} while (0) advice is over-stated in a few situations:

   The more obvious case is macros, like MODULE_PARM_DESC, invoked at
   file-scope, where C disallows code (it must be in functions).  See
   $exceptions if you have one to add by name.

   More troublesome is declarative macros used at top of new scope,
   like DECLARE_PER_CPU.  These might just compile with a do-while-0
   wrapper, but would be incorrect.  Most of these are handled by
   detecting struct,union,etc declaration primitives in $exceptions.

   Theres also macros called inside an if (block), which "return" an
   expression.  These cannot do-while, and need a ({}) wrapper.

   Enjoy this qualification while we work to improve our heuristics.

-:39: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'any' - possible side-effects?
#39: FILE: drivers/gpu/drm/xe/xe_any.h:11:
+#define __xe_any_to_self_assoc(type, any) \
+	const type * : (any), \
+	type * : (any)

-:50: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'any' - possible side-effects?
#50: FILE: drivers/gpu/drm/xe/xe_any.h:22:
+#define xe_any_if_type(any, type)						\
+	_Generic((any),								\
+		 __xe_any_to_self_assoc(type, (any)),				\
+		 default : NULL)

-:53: WARNING:TABSTOP: Statements should start on a tabstop
#53: FILE: drivers/gpu/drm/xe/xe_any.h:25:
+		 default : NULL)

-:53: ERROR:TRAILING_STATEMENTS: trailing statements should be on next line
#53: FILE: drivers/gpu/drm/xe/xe_any.h:25:
+		 default : NULL)

-:87: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'const' - possible side-effects?
#87: FILE: drivers/gpu/drm/xe/xe_any.h:59:
+#define __xe_any_to_other_assoc(const, from, other, p) \
+	const struct from * : __##from##_to_##other((const struct from *)(p))

-:87: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'from' - possible side-effects?
#87: FILE: drivers/gpu/drm/xe/xe_any.h:59:
+#define __xe_any_to_other_assoc(const, from, other, p) \
+	const struct from * : __##from##_to_##other((const struct from *)(p))

-:87: CHECK:MACRO_ARG_PRECEDENCE: Macro argument 'from' may be better as '(from)' to avoid precedence issues
#87: FILE: drivers/gpu/drm/xe/xe_any.h:59:
+#define __xe_any_to_other_assoc(const, from, other, p) \
+	const struct from * : __##from##_to_##other((const struct from *)(p))

-:103: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'any' - possible side-effects?
#103: FILE: drivers/gpu/drm/xe/xe_any.h:75:
+#define xe_any_to_xe(any)							\
+	_Generic((any),								\
+		 __xe_any_to_self_assoc(struct xe_device, (any)),		\
+		 __xe_any_to_other_assoc(/* */, xe_tile, xe_device, (any)),	\
+		 __xe_any_to_other_assoc(const, xe_tile, xe_device, (any)),	\
+		 __xe_any_to_other_assoc(/* */, xe_gt, xe_device, (any)),	\
+		 __xe_any_to_other_assoc(const, xe_gt, xe_device, (any)),	\
+		 __xe_any_to_other_assoc(, drm_device, xe_device, (any)),	\
+		 __xe_any_to_other_assoc(, pci_dev, xe_device, (any)),		\
+		 __xe_any_to_other_assoc(, device, xe_device, (any)))

-:120: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'any' - possible side-effects?
#120: FILE: drivers/gpu/drm/xe/xe_any.h:92:
+#define xe_any_to_drm(any)							\
+	_Generic((any),								\
+		 __xe_any_to_self_assoc(struct drm_device, (any)),		\
+		 default : &xe_any_to_xe(any)->drm)

-:123: WARNING:TABSTOP: Statements should start on a tabstop
#123: FILE: drivers/gpu/drm/xe/xe_any.h:95:
+		 default : &xe_any_to_xe(any)->drm)

-:123: ERROR:TRAILING_STATEMENTS: trailing statements should be on next line
#123: FILE: drivers/gpu/drm/xe/xe_any.h:95:
+		 default : &xe_any_to_xe(any)->drm)

-:131: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'any' - possible side-effects?
#131: FILE: drivers/gpu/drm/xe/xe_any.h:103:
+#define xe_any_to_dev(any)							\
+	_Generic((any),								\
+		 __xe_any_to_self_assoc(struct device, (any)),			\
+		 __xe_any_to_other_assoc(, pci_dev, device, (any)),		\
+		 default : xe_any_to_drm(any)->dev)

-:135: WARNING:TABSTOP: Statements should start on a tabstop
#135: FILE: drivers/gpu/drm/xe/xe_any.h:107:
+		 default : xe_any_to_drm(any)->dev)

-:135: ERROR:TRAILING_STATEMENTS: trailing statements should be on next line
#135: FILE: drivers/gpu/drm/xe/xe_any.h:107:
+		 default : xe_any_to_drm(any)->dev)

-:143: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'any' - possible side-effects?
#143: FILE: drivers/gpu/drm/xe/xe_any.h:115:
+#define xe_any_to_pdev(any)							\
+	_Generic((any),								\
+		 __xe_any_to_self_assoc(struct pci_dev, (any)),			\
+		 default : to_pci_dev(xe_any_to_dev(any)))

-:146: WARNING:TABSTOP: Statements should start on a tabstop
#146: FILE: drivers/gpu/drm/xe/xe_any.h:118:
+		 default : to_pci_dev(xe_any_to_dev(any)))

-:146: ERROR:TRAILING_STATEMENTS: trailing statements should be on next line
#146: FILE: drivers/gpu/drm/xe/xe_any.h:118:
+		 default : to_pci_dev(xe_any_to_dev(any)))

-:157: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'any' - possible side-effects?
#157: FILE: drivers/gpu/drm/xe/xe_any.h:129:
+#define xe_any_id(any)								\
+	_Generic((any),								\
+		 __xe_any_to_other_assoc(/* */, xe_tile, id, (any)),		\
+		 __xe_any_to_other_assoc(const, xe_tile, id, (any)),		\
+		 __xe_any_to_other_assoc(/* */, xe_gt, id, (any)),		\
+		 __xe_any_to_other_assoc(const, xe_gt, id, (any)),		\
+		 default : 0)

-:163: WARNING:TABSTOP: Statements should start on a tabstop
#163: FILE: drivers/gpu/drm/xe/xe_any.h:135:
+		 default : 0)

-:163: ERROR:TRAILING_STATEMENTS: trailing statements should be on next line
#163: FILE: drivers/gpu/drm/xe/xe_any.h:135:
+		 default : 0)

total: 6 errors, 6 warnings, 10 checks, 137 lines checked
2e9b4150b3a0 drm/xe/log: Add structured SIGID error logging infrastructure
-:35: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#35: 
new file mode 100644

total: 0 errors, 1 warnings, 0 checks, 363 lines checked
01c2ec090967 drm/xe/log: Introduce structured component/location identifiers
-:17: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#17: 
new file mode 100644

-:152: ERROR:COMPLEX_MACRO: Macros with complex values should be enclosed in parentheses
#152: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:131:
+#define DEFINE_XE_LOG_COMPONENTS(define) \
+	/* */									\
+	define(SYSTEM, 1, PCI, SW, "Linux PCI Subsystem")			\
+	define(SYSTEM, 2, DRM, SW, "DRM")					\
+	/* */									\
+	define(DRIVER, 1, XE, SW, "Xe Driver")					\
+	define(DRIVER, 2, PROBE, PROBE, "Driver Initialization")		\
+	define(DRIVER, 3, WEDGED, WEDGED, "Device Malfunction")			\
+	define(DRIVER, 4, RTP, SW, "Register Table Processing")			\
+	define(DRIVER, 5, WA, SW, "Workarounds")				\
+	define(DRIVER, 6, PAGEFAULT, MEM_FAULT, "Page Fault")			\
+	/* */									\
+	define(DRIVER_HARDWARE, 1, REGS, IO_BUS, "Registers")			\
+	define(DRIVER_HARDWARE, 2, GGTT, IO_BUS, "Global GTT")			\
+	define(DRIVER_HARDWARE, 3, GT, GT_TDR, "Graphics Technology")		\
+	define(DRIVER_HARDWARE, 4, LMTT, IO_BUS, "LMEM Translation Table")	\
+	define(DRIVER_HARDWARE, 5, MEMIRQ, IO_BUS, "Memory Based IRQ")		\
+	/* */									\
+	define(DRIVER_FEATURE, 1, PF, SW, "SR-IOV Physical Function")		\
+	define(DRIVER_FEATURE, 2, VF, SW, "SR-IOV Virtual Function")		\
+	define(DRIVER_FEATURE, 3, SURVIVABILITY, SURVIVABILITY, "Survivability") \
+	define(DRIVER_FEATURE, 4, RAS, SW, "Reliability, Accessibility, Serviceability") \
+	/* */									\
+	define(DRIVER_FIRMWARE, 1, GUC, RUNTIME_FW, "GuC")			\
+	define(DRIVER_FIRMWARE, 2, HUC, RUNTIME_FW, "HuC")			\
+	define(DRIVER_FIRMWARE, 3, GSC, RUNTIME_FW, "GSC")			\
+	define(DRIVER_FIRMWARE, 16, PCODE, DEVICE_FW, "PCode")			\
+	define(DRIVER_FIRMWARE, 17, SYSCTRL, DEVICE_FW, "System Controller")	\
+	/* eod */

BUT SEE:

   do {} while (0) advice is over-stated in a few situations:

   The more obvious case is macros, like MODULE_PARM_DESC, invoked at
   file-scope, where C disallows code (it must be in functions).  See
   $exceptions if you have one to add by name.

   More troublesome is declarative macros used at top of new scope,
   like DECLARE_PER_CPU.  These might just compile with a do-while-0
   wrapper, but would be incorrect.  Most of these are handled by
   detecting struct,union,etc declaration primitives in $exceptions.

   Theres also macros called inside an if (block), which "return" an
   expression.  These cannot do-while, and need a ({}) wrapper.

   Enjoy this qualification while we work to improve our heuristics.

-:152: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'define' - possible side-effects?
#152: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:131:
+#define DEFINE_XE_LOG_COMPONENTS(define) \
+	/* */									\
+	define(SYSTEM, 1, PCI, SW, "Linux PCI Subsystem")			\
+	define(SYSTEM, 2, DRM, SW, "DRM")					\
+	/* */									\
+	define(DRIVER, 1, XE, SW, "Xe Driver")					\
+	define(DRIVER, 2, PROBE, PROBE, "Driver Initialization")		\
+	define(DRIVER, 3, WEDGED, WEDGED, "Device Malfunction")			\
+	define(DRIVER, 4, RTP, SW, "Register Table Processing")			\
+	define(DRIVER, 5, WA, SW, "Workarounds")				\
+	define(DRIVER, 6, PAGEFAULT, MEM_FAULT, "Page Fault")			\
+	/* */									\
+	define(DRIVER_HARDWARE, 1, REGS, IO_BUS, "Registers")			\
+	define(DRIVER_HARDWARE, 2, GGTT, IO_BUS, "Global GTT")			\
+	define(DRIVER_HARDWARE, 3, GT, GT_TDR, "Graphics Technology")		\
+	define(DRIVER_HARDWARE, 4, LMTT, IO_BUS, "LMEM Translation Table")	\
+	define(DRIVER_HARDWARE, 5, MEMIRQ, IO_BUS, "Memory Based IRQ")		\
+	/* */									\
+	define(DRIVER_FEATURE, 1, PF, SW, "SR-IOV Physical Function")		\
+	define(DRIVER_FEATURE, 2, VF, SW, "SR-IOV Virtual Function")		\
+	define(DRIVER_FEATURE, 3, SURVIVABILITY, SURVIVABILITY, "Survivability") \
+	define(DRIVER_FEATURE, 4, RAS, SW, "Reliability, Accessibility, Serviceability") \
+	/* */									\
+	define(DRIVER_FIRMWARE, 1, GUC, RUNTIME_FW, "GuC")			\
+	define(DRIVER_FIRMWARE, 2, HUC, RUNTIME_FW, "HuC")			\
+	define(DRIVER_FIRMWARE, 3, GSC, RUNTIME_FW, "GSC")			\
+	define(DRIVER_FIRMWARE, 16, PCODE, DEVICE_FW, "PCode")			\
+	define(DRIVER_FIRMWARE, 17, SYSCTRL, DEVICE_FW, "System Controller")	\
+	/* eod */

-:187: ERROR:COMPLEX_MACRO: Macros with complex values should be enclosed in parentheses
#187: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:166:
+#define MAKE_XE_LOG_COMPONENT_ENUM(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	XE_LOG_COMPONENT_##_TAG = MAKE_XE_LOG_COMPONENT(_CLASS, (_ID)), \
+	XE_LOG_COMPONENT_##_CLASS##_##_ID = XE_LOG_COMPONENT_##_TAG, \
+	/* eod */

BUT SEE:

   do {} while (0) advice is over-stated in a few situations:

   The more obvious case is macros, like MODULE_PARM_DESC, invoked at
   file-scope, where C disallows code (it must be in functions).  See
   $exceptions if you have one to add by name.

   More troublesome is declarative macros used at top of new scope,
   like DECLARE_PER_CPU.  These might just compile with a do-while-0
   wrapper, but would be incorrect.  Most of these are handled by
   detecting struct,union,etc declaration primitives in $exceptions.

   Theres also macros called inside an if (block), which "return" an
   expression.  These cannot do-while, and need a ({}) wrapper.

   Enjoy this qualification while we work to improve our heuristics.

-:187: WARNING:MACRO_ARG_UNUSED: Argument '_SIG' is not used in function-like macro
#187: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:166:
+#define MAKE_XE_LOG_COMPONENT_ENUM(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	XE_LOG_COMPONENT_##_TAG = MAKE_XE_LOG_COMPONENT(_CLASS, (_ID)), \
+	XE_LOG_COMPONENT_##_CLASS##_##_ID = XE_LOG_COMPONENT_##_TAG, \
+	/* eod */

-:187: WARNING:MACRO_ARG_UNUSED: Argument '_NAME' is not used in function-like macro
#187: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:166:
+#define MAKE_XE_LOG_COMPONENT_ENUM(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	XE_LOG_COMPONENT_##_TAG = MAKE_XE_LOG_COMPONENT(_CLASS, (_ID)), \
+	XE_LOG_COMPONENT_##_CLASS##_##_ID = XE_LOG_COMPONENT_##_TAG, \
+	/* eod */

-:200: ERROR:COMPLEX_MACRO: Macros with complex values should be enclosed in parentheses
#200: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:179:
+#define MAKE_XE_LOG_COMPONENT_SIGID(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	XE_LOG_COMPONENT_##_TAG##_SIGID = XE_SIGID_##_SIG, \
+	/* eod */

BUT SEE:

   do {} while (0) advice is over-stated in a few situations:

   The more obvious case is macros, like MODULE_PARM_DESC, invoked at
   file-scope, where C disallows code (it must be in functions).  See
   $exceptions if you have one to add by name.

   More troublesome is declarative macros used at top of new scope,
   like DECLARE_PER_CPU.  These might just compile with a do-while-0
   wrapper, but would be incorrect.  Most of these are handled by
   detecting struct,union,etc declaration primitives in $exceptions.

   Theres also macros called inside an if (block), which "return" an
   expression.  These cannot do-while, and need a ({}) wrapper.

   Enjoy this qualification while we work to improve our heuristics.

-:200: WARNING:MACRO_ARG_UNUSED: Argument '_CLASS' is not used in function-like macro
#200: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:179:
+#define MAKE_XE_LOG_COMPONENT_SIGID(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	XE_LOG_COMPONENT_##_TAG##_SIGID = XE_SIGID_##_SIG, \
+	/* eod */

-:200: WARNING:MACRO_ARG_UNUSED: Argument '_ID' is not used in function-like macro
#200: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:179:
+#define MAKE_XE_LOG_COMPONENT_SIGID(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	XE_LOG_COMPONENT_##_TAG##_SIGID = XE_SIGID_##_SIG, \
+	/* eod */

-:200: WARNING:MACRO_ARG_UNUSED: Argument '_NAME' is not used in function-like macro
#200: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:179:
+#define MAKE_XE_LOG_COMPONENT_SIGID(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	XE_LOG_COMPONENT_##_TAG##_SIGID = XE_SIGID_##_SIG, \
+	/* eod */

total: 3 errors, 6 warnings, 1 checks, 186 lines checked
a71ac3694436 drm/xe/log: Add component/location decorations to dmesg
-:40: WARNING:TRAILING_SEMICOLON: macros should not use a trailing semicolon
#40: FILE: drivers/gpu/drm/xe/xe_log.c:26:
+#define MAKE_XE_LOG_COMPONENT_CLASS_PREFIX(_CLASS) \
+	case XE_LOG_COMPONENT_CLASS_##_CLASS: return #_CLASS "? ";

-:55: WARNING:MACRO_ARG_UNUSED: Argument '_CLASS' is not used in function-like macro
#55: FILE: drivers/gpu/drm/xe/xe_log.c:41:
+#define MAKE_XE_LOG_COMPONENT_CASE_PREFIX(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return #_TAG ": ";

-:55: WARNING:MACRO_ARG_UNUSED: Argument '_ID' is not used in function-like macro
#55: FILE: drivers/gpu/drm/xe/xe_log.c:41:
+#define MAKE_XE_LOG_COMPONENT_CASE_PREFIX(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return #_TAG ": ";

-:55: WARNING:MACRO_ARG_UNUSED: Argument '_SIG' is not used in function-like macro
#55: FILE: drivers/gpu/drm/xe/xe_log.c:41:
+#define MAKE_XE_LOG_COMPONENT_CASE_PREFIX(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return #_TAG ": ";

-:55: WARNING:MACRO_ARG_UNUSED: Argument '_NAME' is not used in function-like macro
#55: FILE: drivers/gpu/drm/xe/xe_log.c:41:
+#define MAKE_XE_LOG_COMPONENT_CASE_PREFIX(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return #_TAG ": ";

-:55: WARNING:TRAILING_SEMICOLON: macros should not use a trailing semicolon
#55: FILE: drivers/gpu/drm/xe/xe_log.c:41:
+#define MAKE_XE_LOG_COMPONENT_CASE_PREFIX(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return #_TAG ": ";

total: 0 errors, 6 warnings, 0 checks, 126 lines checked
e0ddd154a05d drm/xe/log: Add SIGID log helpers for severity
8196ff7a09c5 drm/xe/log: Add SIGID log helpers for location
-:44: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'any' - possible side-effects?
#44: FILE: drivers/gpu/drm/xe/xe_log.h:49:
+#define xe_log_location(any) \
+	PREP_XE_LOG_LOCATION(xe_log_location_type(any), xe_any_id(any))

total: 0 errors, 0 warnings, 1 checks, 47 lines checked
72c346c194d9 drm/xe/log: Add SIGID log helpers for location & severity
0fe82a8702af drm/xe/log: Add SIGID log helpers for components
6c4987878ea9 drm/xe/log: Add SIGID log helpers for errno-only
5828bebeeab1 drm/xe/log: Add hardware error signatures
94da8c283f42 drm/xe/log: Extend components list with hardware items
-:23: ERROR:COMPLEX_MACRO: Macros with complex values should be enclosed in parentheses
#23: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:135:
+#define DEFINE_XE_LOG_SOFTWARE_COMPONENTS(define) \
 	/* */									\
 	define(SYSTEM, 1, PCI, SW, "Linux PCI Subsystem")			\
 	define(SYSTEM, 2, DRM, SW, "DRM")					\

BUT SEE:

   do {} while (0) advice is over-stated in a few situations:

   The more obvious case is macros, like MODULE_PARM_DESC, invoked at
   file-scope, where C disallows code (it must be in functions).  See
   $exceptions if you have one to add by name.

   More troublesome is declarative macros used at top of new scope,
   like DECLARE_PER_CPU.  These might just compile with a do-while-0
   wrapper, but would be incorrect.  Most of these are handled by
   detecting struct,union,etc declaration primitives in $exceptions.

   Theres also macros called inside an if (block), which "return" an
   expression.  These cannot do-while, and need a ({}) wrapper.

   Enjoy this qualification while we work to improve our heuristics.

-:23: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'define' - possible side-effects?
#23: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:135:
+#define DEFINE_XE_LOG_SOFTWARE_COMPONENTS(define) \
 	/* */									\
 	define(SYSTEM, 1, PCI, SW, "Linux PCI Subsystem")			\
 	define(SYSTEM, 2, DRM, SW, "DRM")					\

-:32: ERROR:COMPLEX_MACRO: Macros with complex values should be enclosed in parentheses
#32: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:164:
+#define DEFINE_XE_LOG_HARDWARE_COMPONENTS(define) \
+	define(HARDWARE, 1, DEVMEM, DEVICE_MEMORY, "Device Memory")		\
+	define(HARDWARE, 2, HWCORE, CORE_COMPUTE, "Core Compute")		\
+	/*     HARDWARE, 3, RESERVED */						\
+	define(HARDWARE, 4, PCIE, PCIE, "PCIe Interface")			\
+	define(HARDWARE, 5, FABRIC, FABRIC, "Fabric")				\
+	define(HARDWARE, 6, SOC, SOC_INTERNAL, "SoC Internal")			\
 	/* eod */

BUT SEE:

   do {} while (0) advice is over-stated in a few situations:

   The more obvious case is macros, like MODULE_PARM_DESC, invoked at
   file-scope, where C disallows code (it must be in functions).  See
   $exceptions if you have one to add by name.

   More troublesome is declarative macros used at top of new scope,
   like DECLARE_PER_CPU.  These might just compile with a do-while-0
   wrapper, but would be incorrect.  Most of these are handled by
   detecting struct,union,etc declaration primitives in $exceptions.

   Theres also macros called inside an if (block), which "return" an
   expression.  These cannot do-while, and need a ({}) wrapper.

   Enjoy this qualification while we work to improve our heuristics.

-:32: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'define' - possible side-effects?
#32: FILE: drivers/gpu/drm/xe/abi/xe_log_abi.h:164:
+#define DEFINE_XE_LOG_HARDWARE_COMPONENTS(define) \
+	define(HARDWARE, 1, DEVMEM, DEVICE_MEMORY, "Device Memory")		\
+	define(HARDWARE, 2, HWCORE, CORE_COMPUTE, "Core Compute")		\
+	/*     HARDWARE, 3, RESERVED */						\
+	define(HARDWARE, 4, PCIE, PCIE, "PCIe Interface")			\
+	define(HARDWARE, 5, FABRIC, FABRIC, "Fabric")				\
+	define(HARDWARE, 6, SOC, SOC_INTERNAL, "SoC Internal")			\
 	/* eod */

total: 2 errors, 0 warnings, 2 checks, 24 lines checked
d2d2d640a48f drm/xe/ras: Check RAS and LOG component definitions
06331dd4fcaf drm/xe/kunit: Setup driver data in the test device
fa4405457be7 drm/xe/tests: Add Kunit tests for xe_log
-:15: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#15: 
new file mode 100644

-:47: WARNING:MACRO_ARG_UNUSED: Argument '_CLASS' is not used in function-like macro
#47: FILE: drivers/gpu/drm/xe/tests/xe_log_kunit.c:28:
+#define make_component_tag_case(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return _NAME;

-:47: WARNING:MACRO_ARG_UNUSED: Argument '_ID' is not used in function-like macro
#47: FILE: drivers/gpu/drm/xe/tests/xe_log_kunit.c:28:
+#define make_component_tag_case(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return _NAME;

-:47: WARNING:MACRO_ARG_UNUSED: Argument '_SIG' is not used in function-like macro
#47: FILE: drivers/gpu/drm/xe/tests/xe_log_kunit.c:28:
+#define make_component_tag_case(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return _NAME;

-:47: WARNING:TRAILING_SEMICOLON: macros should not use a trailing semicolon
#47: FILE: drivers/gpu/drm/xe/tests/xe_log_kunit.c:28:
+#define make_component_tag_case(_CLASS, _ID, _TAG, _SIG, _NAME) \
+	case XE_LOG_COMPONENT_##_TAG: return _NAME;

-:522: CHECK:PARENTHESIS_ALIGNMENT: Alignment should match open parenthesis
#522: FILE: drivers/gpu/drm/xe/tests/xe_log_kunit.c:503:
+		xe_log_emit(pdev, CPER_SEV_FATAL, XE_SIGID_PROBE,
+			param->comp, param->loc,

total: 0 errors, 5 warnings, 1 checks, 577 lines checked
13223ad8afe9 drm/xe/tests: Add kunit tests for xe_any
-:24: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#24: 
new file mode 100644

total: 0 errors, 1 warnings, 0 checks, 195 lines checked
f9fc901a845b drm/xe: Report 'probe blocked' error using SIGID
55171a73c3d5 drm/xe: Report 'device wedged' errors using SIGID
a90d1ad6f571 drm/xe: Report 'Survivability Mode' errors using SIGID
f504a12a26da drm/xe/guc: Report 'GuC mmio' errors using SIGID
4b1ef0ba18fc drm/xe/pcode: Report 'Mailbox failed' error using SIGID
e658f45ffc9f drm/xe/gt: Report 'reset failed' errors using SIGID
93f9798b6dc3 drm/xe/gt: Report 'pagefault' errors using SIGID
134863cf20fd drm/xe/pci: Report 'cannot re-enable' error using SIGID

✓ CI.KUnit: success for drm/xe: Add structured SIGID error logging infrastructure (rev3)

[Patchwork]

== Series Details ==

Series: drm/xe: Add structured SIGID error logging infrastructure (rev3)
URL   : https://patchwork.freedesktop.org/series/171022/
State : success

== Summary ==

+ trap cleanup EXIT
+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig
[15:40:30] Configuring KUnit Kernel ...
Generating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[15:40:35] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[15:41:06] Starting KUnit Kernel (1/1)...
[15:41:06] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[15:41:07] ================== guc_buf (11 subtests) ===================
[15:41:07] [PASSED] test_smallest
[15:41:07] [PASSED] test_largest
[15:41:07] [PASSED] test_granular
[15:41:07] [PASSED] test_unique
[15:41:07] [PASSED] test_overlap
[15:41:07] [PASSED] test_reusable
[15:41:07] [PASSED] test_too_big
[15:41:07] [PASSED] test_flush
[15:41:07] [PASSED] test_lookup
[15:41:07] [PASSED] test_data
[15:41:07] [PASSED] test_class
[15:41:07] ===================== [PASSED] guc_buf =====================
[15:41:07] =================== guc_dbm (7 subtests) ===================
[15:41:07] [PASSED] test_empty
[15:41:07] [PASSED] test_default
[15:41:07] ======================== test_size  ========================
[15:41:07] [PASSED] 4
[15:41:07] [PASSED] 8
[15:41:07] [PASSED] 32
[15:41:07] [PASSED] 256
[15:41:07] ==================== [PASSED] test_size ====================
[15:41:07] ======================= test_reuse  ========================
[15:41:07] [PASSED] 4
[15:41:07] [PASSED] 8
[15:41:07] [PASSED] 32
[15:41:07] [PASSED] 256
[15:41:07] =================== [PASSED] test_reuse ====================
[15:41:07] =================== test_range_overlap  ====================
[15:41:07] [PASSED] 4
[15:41:07] [PASSED] 8
[15:41:07] [PASSED] 32
[15:41:07] [PASSED] 256
[15:41:07] =============== [PASSED] test_range_overlap ================
[15:41:07] =================== test_range_compact  ====================
[15:41:07] [PASSED] 4
[15:41:07] [PASSED] 8
[15:41:07] [PASSED] 32
[15:41:07] [PASSED] 256
[15:41:07] =============== [PASSED] test_range_compact ================
[15:41:07] ==================== test_range_spare  =====================
[15:41:07] [PASSED] 4
[15:41:07] [PASSED] 8
[15:41:07] [PASSED] 32
[15:41:07] [PASSED] 256
[15:41:07] ================ [PASSED] test_range_spare =================
[15:41:07] ===================== [PASSED] guc_dbm =====================
[15:41:07] =================== guc_idm (6 subtests) ===================
[15:41:07] [PASSED] bad_init
[15:41:07] [PASSED] no_init
[15:41:07] [PASSED] init_fini
[15:41:07] [PASSED] check_used
[15:41:07] [PASSED] check_quota
[15:41:07] [PASSED] check_all
[15:41:07] ===================== [PASSED] guc_idm =====================
[15:41:07] =============== guc_klv_helpers (9 subtests) ===============
[15:41:07] [PASSED] test_count
[15:41:07] [PASSED] test_encode_u32
[15:41:07] [PASSED] test_encode_u64
[15:41:07] [PASSED] test_encode_string
[15:41:07] [PASSED] test_encode_object_raw
[15:41:07] [PASSED] test_encode_object_klv
[15:41:07] [PASSED] test_encode_object_nested
[15:41:07] [PASSED] test_encode_object_basic
[15:41:07] [PASSED] test_print
[15:41:07] ================= [PASSED] guc_klv_helpers =================
[15:41:07] =================== xe_log (4 subtests) ====================
[15:41:07] [PASSED] demo_cper
[15:41:07] [PASSED] demo_dmesg
[15:41:07] ======================= test_dmesg  ========================
[15:41:07] [PASSED] test_fatal
[15:41:07] [PASSED] test_fatal_tile
[15:41:07] [PASSED] test_fatal_gt
[15:41:07] [PASSED] test_fatal_comp
[15:41:07] [PASSED] test_fatal_comp_tile
[15:41:07] [PASSED] test_fatal_comp_gt
[15:41:07] [PASSED] test_fatal_all
[15:41:07] [PASSED] test_recoverable
[15:41:07] [PASSED] test_recoverable_tile
[15:41:07] [PASSED] test_recoverable_gt
[15:41:07] [PASSED] test_recoverable_comp
[15:41:07] [PASSED] test_recoverable_comp_tile
[15:41:07] [PASSED] test_recoverable_comp_gt
[15:41:07] [PASSED] test_recoverable_all
[15:41:07] [PASSED] test_info
[15:41:07] [PASSED] test_info_tile
[15:41:07] [PASSED] test_info_gt
[15:41:07] [PASSED] test_info_comp
[15:41:07] [PASSED] test_info_comp_tile
[15:41:07] [PASSED] test_info_comp_gt
[15:41:07] [PASSED] test_info_all
[15:41:07] [PASSED] test_hw_fatal
[15:41:07] [PASSED] test_hw_recoverable
[15:41:07] [PASSED] test_hw_corrected
[15:41:07] [PASSED] test_hw_informational
[15:41:07] =================== [PASSED] test_dmesg ====================
[15:41:07] ====================== test_invalid  =======================
[15:41:07] [SKIPPED] no-component no-location no-warn (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] reserved location (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] unknown location (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] nonzero-device-id location (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] invalid-tile-id location (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] invalid-gt-id location (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] unknown component class (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] unknown system component (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] unknown hardware component (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] [SKIPPED] unknown component and location (requires CONFIG_DRM_XE_DEBUG)
[15:41:07] ================== [SKIPPED] test_invalid ==================
[15:41:07] ===================== [PASSED] xe_log ======================
[15:41:07] ================== no_relay (3 subtests) ===================
[15:41:07] [PASSED] xe_drops_guc2pf_if_not_ready
[15:41:07] [PASSED] xe_drops_guc2vf_if_not_ready
[15:41:07] [PASSED] xe_rejects_send_if_not_ready
[15:41:07] ==================== [PASSED] no_relay =====================
[15:41:07] ================== pf_relay (14 subtests) ==================
[15:41:07] [PASSED] pf_rejects_guc2pf_too_short
[15:41:07] [PASSED] pf_rejects_guc2pf_too_long
[15:41:07] [PASSED] pf_rejects_guc2pf_no_payload
[15:41:07] [PASSED] pf_fails_no_payload
[15:41:07] [PASSED] pf_fails_bad_origin
[15:41:07] [PASSED] pf_fails_bad_type
[15:41:07] [PASSED] pf_txn_reports_error
[15:41:07] [PASSED] pf_txn_sends_pf2guc
[15:41:07] [PASSED] pf_sends_pf2guc
[15:41:07] [SKIPPED] pf_loopback_nop (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[15:41:07] [SKIPPED] pf_loopback_echo (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[15:41:07] [SKIPPED] pf_loopback_fail (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[15:41:07] [SKIPPED] pf_loopback_busy (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[15:41:07] [SKIPPED] pf_loopback_retry (requires CONFIG_DRM_XE_DEBUG_SRIOV)
[15:41:07] ==================== [PASSED] pf_relay =====================
[15:41:07] ================== vf_relay (3 subtests) ===================
[15:41:07] [PASSED] vf_rejects_guc2vf_too_short
[15:41:07] [PASSED] vf_rejects_guc2vf_too_long
[15:41:07] [PASSED] vf_rejects_guc2vf_no_payload
[15:41:07] ==================== [PASSED] vf_relay =====================
[15:41:07] ================ pf_gt_config (9 subtests) =================
[15:41:07] [PASSED] fair_contexts_1vf
[15:41:07] [PASSED] fair_doorbells_1vf
[15:41:07] [PASSED] fair_ggtt_1vf
[15:41:07] ====================== fair_vram_1vf  ======================
[15:41:07] [PASSED] 3.50 GiB
[15:41:07] [PASSED] 11.5 GiB
[15:41:07] [PASSED] 15.5 GiB
[15:41:07] [PASSED] 31.5 GiB
[15:41:07] [PASSED] 63.5 GiB
[15:41:07] [PASSED] 1.91 GiB
[15:41:07] ================== [PASSED] fair_vram_1vf ==================
[15:41:07] ================ fair_vram_1vf_admin_only  =================
[15:41:07] [PASSED] 3.50 GiB
[15:41:07] [PASSED] 11.5 GiB
[15:41:07] [PASSED] 15.5 GiB
[15:41:07] [PASSED] 31.5 GiB
[15:41:07] [PASSED] 63.5 GiB
[15:41:07] [PASSED] 1.91 GiB
[15:41:07] ============ [PASSED] fair_vram_1vf_admin_only =============
[15:41:07] ====================== fair_contexts  ======================
[15:41:07] [PASSED] 1 VF
[15:41:07] [PASSED] 2 VFs
[15:41:07] [PASSED] 3 VFs
[15:41:07] [PASSED] 4 VFs
[15:41:07] [PASSED] 5 VFs
[15:41:07] [PASSED] 6 VFs
[15:41:07] [PASSED] 7 VFs
[15:41:07] [PASSED] 8 VFs
[15:41:07] [PASSED] 9 VFs
[15:41:07] [PASSED] 10 VFs
[15:41:07] [PASSED] 11 VFs
[15:41:07] [PASSED] 12 VFs
[15:41:07] [PASSED] 13 VFs
[15:41:07] [PASSED] 14 VFs
[15:41:07] [PASSED] 15 VFs
[15:41:07] [PASSED] 16 VFs
[15:41:07] [PASSED] 17 VFs
[15:41:07] [PASSED] 18 VFs
[15:41:07] [PASSED] 19 VFs
[15:41:07] [PASSED] 20 VFs
[15:41:07] [PASSED] 21 VFs
[15:41:07] [PASSED] 22 VFs
[15:41:07] [PASSED] 23 VFs
[15:41:07] [PASSED] 24 VFs
[15:41:07] [PASSED] 25 VFs
[15:41:07] [PASSED] 26 VFs
[15:41:07] [PASSED] 27 VFs
[15:41:07] [PASSED] 28 VFs
[15:41:07] [PASSED] 29 VFs
[15:41:07] [PASSED] 30 VFs
[15:41:07] [PASSED] 31 VFs
[15:41:07] [PASSED] 32 VFs
[15:41:07] [PASSED] 33 VFs
[15:41:07] [PASSED] 34 VFs
[15:41:07] [PASSED] 35 VFs
[15:41:07] [PASSED] 36 VFs
[15:41:07] [PASSED] 37 VFs
[15:41:07] [PASSED] 38 VFs
[15:41:07] [PASSED] 39 VFs
[15:41:07] [PASSED] 40 VFs
[15:41:07] [PASSED] 41 VFs
[15:41:07] [PASSED] 42 VFs
[15:41:07] [PASSED] 43 VFs
[15:41:07] [PASSED] 44 VFs
[15:41:07] [PASSED] 45 VFs
[15:41:07] [PASSED] 46 VFs
[15:41:07] [PASSED] 47 VFs
[15:41:07] [PASSED] 48 VFs
[15:41:07] [PASSED] 49 VFs
[15:41:07] [PASSED] 50 VFs
[15:41:07] [PASSED] 51 VFs
[15:41:07] [PASSED] 52 VFs
[15:41:07] [PASSED] 53 VFs
[15:41:07] [PASSED] 54 VFs
[15:41:07] [PASSED] 55 VFs
[15:41:07] [PASSED] 56 VFs
[15:41:07] [PASSED] 57 VFs
[15:41:07] [PASSED] 58 VFs
[15:41:07] [PASSED] 59 VFs
[15:41:07] [PASSED] 60 VFs
[15:41:07] [PASSED] 61 VFs
[15:41:07] [PASSED] 62 VFs
[15:41:07] [PASSED] 63 VFs
[15:41:07] ================== [PASSED] fair_contexts ==================
[15:41:07] ===================== fair_doorbells  ======================
[15:41:07] [PASSED] 1 VF
[15:41:07] [PASSED] 2 VFs
[15:41:07] [PASSED] 3 VFs
[15:41:07] [PASSED] 4 VFs
[15:41:07] [PASSED] 5 VFs
[15:41:07] [PASSED] 6 VFs
[15:41:07] [PASSED] 7 VFs
[15:41:07] [PASSED] 8 VFs
[15:41:07] [PASSED] 9 VFs
[15:41:07] [PASSED] 10 VFs
[15:41:07] [PASSED] 11 VFs
[15:41:07] [PASSED] 12 VFs
[15:41:07] [PASSED] 13 VFs
[15:41:07] [PASSED] 14 VFs
[15:41:07] [PASSED] 15 VFs
[15:41:07] [PASSED] 16 VFs
[15:41:07] [PASSED] 17 VFs
[15:41:07] [PASSED] 18 VFs
[15:41:07] [PASSED] 19 VFs
[15:41:07] [PASSED] 20 VFs
[15:41:07] [PASSED] 21 VFs
[15:41:07] [PASSED] 22 VFs
[15:41:07] [PASSED] 23 VFs
[15:41:07] [PASSED] 24 VFs
[15:41:07] [PASSED] 25 VFs
[15:41:07] [PASSED] 26 VFs
[15:41:07] [PASSED] 27 VFs
[15:41:07] [PASSED] 28 VFs
[15:41:07] [PASSED] 29 VFs
[15:41:07] [PASSED] 30 VFs
[15:41:07] [PASSED] 31 VFs
[15:41:07] [PASSED] 32 VFs
[15:41:07] [PASSED] 33 VFs
[15:41:07] [PASSED] 34 VFs
[15:41:07] [PASSED] 35 VFs
[15:41:07] [PASSED] 36 VFs
[15:41:07] [PASSED] 37 VFs
[15:41:07] [PASSED] 38 VFs
[15:41:07] [PASSED] 39 VFs
[15:41:07] [PASSED] 40 VFs
[15:41:07] [PASSED] 41 VFs
[15:41:07] [PASSED] 42 VFs
[15:41:07] [PASSED] 43 VFs
[15:41:07] [PASSED] 44 VFs
[15:41:07] [PASSED] 45 VFs
[15:41:07] [PASSED] 46 VFs
[15:41:07] [PASSED] 47 VFs
[15:41:07] [PASSED] 48 VFs
[15:41:07] [PASSED] 49 VFs
[15:41:07] [PASSED] 50 VFs
[15:41:07] [PASSED] 51 VFs
[15:41:07] [PASSED] 52 VFs
[15:41:07] [PASSED] 53 VFs
[15:41:07] [PASSED] 54 VFs
[15:41:07] [PASSED] 55 VFs
[15:41:07] [PASSED] 56 VFs
[15:41:07] [PASSED] 57 VFs
[15:41:07] [PASSED] 58 VFs
[15:41:07] [PASSED] 59 VFs
[15:41:07] [PASSED] 60 VFs
[15:41:07] [PASSED] 61 VFs
[15:41:07] [PASSED] 62 VFs
[15:41:07] [PASSED] 63 VFs
[15:41:07] ================= [PASSED] fair_doorbells ==================
[15:41:07] ======================== fair_ggtt  ========================
[15:41:07] [PASSED] 1 VF
[15:41:07] [PASSED] 2 VFs
[15:41:07] [PASSED] 3 VFs
[15:41:07] [PASSED] 4 VFs
[15:41:07] [PASSED] 5 VFs
[15:41:07] [PASSED] 6 VFs
[15:41:07] [PASSED] 7 VFs
[15:41:07] [PASSED] 8 VFs
[15:41:07] [PASSED] 9 VFs
[15:41:07] [PASSED] 10 VFs
[15:41:07] [PASSED] 11 VFs
[15:41:07] [PASSED] 12 VFs
[15:41:07] [PASSED] 13 VFs
[15:41:07] [PASSED] 14 VFs
[15:41:07] [PASSED] 15 VFs
[15:41:07] [PASSED] 16 VFs
[15:41:07] [PASSED] 17 VFs
[15:41:07] [PASSED] 18 VFs
[15:41:07] [PASSED] 19 VFs
[15:41:07] [PASSED] 20 VFs
[15:41:07] [PASSED] 21 VFs
[15:41:07] [PASSED] 22 VFs
[15:41:07] [PASSED] 23 VFs
[15:41:07] [PASSED] 24 VFs
[15:41:07] [PASSED] 25 VFs
[15:41:07] [PASSED] 26 VFs
[15:41:07] [PASSED] 27 VFs
[15:41:07] [PASSED] 28 VFs
[15:41:07] [PASSED] 29 VFs
[15:41:07] [PASSED] 30 VFs
[15:41:07] [PASSED] 31 VFs
[15:41:07] [PASSED] 32 VFs
[15:41:07] [PASSED] 33 VFs
[15:41:07] [PASSED] 34 VFs
[15:41:07] [PASSED] 35 VFs
[15:41:07] [PASSED] 36 VFs
[15:41:07] [PASSED] 37 VFs
[15:41:07] [PASSED] 38 VFs
[15:41:07] [PASSED] 39 VFs
[15:41:07] [PASSED] 40 VFs
[15:41:07] [PASSED] 41 VFs
[15:41:07] [PASSED] 42 VFs
[15:41:07] [PASSED] 43 VFs
[15:41:07] [PASSED] 44 VFs
[15:41:07] [PASSED] 45 VFs
[15:41:07] [PASSED] 46 VFs
[15:41:07] [PASSED] 47 VFs
[15:41:07] [PASSED] 48 VFs
[15:41:07] [PASSED] 49 VFs
[15:41:07] [PASSED] 50 VFs
[15:41:07] [PASSED] 51 VFs
[15:41:07] [PASSED] 52 VFs
[15:41:07] [PASSED] 53 VFs
[15:41:07] [PASSED] 54 VFs
[15:41:07] [PASSED] 55 VFs
[15:41:07] [PASSED] 56 VFs
[15:41:07] [PASSED] 57 VFs
[15:41:07] [PASSED] 58 VFs
[15:41:07] [PASSED] 59 VFs
[15:41:07] [PASSED] 60 VFs
[15:41:07] [PASSED] 61 VFs
[15:41:07] [PASSED] 62 VFs
[15:41:07] [PASSED] 63 VFs
[15:41:07] ==================== [PASSED] fair_ggtt ====================
[15:41:07] ======================== fair_vram  ========================
[15:41:07] [PASSED] 1 VF
[15:41:07] [PASSED] 2 VFs
[15:41:07] [PASSED] 3 VFs
[15:41:07] [PASSED] 4 VFs
[15:41:07] [PASSED] 5 VFs
[15:41:07] [PASSED] 6 VFs
[15:41:07] [PASSED] 7 VFs
[15:41:07] [PASSED] 8 VFs
[15:41:07] [PASSED] 9 VFs
[15:41:07] [PASSED] 10 VFs
[15:41:07] [PASSED] 11 VFs
[15:41:07] [PASSED] 12 VFs
[15:41:07] [PASSED] 13 VFs
[15:41:07] [PASSED] 14 VFs
[15:41:07] [PASSED] 15 VFs
[15:41:07] [PASSED] 16 VFs
[15:41:07] [PASSED] 17 VFs
[15:41:07] [PASSED] 18 VFs
[15:41:07] [PASSED] 19 VFs
[15:41:07] [PASSED] 20 VFs
[15:41:07] [PASSED] 21 VFs
[15:41:07] [PASSED] 22 VFs
[15:41:07] [PASSED] 23 VFs
[15:41:07] [PASSED] 24 VFs
[15:41:07] [PASSED] 25 VFs
[15:41:07] [PASSED] 26 VFs
[15:41:07] [PASSED] 27 VFs
[15:41:07] [PASSED] 28 VFs
[15:41:07] [PASSED] 29 VFs
[15:41:07] [PASSED] 30 VFs
[15:41:07] [PASSED] 31 VFs
[15:41:07] [PASSED] 32 VFs
[15:41:07] [PASSED] 33 VFs
[15:41:07] [PASSED] 34 VFs
[15:41:07] [PASSED] 35 VFs
[15:41:07] [PASSED] 36 VFs
[15:41:07] [PASSED] 37 VFs
[15:41:07] [PASSED] 38 VFs
[15:41:07] [PASSED] 39 VFs
[15:41:07] [PASSED] 40 VFs
[15:41:07] [PASSED] 41 VFs
[15:41:07] [PASSED] 42 VFs
[15:41:07] [PASSED] 43 VFs
[15:41:07] [PASSED] 44 VFs
[15:41:07] [PASSED] 45 VFs
[15:41:07] [PASSED] 46 VFs
[15:41:07] [PASSED] 47 VFs
[15:41:07] [PASSED] 48 VFs
[15:41:07] [PASSED] 49 VFs
[15:41:07] [PASSED] 50 VFs
[15:41:07] [PASSED] 51 VFs
[15:41:07] [PASSED] 52 VFs
[15:41:07] [PASSED] 53 VFs
[15:41:07] [PASSED] 54 VFs
[15:41:07] [PASSED] 55 VFs
[15:41:07] [PASSED] 56 VFs
[15:41:07] [PASSED] 57 VFs
[15:41:07] [PASSED] 58 VFs
[15:41:07] [PASSED] 59 VFs
[15:41:07] [PASSED] 60 VFs
[15:41:07] [PASSED] 61 VFs
[15:41:07] [PASSED] 62 VFs
[15:41:07] [PASSED] 63 VFs
[15:41:07] ==================== [PASSED] fair_vram ====================
[15:41:07] ================== [PASSED] pf_gt_config ===================
[15:41:07] ===================== lmtt (1 subtest) =====================
[15:41:07] ======================== test_ops  =========================
[15:41:07] [PASSED] 2-level
[15:41:07] [PASSED] multi-level
[15:41:07] ==================== [PASSED] test_ops =====================
[15:41:07] ====================== [PASSED] lmtt =======================
[15:41:07] ================= sriov_packet (1 subtest) =================
[15:41:07] [PASSED] test_descriptor_init
[15:41:07] ================== [PASSED] sriov_packet ===================
[15:41:07] ================= pf_service (11 subtests) =================
[15:41:07] [PASSED] pf_negotiate_any
[15:41:07] [PASSED] pf_negotiate_base_match
[15:41:07] [PASSED] pf_negotiate_base_newer
[15:41:07] [PASSED] pf_negotiate_base_next
[15:41:07] [SKIPPED] pf_negotiate_base_older (no older minor)
[15:41:07] [PASSED] pf_negotiate_base_prev
[15:41:07] [PASSED] pf_negotiate_latest_match
[15:41:07] [PASSED] pf_negotiate_latest_newer
[15:41:07] [PASSED] pf_negotiate_latest_next
[15:41:07] [SKIPPED] pf_negotiate_latest_older (no older minor)
[15:41:07] [SKIPPED] pf_negotiate_latest_prev (no prev major)
[15:41:07] =================== [PASSED] pf_service ====================
[15:41:07] ================= xe_guc_g2g (2 subtests) ==================
[15:41:07] ============== xe_live_guc_g2g_kunit_default  ==============
[15:41:07] ========= [SKIPPED] xe_live_guc_g2g_kunit_default ==========
[15:41:07] ============== xe_live_guc_g2g_kunit_allmem  ===============
[15:41:07] ========== [SKIPPED] xe_live_guc_g2g_kunit_allmem ==========
[15:41:07] =================== [SKIPPED] xe_guc_g2g ===================
[15:41:07] =================== xe_mocs (2 subtests) ===================
[15:41:07] ================ xe_live_mocs_kernel_kunit  ================
[15:41:07] =========== [SKIPPED] xe_live_mocs_kernel_kunit ============
[15:41:07] ================ xe_live_mocs_reset_kunit  =================
[15:41:07] ============ [SKIPPED] xe_live_mocs_reset_kunit ============
[15:41:07] ==================== [SKIPPED] xe_mocs =====================
[15:41:07] ================= xe_migrate (2 subtests) ==================
[15:41:07] ================= xe_migrate_sanity_kunit  =================
[15:41:07] ============ [SKIPPED] xe_migrate_sanity_kunit =============
[15:41:07] ================== xe_validate_ccs_kunit  ==================
[15:41:07] ============= [SKIPPED] xe_validate_ccs_kunit ==============
[15:41:07] =================== [SKIPPED] xe_migrate ===================
[15:41:07] ================== xe_dma_buf (1 subtest) ==================
[15:41:07] ==================== xe_dma_buf_kunit  =====================
[15:41:07] ================ [SKIPPED] xe_dma_buf_kunit ================
[15:41:07] =================== [SKIPPED] xe_dma_buf ===================
[15:41:07] ================= xe_bo_shrink (1 subtest) =================
[15:41:07] =================== xe_bo_shrink_kunit  ====================
[15:41:07] =============== [SKIPPED] xe_bo_shrink_kunit ===============
[15:41:07] ================== [SKIPPED] xe_bo_shrink ==================
[15:41:07] ==================== xe_bo (2 subtests) ====================
[15:41:07] ================== xe_ccs_migrate_kunit  ===================
[15:41:07] ============== [SKIPPED] xe_ccs_migrate_kunit ==============
[15:41:07] ==================== xe_bo_evict_kunit  ====================
[15:41:07] =============== [SKIPPED] xe_bo_evict_kunit ================
[15:41:07] ===================== [SKIPPED] xe_bo ======================
[15:41:07] =================== xe_any (8 subtests) ====================
[15:41:07] [PASSED] test_to_xe
[15:41:07] [PASSED] test_to_dev
[15:41:07] [PASSED] test_to_pdev
[15:41:07] [PASSED] test_to_drm
[15:41:07] [PASSED] test_if_xe
[15:41:07] [PASSED] test_if_tile
[15:41:07] [PASSED] test_if_gt
[15:41:07] [PASSED] test_to_id
[15:41:07] ===================== [PASSED] xe_any ======================
[15:41:07] ==================== args (13 subtests) ====================
[15:41:07] [PASSED] count_args_test
[15:41:07] [PASSED] call_args_example
[15:41:07] [PASSED] call_args_test
[15:41:07] [PASSED] drop_first_arg_example
[15:41:07] [PASSED] drop_first_arg_test
[15:41:07] [PASSED] first_arg_example
[15:41:07] [PASSED] first_arg_test
[15:41:07] [PASSED] last_arg_example
[15:41:07] [PASSED] last_arg_test
[15:41:07] [PASSED] pick_arg_example
[15:41:07] [PASSED] if_args_example
[15:41:07] [PASSED] if_args_test
[15:41:07] [PASSED] sep_comma_example
[15:41:07] ====================== [PASSED] args =======================
[15:41:07] =================== xe_pci (3 subtests) ====================
[15:41:07] ==================== check_graphics_ip  ====================
[15:41:07] [PASSED] 12.00 Xe_LP
[15:41:07] [PASSED] 12.10 Xe_LP+
[15:41:07] [PASSED] 12.55 Xe_HPG
[15:41:07] [PASSED] 12.60 Xe_HPC
[15:41:07] [PASSED] 12.70 Xe_LPG
[15:41:07] [PASSED] 12.71 Xe_LPG
[15:41:07] [PASSED] 12.74 Xe_LPG+
[15:41:07] [PASSED] 20.01 Xe2_HPG
[15:41:07] [PASSED] 20.02 Xe2_HPG
[15:41:07] [PASSED] 20.04 Xe2_LPG
[15:41:07] [PASSED] 30.00 Xe3_LPG
[15:41:07] [PASSED] 30.01 Xe3_LPG
[15:41:07] [PASSED] 30.03 Xe3_LPG
[15:41:07] [PASSED] 30.04 Xe3_LPG
[15:41:07] [PASSED] 30.05 Xe3_LPG
[15:41:07] [PASSED] 35.10 Xe3p_LPG
[15:41:07] [PASSED] 35.11 Xe3p_XPC
[15:41:07] ================ [PASSED] check_graphics_ip ================
[15:41:07] ===================== check_media_ip  ======================
[15:41:07] [PASSED] 12.00 Xe_M
[15:41:07] [PASSED] 12.55 Xe_HPM
[15:41:07] [PASSED] 13.00 Xe_LPM+
[15:41:07] [PASSED] 13.01 Xe2_HPM
[15:41:07] [PASSED] 20.00 Xe2_LPM
[15:41:07] [PASSED] 30.00 Xe3_LPM
[15:41:07] [PASSED] 30.02 Xe3_LPM
[15:41:07] [PASSED] 35.00 Xe3p_LPM
[15:41:07] [PASSED] 35.03 Xe3p_HPM
[15:41:07] ================= [PASSED] check_media_ip ==================
[15:41:07] =================== check_platform_desc  ===================
[15:41:07] [PASSED] 0x9A60 (TIGERLAKE)
[15:41:07] [PASSED] 0x9A68 (TIGERLAKE)
[15:41:07] [PASSED] 0x9A70 (TIGERLAKE)
[15:41:07] [PASSED] 0x9A40 (TIGERLAKE)
[15:41:07] [PASSED] 0x9A49 (TIGERLAKE)
[15:41:07] [PASSED] 0x9A59 (TIGERLAKE)
[15:41:07] [PASSED] 0x9A78 (TIGERLAKE)
[15:41:07] [PASSED] 0x9AC0 (TIGERLAKE)
[15:41:07] [PASSED] 0x9AC9 (TIGERLAKE)
[15:41:07] [PASSED] 0x9AD9 (TIGERLAKE)
[15:41:07] [PASSED] 0x9AF8 (TIGERLAKE)
[15:41:07] [PASSED] 0x4C80 (ROCKETLAKE)
[15:41:07] [PASSED] 0x4C8A (ROCKETLAKE)
[15:41:07] [PASSED] 0x4C8B (ROCKETLAKE)
[15:41:07] [PASSED] 0x4C8C (ROCKETLAKE)
[15:41:07] [PASSED] 0x4C90 (ROCKETLAKE)
[15:41:07] [PASSED] 0x4C9A (ROCKETLAKE)
[15:41:07] [PASSED] 0x4680 (ALDERLAKE_S)
[15:41:07] [PASSED] 0x4682 (ALDERLAKE_S)
[15:41:07] [PASSED] 0x4688 (ALDERLAKE_S)
[15:41:07] [PASSED] 0x468A (ALDERLAKE_S)
[15:41:07] [PASSED] 0x468B (ALDERLAKE_S)
[15:41:07] [PASSED] 0x4690 (ALDERLAKE_S)
[15:41:07] [PASSED] 0x4692 (ALDERLAKE_S)
[15:41:07] [PASSED] 0x4693 (ALDERLAKE_S)
[15:41:07] [PASSED] 0x46A0 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46A1 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46A2 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46A3 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46A6 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46A8 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46AA (ALDERLAKE_P)
[15:41:07] [PASSED] 0x462A (ALDERLAKE_P)
[15:41:07] [PASSED] 0x4626 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x4628 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46B0 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46B1 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46B2 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46B3 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46C0 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46C1 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46C2 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46C3 (ALDERLAKE_P)
[15:41:07] [PASSED] 0x46D0 (ALDERLAKE_N)
[15:41:07] [PASSED] 0x46D1 (ALDERLAKE_N)
[15:41:07] [PASSED] 0x46D2 (ALDERLAKE_N)
[15:41:07] [PASSED] 0x46D3 (ALDERLAKE_N)
[15:41:07] [PASSED] 0x46D4 (ALDERLAKE_N)
[15:41:07] [PASSED] 0xA721 (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA7A1 (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA7A9 (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA7AC (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA7AD (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA720 (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA7A0 (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA7A8 (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA7AA (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA7AB (ALDERLAKE_P)
[15:41:07] [PASSED] 0xA780 (ALDERLAKE_S)
[15:41:07] [PASSED] 0xA781 (ALDERLAKE_S)
[15:41:07] [PASSED] 0xA782 (ALDERLAKE_S)
[15:41:07] [PASSED] 0xA783 (ALDERLAKE_S)
[15:41:07] [PASSED] 0xA788 (ALDERLAKE_S)
[15:41:07] [PASSED] 0xA789 (ALDERLAKE_S)
[15:41:07] [PASSED] 0xA78A (ALDERLAKE_S)
[15:41:07] [PASSED] 0xA78B (ALDERLAKE_S)
[15:41:07] [PASSED] 0x4905 (DG1)
[15:41:07] [PASSED] 0x4906 (DG1)
[15:41:07] [PASSED] 0x4907 (DG1)
[15:41:07] [PASSED] 0x4908 (DG1)
[15:41:07] [PASSED] 0x4909 (DG1)
[15:41:07] [PASSED] 0x56C0 (DG2)
[15:41:07] [PASSED] 0x56C2 (DG2)
[15:41:07] [PASSED] 0x56C1 (DG2)
[15:41:07] [PASSED] 0x7D51 (METEORLAKE)
[15:41:07] [PASSED] 0x7DD1 (METEORLAKE)
[15:41:07] [PASSED] 0x7D41 (METEORLAKE)
[15:41:07] [PASSED] 0x7D67 (METEORLAKE)
[15:41:07] [PASSED] 0xB640 (METEORLAKE)
[15:41:07] [PASSED] 0x56A0 (DG2)
[15:41:07] [PASSED] 0x56A1 (DG2)
[15:41:07] [PASSED] 0x56A2 (DG2)
[15:41:07] [PASSED] 0x56BE (DG2)
[15:41:07] [PASSED] 0x56BF (DG2)
[15:41:07] [PASSED] 0x5690 (DG2)
[15:41:07] [PASSED] 0x5691 (DG2)
[15:41:07] [PASSED] 0x5692 (DG2)
[15:41:07] [PASSED] 0x56A5 (DG2)
[15:41:07] [PASSED] 0x56A6 (DG2)
[15:41:07] [PASSED] 0x56B0 (DG2)
[15:41:07] [PASSED] 0x56B1 (DG2)
[15:41:07] [PASSED] 0x56BA (DG2)
[15:41:07] [PASSED] 0x56BB (DG2)
[15:41:07] [PASSED] 0x56BC (DG2)
[15:41:07] [PASSED] 0x56BD (DG2)
[15:41:07] [PASSED] 0x5693 (DG2)
[15:41:07] [PASSED] 0x5694 (DG2)
[15:41:07] [PASSED] 0x5695 (DG2)
[15:41:07] [PASSED] 0x56A3 (DG2)
[15:41:07] [PASSED] 0x56A4 (DG2)
[15:41:07] [PASSED] 0x56B2 (DG2)
[15:41:07] [PASSED] 0x56B3 (DG2)
[15:41:07] [PASSED] 0x5696 (DG2)
[15:41:07] [PASSED] 0x5697 (DG2)
[15:41:07] [PASSED] 0xB69 (PVC)
[15:41:07] [PASSED] 0xB6E (PVC)
[15:41:07] [PASSED] 0xBD4 (PVC)
[15:41:07] [PASSED] 0xBD5 (PVC)
[15:41:07] [PASSED] 0xBD6 (PVC)
[15:41:07] [PASSED] 0xBD7 (PVC)
[15:41:07] [PASSED] 0xBD8 (PVC)
[15:41:07] [PASSED] 0xBD9 (PVC)
[15:41:07] [PASSED] 0xBDA (PVC)
[15:41:07] [PASSED] 0xBDB (PVC)
[15:41:07] [PASSED] 0xBE0 (PVC)
[15:41:07] [PASSED] 0xBE1 (PVC)
[15:41:07] [PASSED] 0xBE5 (PVC)
[15:41:07] [PASSED] 0x7D40 (METEORLAKE)
[15:41:07] [PASSED] 0x7D45 (METEORLAKE)
[15:41:07] [PASSED] 0x7D55 (METEORLAKE)
[15:41:07] [PASSED] 0x7D60 (METEORLAKE)
[15:41:07] [PASSED] 0x7DD5 (METEORLAKE)
[15:41:07] [PASSED] 0x6420 (LUNARLAKE)
[15:41:07] [PASSED] 0x64A0 (LUNARLAKE)
[15:41:07] [PASSED] 0x64B0 (LUNARLAKE)
[15:41:07] [PASSED] 0xE202 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE209 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE20B (BATTLEMAGE)
[15:41:07] [PASSED] 0xE20C (BATTLEMAGE)
[15:41:07] [PASSED] 0xE20D (BATTLEMAGE)
[15:41:07] [PASSED] 0xE210 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE211 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE212 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE216 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE220 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE221 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE222 (BATTLEMAGE)
[15:41:07] [PASSED] 0xE223 (BATTLEMAGE)
[15:41:07] [PASSED] 0xB080 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB081 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB082 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB083 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB084 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB085 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB086 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB087 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB08F (PANTHERLAKE)
[15:41:07] [PASSED] 0xB090 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB0A0 (PANTHERLAKE)
[15:41:07] [PASSED] 0xB0B0 (PANTHERLAKE)
[15:41:07] [PASSED] 0xFD80 (PANTHERLAKE)
[15:41:07] [PASSED] 0xFD81 (PANTHERLAKE)
[15:41:07] [PASSED] 0xD740 (NOVALAKE_S)
[15:41:07] [PASSED] 0xD741 (NOVALAKE_S)
[15:41:07] [PASSED] 0xD742 (NOVALAKE_S)
[15:41:07] [PASSED] 0xD743 (NOVALAKE_S)
[15:41:07] [PASSED] 0xD745 (NOVALAKE_S)
[15:41:07] [PASSED] 0xD74A (NOVALAKE_S)
[15:41:07] [PASSED] 0xD74B (NOVALAKE_S)
[15:41:07] [PASSED] 0x674C (CRESCENTISLAND)
[15:41:07] [PASSED] 0x674D (CRESCENTISLAND)
[15:41:07] [PASSED] 0x674E (CRESCENTISLAND)
[15:41:07] [PASSED] 0x674F (CRESCENTISLAND)
[15:41:07] [PASSED] 0x6750 (CRESCENTISLAND)
[15:41:07] [PASSED] 0xD750 (NOVALAKE_P)
[15:41:07] [PASSED] 0xD751 (NOVALAKE_P)
[15:41:07] [PASSED] 0xD752 (NOVALAKE_P)
[15:41:07] [PASSED] 0xD753 (NOVALAKE_P)
[15:41:07] [PASSED] 0xD754 (NOVALAKE_P)
[15:41:07] [PASSED] 0xD755 (NOVALAKE_P)
[15:41:07] [PASSED] 0xD756 (NOVALAKE_P)
[15:41:07] [PASSED] 0xD757 (NOVALAKE_P)
[15:41:07] [PASSED] 0xD75F (NOVALAKE_P)
[15:41:07] =============== [PASSED] check_platform_desc ===============
[15:41:07] ===================== [PASSED] xe_pci ======================
[15:41:07] ============= xe_rtp_tables_test (5 subtests) ==============
[15:41:07] ================== xe_rtp_table_gt_test  ===================
[15:41:07] [PASSED] gt_was/14011060649
[15:41:07] [PASSED] gt_was/14011059788
[15:41:07] [PASSED] gt_was/14015795083
[15:41:07] [PASSED] gt_was/16021867713
[15:41:07] [PASSED] gt_was/14019449301
[15:41:07] [PASSED] gt_was/16028005424
[15:41:07] [PASSED] gt_was/14026578760
[15:41:07] [PASSED] gt_was/1409420604
[15:41:07] [PASSED] gt_was/1408615072
[15:41:07] [PASSED] gt_was/22010523718
[15:41:07] [PASSED] gt_was/14011006942
[15:41:07] [PASSED] gt_was/14014830051
[15:41:07] [PASSED] gt_was/18018781329
[15:41:07] [PASSED] gt_was/1509235366
[15:41:07] [PASSED] gt_was/18018781329
[15:41:07] [PASSED] gt_was/16016694945
[15:41:07] [PASSED] gt_was/14018575942
[15:41:07] [PASSED] gt_was/22016670082
[15:41:07] [PASSED] gt_was/22016670082
[15:41:07] [PASSED] gt_was/14017421178
[15:41:07] [PASSED] gt_was/16025250150
[15:41:07] [PASSED] gt_was/14021871409
[15:41:07] [PASSED] gt_was/16021865536
[15:41:07] [PASSED] gt_was/14021486841
[15:41:07] [PASSED] gt_was/14025160223
[15:41:07] [PASSED] gt_was/14026144927, 16029437861, 14026127056
[15:41:07] [PASSED] gt_was/14025635424
[15:41:07] [PASSED] gt_was/16028005424
[15:41:07] ============== [PASSED] xe_rtp_table_gt_test ===============
[15:41:07] ================== xe_rtp_table_gt_test  ===================
[15:41:07] [PASSED] gt_tunings/Tuning: Blend Fill Caching Optimization Disable
[15:41:07] [PASSED] gt_tunings/Tuning: 32B Access Enable
[15:41:07] [PASSED] gt_tunings/Tuning: L3 cache
[15:41:07] [PASSED] gt_tunings/Tuning: L3 cache - media
[15:41:07] [PASSED] gt_tunings/Tuning: Compression Overfetch
[15:41:07] [PASSED] gt_tunings/Tuning: Compression Overfetch - media
[15:41:07] [PASSED] gt_tunings/Tuning: Enable compressible partial write overfetch in L3
[15:41:07] [PASSED] gt_tunings/Tuning: Enable compressible partial write overfetch in L3 - media
[15:41:07] [PASSED] gt_tunings/Tuning: L2 Overfetch Compressible Only
[15:41:07] [PASSED] gt_tunings/Tuning: L2 Overfetch Compressible Only - media
[15:41:07] [PASSED] gt_tunings/Tuning: Stateless compression control
[15:41:07] [PASSED] gt_tunings/Tuning: Stateless compression control - media
[15:41:07] [PASSED] gt_tunings/Tuning: L3 RW flush all Cache
[15:41:07] [PASSED] gt_tunings/Tuning: L3 RW flush all cache - media
[15:41:07] [PASSED] gt_tunings/Tuning: Set STLB Bank Hash Mode to 4KB
[15:41:07] ============== [PASSED] xe_rtp_table_gt_test ===============
[15:41:07] ================== xe_rtp_table_oob_test  ==================
[15:41:07] [PASSED] oob_was/1607983814
[15:41:07] [PASSED] oob_was/16010904313
[15:41:07] [PASSED] oob_was/18022495364
[15:41:07] [PASSED] oob_was/22012773006
[15:41:07] [PASSED] oob_was/14014475959
[15:41:07] [PASSED] oob_was/22011391025
[15:41:07] [PASSED] oob_was/22012727170
[15:41:07] [PASSED] oob_was/22012727685
[15:41:07] [PASSED] oob_was/22016596838
[15:41:07] [PASSED] oob_was/18020744125
[15:41:07] [PASSED] oob_was/1409600907
[15:41:07] [PASSED] oob_was/22014953428
[15:41:07] [PASSED] oob_was/16017236439
[15:41:07] [PASSED] oob_was/14019821291
[15:41:07] [PASSED] oob_was/14015076503
[15:41:07] [PASSED] oob_was/14018913170
[15:41:07] [PASSED] oob_was/14018094691
[15:41:07] [PASSED] oob_was/18024947630
[15:41:07] [PASSED] oob_was/16022287689
[15:41:07] [PASSED] oob_was/13011645652
[15:41:07] [PASSED] oob_was/14022293748
[15:41:07] [PASSED] oob_was/22019794406
[15:41:07] [PASSED] oob_was/22019338487
[15:41:07] [PASSED] oob_was/16023588340
[15:41:07] [PASSED] oob_was/14019789679
[15:41:07] [PASSED] oob_was/14022866841
[15:41:07] [PASSED] oob_was/16021333562
[15:41:07] [PASSED] oob_was/14016712196
[15:41:07] [PASSED] oob_was/14015568240
[15:41:07] [PASSED] oob_was/18013179988
[15:41:07] [PASSED] oob_was/1508761755
[15:41:07] [PASSED] oob_was/16023105232
[15:41:07] [PASSED] oob_was/16026508708
[15:41:07] [PASSED] oob_was/14020001231
[15:41:07] [PASSED] oob_was/16023683509
[15:41:07] [PASSED] oob_was/14025515070
[15:41:07] [PASSED] oob_was/15015404425_disable
[15:41:07] [PASSED] oob_was/16026007364
[15:41:07] [PASSED] oob_was/14020316580
[15:41:07] [PASSED] oob_was/14025883347
[15:41:07] [PASSED] oob_was/16029380221
[15:41:07] [PASSED] oob_was/22022079272
[15:41:07] [PASSED] oob_was/16029897822
[15:41:07] [PASSED] oob_was/14027054324
[15:41:07] ============== [PASSED] xe_rtp_table_oob_test ==============
[15:41:07] ================ xe_rtp_table_dev_oob_test  ================
[15:41:07] [PASSED] device_oob_was/22010954014
[15:41:07] [PASSED] device_oob_was/15015404425
[15:41:07] [PASSED] device_oob_was/22019338487_display
[15:41:07] [PASSED] device_oob_was/14022085890
[15:41:07] [PASSED] device_oob_was/14026539277
[15:41:07] [PASSED] device_oob_was/14026633728
[15:41:07] [PASSED] device_oob_was/14026746987
[15:41:07] [PASSED] device_oob_was/14026779378
[15:41:07] ============ [PASSED] xe_rtp_table_dev_oob_test ============
[15:41:07] ========== xe_rtp_table_missing_upper_bound_test  ==========
[15:41:07] [PASSED] register_whitelist/WaAllowPMDepthAndInvocationCountAccessFromUMD, 1408556865
[15:41:07] [PASSED] register_whitelist/1508744258, 14012131227, 1808121037
[15:41:07] [PASSED] register_whitelist/1806527549
[15:41:07] [PASSED] register_whitelist/allow_read_ctx_timestamp
[15:41:07] [PASSED] register_whitelist/allow_read_queue_timestamp
[15:41:07] [PASSED] register_whitelist/16014440446
[15:41:07] [PASSED] register_whitelist/16017236439
[15:41:07] [PASSED] register_whitelist/16020183090
[15:41:07] [PASSED] register_whitelist/14024997852
[15:41:07] [PASSED] register_whitelist/14024997852
[15:41:07] ====== [PASSED] xe_rtp_table_missing_upper_bound_test ======
[15:41:07] =============== [PASSED] xe_rtp_tables_test ================
[15:41:07] =================== xe_rtp (3 subtests) ====================
[15:41:07] =================== xe_rtp_rules_tests  ====================
[15:41:07] [PASSED] no
[15:41:07] [PASSED] yes
[15:41:07] [PASSED] no-and-no
[15:41:07] [PASSED] no-and-yes
[15:41:07] [PASSED] yes-and-no
[15:41:07] [PASSED] yes-and-yes
[15:41:07] [PASSED] no-or-no
[15:41:07] [PASSED] no-or-yes
[15:41:07] [PASSED] yes-or-no
[15:41:07] [PASSED] yes-or-yes
[15:41:07] [PASSED] no-yes-or-yes-no
[15:41:07] [PASSED] no-yes-or-yes-yes
[15:41:07] [PASSED] yes-yes-or-no-yes
[15:41:07] [PASSED] yes-yes-or-yes-yes
[15:41:07] [PASSED] no-no-or-yes-or-no
[15:41:07] [PASSED] or
[15:41:07] [PASSED] or-yes
[15:41:07] [PASSED] or-no
[15:41:07] [PASSED] yes-or
[15:41:07] [PASSED] no-or
[15:41:07] [PASSED] no-or-or-yes
[15:41:07] [PASSED] yes-or-or-no
[15:41:07] [PASSED] no-or-or-no
[15:41:07] [PASSED] missing-context-engine-class
[15:41:07] [PASSED] missing-context-engine-class-or-yes
[15:41:07] [PASSED] missing-context-engine-class-or-or-yes
[15:41:07] =============== [PASSED] xe_rtp_rules_tests ================
[15:41:07] =============== xe_rtp_process_to_sr_tests  ================
[15:41:07] [PASSED] coalesce-same-reg
[15:41:07] [PASSED] coalesce-same-reg-literal-and-func
[15:41:07] [PASSED] no-match-no-add
[15:41:07] [PASSED] two-regs-two-entries
[15:41:07] [PASSED] clr-one-set-other
[15:41:07] [PASSED] set-field
[15:41:07] [PASSED] conflict-duplicate
[15:41:07] [PASSED] conflict-not-disjoint
[15:41:07] [PASSED] conflict-not-disjoint-literal-and-func
[15:41:07] [PASSED] conflict-reg-type
[15:41:07] [PASSED] bad-mcr-reg-forced-to-regular
[15:41:07] [PASSED] bad-regular-reg-forced-to-mcr
[15:41:07] =========== [PASSED] xe_rtp_process_to_sr_tests ============
[15:41:07] ================== xe_rtp_process_tests  ===================
[15:41:07] [PASSED] active1
[15:41:07] [PASSED] active2
[15:41:07] [PASSED] active-inactive
[15:41:07] [PASSED] inactive-active
[15:41:07] [PASSED] inactive-active-inactive
[15:41:07] [PASSED] inactive-inactive-inactive
[15:41:07] ============== [PASSED] xe_rtp_process_tests ===============
[15:41:07] ===================== [PASSED] xe_rtp ======================
[15:41:07] ==================== xe_wa (1 subtest) =====================
[15:41:07] ======================== xe_wa_gt  =========================
[15:41:07] [PASSED] TIGERLAKE B0
[15:41:07] [PASSED] DG1 A0
[15:41:07] [PASSED] DG1 B0
[15:41:07] [PASSED] ALDERLAKE_S A0
[15:41:07] [PASSED] ALDERLAKE_S B0
[15:41:07] [PASSED] ALDERLAKE_S C0
[15:41:07] [PASSED] ALDERLAKE_S D0
[15:41:07] [PASSED] ALDERLAKE_P A0
[15:41:07] [PASSED] ALDERLAKE_P B0
[15:41:07] [PASSED] ALDERLAKE_P C0
[15:41:07] [PASSED] ALDERLAKE_S RPLS D0
[15:41:07] [PASSED] ALDERLAKE_P RPLU E0
[15:41:07] [PASSED] DG2 G10 C0
[15:41:07] [PASSED] DG2 G11 B1
[15:41:07] [PASSED] DG2 G12 A1
[15:41:07] [PASSED] METEORLAKE 12.70(Xe_LPG) A0 13.00(Xe_LPM+) A0
[15:41:07] [PASSED] METEORLAKE 12.71(Xe_LPG) A0 13.00(Xe_LPM+) A0
[15:41:07] [PASSED] METEORLAKE 12.74(Xe_LPG+) A0 13.00(Xe_LPM+) A0
[15:41:07] [PASSED] LUNARLAKE 20.04(Xe2_LPG) A0 20.00(Xe2_LPM) A0
[15:41:07] [PASSED] LUNARLAKE 20.04(Xe2_LPG) B0 20.00(Xe2_LPM) A0
[15:41:07] [PASSED] BATTLEMAGE 20.01(Xe2_HPG) A0 13.01(Xe2_HPM) A1
[15:41:07] [PASSED] PANTHERLAKE 30.00(Xe3_LPG) A0 30.00(Xe3_LPM) A0
[15:41:07] ==================== [PASSED] xe_wa_gt =====================
[15:41:07] ====================== [PASSED] xe_wa ======================
[15:41:07] ============================================================
[15:41:07] Testing complete. Ran 787 tests: passed: 759, skipped: 28
[15:41:07] Elapsed time: 36.913s total, 4.310s configuring, 31.886s building, 0.676s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/tests/.kunitconfig
[15:41:07] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[15:41:09] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[15:41:34] Starting KUnit Kernel (1/1)...
[15:41:34] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[15:41:34] ============ drm_test_pick_cmdline (2 subtests) ============
[15:41:34] [PASSED] drm_test_pick_cmdline_res_1920_1080_60
[15:41:34] =============== drm_test_pick_cmdline_named  ===============
[15:41:34] [PASSED] NTSC
[15:41:34] [PASSED] NTSC-J
[15:41:34] [PASSED] PAL
[15:41:34] [PASSED] PAL-M
[15:41:34] =========== [PASSED] drm_test_pick_cmdline_named ===========
[15:41:34] ============== [PASSED] drm_test_pick_cmdline ==============
[15:41:34] == drm_test_atomic_get_connector_for_encoder (1 subtest) ===
[15:41:34] [PASSED] drm_test_drm_atomic_get_connector_for_encoder
[15:41:34] ==== [PASSED] drm_test_atomic_get_connector_for_encoder ====
[15:41:34] =========== drm_validate_clone_mode (2 subtests) ===========
[15:41:34] ============== drm_test_check_in_clone_mode  ===============
[15:41:34] [PASSED] in_clone_mode
[15:41:34] [PASSED] not_in_clone_mode
[15:41:34] ========== [PASSED] drm_test_check_in_clone_mode ===========
[15:41:34] =============== drm_test_check_valid_clones  ===============
[15:41:34] [PASSED] not_in_clone_mode
[15:41:34] [PASSED] valid_clone
[15:41:34] [PASSED] invalid_clone
[15:41:34] =========== [PASSED] drm_test_check_valid_clones ===========
[15:41:34] ============= [PASSED] drm_validate_clone_mode =============
[15:41:34] ============= drm_validate_modeset (1 subtest) =============
[15:41:34] [PASSED] drm_test_check_connector_changed_modeset
[15:41:34] ============== [PASSED] drm_validate_modeset ===============
[15:41:34] ====== drm_test_bridge_get_current_state (1 subtest) =======
[15:41:34] [PASSED] drm_test_drm_bridge_get_current_state_atomic
[15:41:34] ======== [PASSED] drm_test_bridge_get_current_state ========
[15:41:34] ====== drm_test_bridge_helper_reset_crtc (3 subtests) ======
[15:41:34] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic
[15:41:34] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic_disabled
[15:41:34] [PASSED] drm_test_drm_bridge_helper_hdmi_output_bus_fmts
[15:41:34] ======== [PASSED] drm_test_bridge_helper_reset_crtc ========
[15:41:34] ============== drm_bridge_alloc (2 subtests) ===============
[15:41:34] [PASSED] drm_test_drm_bridge_alloc_basic
[15:41:34] [PASSED] drm_test_drm_bridge_alloc_get_put
[15:41:34] ================ [PASSED] drm_bridge_alloc =================
[15:41:34] ============= drm_bridge_bus_fmt (5 subtests) ==============
[15:41:34] [PASSED] drm_test_bridge_rgb_yuv_rgb
[15:41:34] [PASSED] drm_test_bridge_must_convert_to_yuv444
[15:41:34] [PASSED] drm_test_bridge_hdmi_auto_rgb
[15:41:34] [PASSED] drm_test_bridge_auto_first
[15:41:34] [PASSED] drm_test_bridge_rgb_yuv_no_path
[15:41:34] =============== [PASSED] drm_bridge_bus_fmt ================
[15:41:34] ============= drm_cmdline_parser (40 subtests) =============
[15:41:34] [PASSED] drm_test_cmdline_force_d_only
[15:41:34] [PASSED] drm_test_cmdline_force_D_only_dvi
[15:41:34] [PASSED] drm_test_cmdline_force_D_only_hdmi
[15:41:34] [PASSED] drm_test_cmdline_force_D_only_not_digital
[15:41:34] [PASSED] drm_test_cmdline_force_e_only
[15:41:34] [PASSED] drm_test_cmdline_res
[15:41:34] [PASSED] drm_test_cmdline_res_vesa
[15:41:34] [PASSED] drm_test_cmdline_res_vesa_rblank
[15:41:34] [PASSED] drm_test_cmdline_res_rblank
[15:41:34] [PASSED] drm_test_cmdline_res_bpp
[15:41:34] [PASSED] drm_test_cmdline_res_refresh
[15:41:34] [PASSED] drm_test_cmdline_res_bpp_refresh
[15:41:34] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced
[15:41:34] [PASSED] drm_test_cmdline_res_bpp_refresh_margins
[15:41:34] [PASSED] drm_test_cmdline_res_bpp_refresh_force_off
[15:41:34] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on
[15:41:34] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_analog
[15:41:34] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_digital
[15:41:34] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced_margins_force_on
[15:41:34] [PASSED] drm_test_cmdline_res_margins_force_on
[15:41:34] [PASSED] drm_test_cmdline_res_vesa_margins
[15:41:34] [PASSED] drm_test_cmdline_name
[15:41:34] [PASSED] drm_test_cmdline_name_bpp
[15:41:34] [PASSED] drm_test_cmdline_name_option
[15:41:34] [PASSED] drm_test_cmdline_name_bpp_option
[15:41:34] [PASSED] drm_test_cmdline_rotate_0
[15:41:34] [PASSED] drm_test_cmdline_rotate_90
[15:41:34] [PASSED] drm_test_cmdline_rotate_180
[15:41:34] [PASSED] drm_test_cmdline_rotate_270
[15:41:34] [PASSED] drm_test_cmdline_hmirror
[15:41:34] [PASSED] drm_test_cmdline_vmirror
[15:41:34] [PASSED] drm_test_cmdline_margin_options
[15:41:34] [PASSED] drm_test_cmdline_multiple_options
[15:41:34] [PASSED] drm_test_cmdline_bpp_extra_and_option
[15:41:34] [PASSED] drm_test_cmdline_extra_and_option
[15:41:34] [PASSED] drm_test_cmdline_freestanding_options
[15:41:34] [PASSED] drm_test_cmdline_freestanding_force_e_and_options
[15:41:34] [PASSED] drm_test_cmdline_panel_orientation
[15:41:34] ================ drm_test_cmdline_invalid  =================
[15:41:34] [PASSED] margin_only
[15:41:34] [PASSED] interlace_only
[15:41:34] [PASSED] res_missing_x
[15:41:34] [PASSED] res_missing_y
[15:41:34] [PASSED] res_bad_y
[15:41:34] [PASSED] res_missing_y_bpp
[15:41:34] [PASSED] res_bad_bpp
[15:41:34] [PASSED] res_bad_refresh
[15:41:34] [PASSED] res_bpp_refresh_force_on_off
[15:41:34] [PASSED] res_invalid_mode
[15:41:34] [PASSED] res_bpp_wrong_place_mode
[15:41:34] [PASSED] name_bpp_refresh
[15:41:34] [PASSED] name_refresh
[15:41:34] [PASSED] name_refresh_wrong_mode
[15:41:34] [PASSED] name_refresh_invalid_mode
[15:41:34] [PASSED] rotate_multiple
[15:41:34] [PASSED] rotate_invalid_val
[15:41:34] [PASSED] rotate_truncated
[15:41:34] [PASSED] invalid_option
[15:41:34] [PASSED] invalid_tv_option
[15:41:34] [PASSED] truncated_tv_option
[15:41:34] ============ [PASSED] drm_test_cmdline_invalid =============
[15:41:34] =============== drm_test_cmdline_tv_options  ===============
[15:41:34] [PASSED] NTSC
[15:41:34] [PASSED] NTSC_443
[15:41:34] [PASSED] NTSC_J
[15:41:34] [PASSED] PAL
[15:41:34] [PASSED] PAL_M
[15:41:34] [PASSED] PAL_N
[15:41:34] [PASSED] SECAM
[15:41:34] [PASSED] MONO_525
[15:41:34] [PASSED] MONO_625
[15:41:34] =========== [PASSED] drm_test_cmdline_tv_options ===========
[15:41:34] =============== [PASSED] drm_cmdline_parser ================
[15:41:34] ========== drmm_connector_hdmi_init (20 subtests) ==========
[15:41:34] [PASSED] drm_test_connector_hdmi_init_valid
[15:41:34] [PASSED] drm_test_connector_hdmi_init_bpc_8
[15:41:34] [PASSED] drm_test_connector_hdmi_init_bpc_10
[15:41:34] [PASSED] drm_test_connector_hdmi_init_bpc_12
[15:41:34] [PASSED] drm_test_connector_hdmi_init_bpc_invalid
[15:41:34] [PASSED] drm_test_connector_hdmi_init_bpc_null
[15:41:34] [PASSED] drm_test_connector_hdmi_init_formats_empty
[15:41:34] [PASSED] drm_test_connector_hdmi_init_formats_no_rgb
[15:41:34] === drm_test_connector_hdmi_init_formats_yuv420_allowed  ===
[15:41:34] [PASSED] supported_formats=0x9 yuv420_allowed=1
[15:41:34] [PASSED] supported_formats=0x9 yuv420_allowed=0
[15:41:34] [PASSED] supported_formats=0x5 yuv420_allowed=1
[15:41:34] [PASSED] supported_formats=0x5 yuv420_allowed=0
[15:41:34] === [PASSED] drm_test_connector_hdmi_init_formats_yuv420_allowed ===
[15:41:34] [PASSED] drm_test_connector_hdmi_init_null_ddc
[15:41:34] [PASSED] drm_test_connector_hdmi_init_null_product
[15:41:34] [PASSED] drm_test_connector_hdmi_init_null_vendor
[15:41:34] [PASSED] drm_test_connector_hdmi_init_product_length_exact
[15:41:34] [PASSED] drm_test_connector_hdmi_init_product_length_too_long
[15:41:34] [PASSED] drm_test_connector_hdmi_init_product_valid
[15:41:34] [PASSED] drm_test_connector_hdmi_init_vendor_length_exact
[15:41:34] [PASSED] drm_test_connector_hdmi_init_vendor_length_too_long
[15:41:34] [PASSED] drm_test_connector_hdmi_init_vendor_valid
[15:41:34] ========= drm_test_connector_hdmi_init_type_valid  =========
[15:41:34] [PASSED] HDMI-A
[15:41:34] [PASSED] HDMI-B
[15:41:34] ===== [PASSED] drm_test_connector_hdmi_init_type_valid =====
[15:41:34] ======== drm_test_connector_hdmi_init_type_invalid  ========
[15:41:34] [PASSED] Unknown
[15:41:34] [PASSED] VGA
[15:41:34] [PASSED] DVI-I
[15:41:34] [PASSED] DVI-D
[15:41:34] [PASSED] DVI-A
[15:41:34] [PASSED] Composite
[15:41:34] [PASSED] SVIDEO
[15:41:34] [PASSED] LVDS
[15:41:34] [PASSED] Component
[15:41:34] [PASSED] DIN
[15:41:34] [PASSED] DP
[15:41:34] [PASSED] TV
[15:41:34] [PASSED] eDP
[15:41:34] [PASSED] Virtual
[15:41:34] [PASSED] DSI
[15:41:34] [PASSED] DPI
[15:41:34] [PASSED] Writeback
[15:41:34] [PASSED] SPI
[15:41:34] [PASSED] USB
[15:41:34] ==== [PASSED] drm_test_connector_hdmi_init_type_invalid ====
[15:41:34] ============ [PASSED] drmm_connector_hdmi_init =============
[15:41:34] ============= drmm_connector_init (3 subtests) =============
[15:41:34] [PASSED] drm_test_drmm_connector_init
[15:41:34] [PASSED] drm_test_drmm_connector_init_null_ddc
[15:41:34] ========= drm_test_drmm_connector_init_type_valid  =========
[15:41:34] [PASSED] Unknown
[15:41:34] [PASSED] VGA
[15:41:34] [PASSED] DVI-I
[15:41:34] [PASSED] DVI-D
[15:41:34] [PASSED] DVI-A
[15:41:34] [PASSED] Composite
[15:41:34] [PASSED] SVIDEO
[15:41:34] [PASSED] LVDS
[15:41:34] [PASSED] Component
[15:41:34] [PASSED] DIN
[15:41:34] [PASSED] DP
[15:41:34] [PASSED] HDMI-A
[15:41:34] [PASSED] HDMI-B
[15:41:34] [PASSED] TV
[15:41:34] [PASSED] eDP
[15:41:34] [PASSED] Virtual
[15:41:34] [PASSED] DSI
[15:41:34] [PASSED] DPI
[15:41:34] [PASSED] Writeback
[15:41:34] [PASSED] SPI
[15:41:34] [PASSED] USB
[15:41:34] ===== [PASSED] drm_test_drmm_connector_init_type_valid =====
[15:41:34] =============== [PASSED] drmm_connector_init ===============
[15:41:34] ========= drm_connector_dynamic_init (6 subtests) ==========
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_init
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_init_null_ddc
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_init_not_added
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_init_properties
[15:41:34] ===== drm_test_drm_connector_dynamic_init_type_valid  ======
[15:41:34] [PASSED] Unknown
[15:41:34] [PASSED] VGA
[15:41:34] [PASSED] DVI-I
[15:41:34] [PASSED] DVI-D
[15:41:34] [PASSED] DVI-A
[15:41:34] [PASSED] Composite
[15:41:34] [PASSED] SVIDEO
[15:41:34] [PASSED] LVDS
[15:41:34] [PASSED] Component
[15:41:34] [PASSED] DIN
[15:41:34] [PASSED] DP
[15:41:34] [PASSED] HDMI-A
[15:41:34] [PASSED] HDMI-B
[15:41:34] [PASSED] TV
[15:41:34] [PASSED] eDP
[15:41:34] [PASSED] Virtual
[15:41:34] [PASSED] DSI
[15:41:34] [PASSED] DPI
[15:41:34] [PASSED] Writeback
[15:41:34] [PASSED] SPI
[15:41:34] [PASSED] USB
[15:41:34] = [PASSED] drm_test_drm_connector_dynamic_init_type_valid ==
[15:41:34] ======== drm_test_drm_connector_dynamic_init_name  =========
[15:41:34] [PASSED] Unknown
[15:41:34] [PASSED] VGA
[15:41:34] [PASSED] DVI-I
[15:41:34] [PASSED] DVI-D
[15:41:34] [PASSED] DVI-A
[15:41:34] [PASSED] Composite
[15:41:34] [PASSED] SVIDEO
[15:41:34] [PASSED] LVDS
[15:41:34] [PASSED] Component
[15:41:34] [PASSED] DIN
[15:41:34] [PASSED] DP
[15:41:34] [PASSED] HDMI-A
[15:41:34] [PASSED] HDMI-B
[15:41:34] [PASSED] TV
[15:41:34] [PASSED] eDP
[15:41:34] [PASSED] Virtual
[15:41:34] [PASSED] DSI
[15:41:34] [PASSED] DPI
[15:41:34] [PASSED] Writeback
[15:41:34] [PASSED] SPI
[15:41:34] [PASSED] USB
[15:41:34] ==== [PASSED] drm_test_drm_connector_dynamic_init_name =====
[15:41:34] =========== [PASSED] drm_connector_dynamic_init ============
[15:41:34] ==== drm_connector_dynamic_register_early (4 subtests) =====
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_early_on_list
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_early_defer
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_early_no_init
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_early_no_mode_object
[15:41:34] ====== [PASSED] drm_connector_dynamic_register_early =======
[15:41:34] ======= drm_connector_dynamic_register (7 subtests) ========
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_on_list
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_no_defer
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_no_init
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_mode_object
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_sysfs
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_sysfs_name
[15:41:34] [PASSED] drm_test_drm_connector_dynamic_register_debugfs
[15:41:34] ========= [PASSED] drm_connector_dynamic_register ==========
[15:41:34] = drm_connector_attach_broadcast_rgb_property (2 subtests) =
[15:41:34] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property
[15:41:34] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector
[15:41:34] === [PASSED] drm_connector_attach_broadcast_rgb_property ===
[15:41:34] ========== drm_get_tv_mode_from_name (2 subtests) ==========
[15:41:34] ========== drm_test_get_tv_mode_from_name_valid  ===========
[15:41:34] [PASSED] NTSC
[15:41:34] [PASSED] NTSC-443
[15:41:34] [PASSED] NTSC-J
[15:41:34] [PASSED] PAL
[15:41:34] [PASSED] PAL-M
[15:41:34] [PASSED] PAL-N
[15:41:34] [PASSED] SECAM
[15:41:34] [PASSED] Mono
[15:41:34] ====== [PASSED] drm_test_get_tv_mode_from_name_valid =======
[15:41:34] [PASSED] drm_test_get_tv_mode_from_name_truncated
[15:41:34] ============ [PASSED] drm_get_tv_mode_from_name ============
[15:41:34] = drm_test_connector_hdmi_compute_mode_clock (12 subtests) =
[15:41:34] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb
[15:41:34] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc
[15:41:34] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1
[15:41:34] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc
[15:41:34] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1
[15:41:34] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_double
[15:41:34] = drm_test_connector_hdmi_compute_mode_clock_yuv420_valid  =
[15:41:34] [PASSED] VIC 96
[15:41:34] [PASSED] VIC 97
[15:41:34] [PASSED] VIC 101
[15:41:34] [PASSED] VIC 102
[15:41:34] [PASSED] VIC 106
[15:41:34] [PASSED] VIC 107
[15:41:34] === [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_valid ===
[15:41:34] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc
[15:41:34] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc
[15:41:34] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc
[15:41:34] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc
[15:41:34] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc
[15:41:34] === [PASSED] drm_test_connector_hdmi_compute_mode_clock ====
[15:41:34] == drm_hdmi_connector_get_broadcast_rgb_name (2 subtests) ==
[15:41:34] === drm_test_drm_hdmi_connector_get_broadcast_rgb_name  ====
[15:41:34] [PASSED] Automatic
[15:41:34] [PASSED] Full
[15:41:34] [PASSED] Limited 16:235
[15:41:34] === [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name ===
[15:41:34] [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid
[15:41:34] ==== [PASSED] drm_hdmi_connector_get_broadcast_rgb_name ====
[15:41:34] == drm_hdmi_connector_get_output_format_name (2 subtests) ==
[15:41:34] === drm_test_drm_hdmi_connector_get_output_format_name  ====
[15:41:34] [PASSED] RGB
[15:41:34] [PASSED] YUV 4:2:0
[15:41:34] [PASSED] YUV 4:2:2
[15:41:34] [PASSED] YUV 4:4:4
[15:41:34] === [PASSED] drm_test_drm_hdmi_connector_get_output_format_name ===
[15:41:34] [PASSED] drm_test_drm_hdmi_connector_get_output_format_name_invalid
[15:41:34] ==== [PASSED] drm_hdmi_connector_get_output_format_name ====
[15:41:34] ============= drm_damage_helper (21 subtests) ==============
[15:41:34] [PASSED] drm_test_damage_iter_no_damage
[15:41:34] [PASSED] drm_test_damage_iter_no_damage_fractional_src
[15:41:34] [PASSED] drm_test_damage_iter_no_damage_src_moved
[15:41:34] [PASSED] drm_test_damage_iter_no_damage_fractional_src_moved
[15:41:34] [PASSED] drm_test_damage_iter_no_damage_not_visible
[15:41:34] [PASSED] drm_test_damage_iter_no_damage_no_crtc
[15:41:34] [PASSED] drm_test_damage_iter_no_damage_no_fb
[15:41:34] [PASSED] drm_test_damage_iter_simple_damage
[15:41:34] [PASSED] drm_test_damage_iter_single_damage
[15:41:34] [PASSED] drm_test_damage_iter_single_damage_intersect_src
[15:41:34] [PASSED] drm_test_damage_iter_single_damage_outside_src
[15:41:34] [PASSED] drm_test_damage_iter_single_damage_fractional_src
[15:41:34] [PASSED] drm_test_damage_iter_single_damage_intersect_fractional_src
[15:41:34] [PASSED] drm_test_damage_iter_single_damage_outside_fractional_src
[15:41:34] [PASSED] drm_test_damage_iter_single_damage_src_moved
[15:41:34] [PASSED] drm_test_damage_iter_single_damage_fractional_src_moved
[15:41:34] [PASSED] drm_test_damage_iter_damage
[15:41:34] [PASSED] drm_test_damage_iter_damage_one_intersect
[15:41:34] [PASSED] drm_test_damage_iter_damage_one_outside
[15:41:34] [PASSED] drm_test_damage_iter_damage_src_moved
[15:41:34] [PASSED] drm_test_damage_iter_damage_not_visible
[15:41:34] ================ [PASSED] drm_damage_helper ================
[15:41:34] ============== drm_dp_mst_helper (3 subtests) ==============
[15:41:34] ============== drm_test_dp_mst_calc_pbn_mode  ==============
[15:41:34] [PASSED] Clock 154000 BPP 30 DSC disabled
[15:41:34] [PASSED] Clock 234000 BPP 30 DSC disabled
[15:41:34] [PASSED] Clock 297000 BPP 24 DSC disabled
[15:41:34] [PASSED] Clock 332880 BPP 24 DSC enabled
[15:41:34] [PASSED] Clock 324540 BPP 24 DSC enabled
[15:41:34] ========== [PASSED] drm_test_dp_mst_calc_pbn_mode ==========
[15:41:34] ============== drm_test_dp_mst_calc_pbn_div  ===============
[15:41:34] [PASSED] Link rate 2000000 lane count 4
[15:41:34] [PASSED] Link rate 2000000 lane count 2
[15:41:34] [PASSED] Link rate 2000000 lane count 1
[15:41:34] [PASSED] Link rate 1350000 lane count 4
[15:41:34] [PASSED] Link rate 1350000 lane count 2
[15:41:34] [PASSED] Link rate 1350000 lane count 1
[15:41:34] [PASSED] Link rate 1000000 lane count 4
[15:41:34] [PASSED] Link rate 1000000 lane count 2
[15:41:34] [PASSED] Link rate 1000000 lane count 1
[15:41:34] [PASSED] Link rate 810000 lane count 4
[15:41:34] [PASSED] Link rate 810000 lane count 2
[15:41:34] [PASSED] Link rate 810000 lane count 1
[15:41:34] [PASSED] Link rate 540000 lane count 4
[15:41:34] [PASSED] Link rate 540000 lane count 2
[15:41:34] [PASSED] Link rate 540000 lane count 1
[15:41:34] [PASSED] Link rate 270000 lane count 4
[15:41:34] [PASSED] Link rate 270000 lane count 2
[15:41:34] [PASSED] Link rate 270000 lane count 1
[15:41:34] [PASSED] Link rate 162000 lane count 4
[15:41:34] [PASSED] Link rate 162000 lane count 2
[15:41:34] [PASSED] Link rate 162000 lane count 1
[15:41:34] ========== [PASSED] drm_test_dp_mst_calc_pbn_div ===========
[15:41:34] ========= drm_test_dp_mst_sideband_msg_req_decode  =========
[15:41:34] [PASSED] DP_ENUM_PATH_RESOURCES with port number
[15:41:34] [PASSED] DP_POWER_UP_PHY with port number
[15:41:34] [PASSED] DP_POWER_DOWN_PHY with port number
[15:41:34] [PASSED] DP_ALLOCATE_PAYLOAD with SDP stream sinks
[15:41:34] [PASSED] DP_ALLOCATE_PAYLOAD with port number
[15:41:34] [PASSED] DP_ALLOCATE_PAYLOAD with VCPI
[15:41:34] [PASSED] DP_ALLOCATE_PAYLOAD with PBN
[15:41:34] [PASSED] DP_QUERY_PAYLOAD with port number
[15:41:34] [PASSED] DP_QUERY_PAYLOAD with VCPI
[15:41:34] [PASSED] DP_REMOTE_DPCD_READ with port number
[15:41:34] [PASSED] DP_REMOTE_DPCD_READ with DPCD address
[15:41:34] [PASSED] DP_REMOTE_DPCD_READ with max number of bytes
[15:41:34] [PASSED] DP_REMOTE_DPCD_WRITE with port number
[15:41:34] [PASSED] DP_REMOTE_DPCD_WRITE with DPCD address
[15:41:34] [PASSED] DP_REMOTE_DPCD_WRITE with data array
[15:41:34] [PASSED] DP_REMOTE_I2C_READ with port number
[15:41:34] [PASSED] DP_REMOTE_I2C_READ with I2C device ID
[15:41:34] [PASSED] DP_REMOTE_I2C_READ with transactions array
[15:41:34] [PASSED] DP_REMOTE_I2C_WRITE with port number
[15:41:34] [PASSED] DP_REMOTE_I2C_WRITE with I2C device ID
[15:41:34] [PASSED] DP_REMOTE_I2C_WRITE with data array
[15:41:34] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream ID
[15:41:34] [PASSED] DP_QUERY_STREAM_ENC_STATUS with client ID
[15:41:34] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream event
[15:41:34] [PASSED] DP_QUERY_STREAM_ENC_STATUS with valid stream event
[15:41:34] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream behavior
[15:41:34] [PASSED] DP_QUERY_STREAM_ENC_STATUS with a valid stream behavior
[15:41:34] ===== [PASSED] drm_test_dp_mst_sideband_msg_req_decode =====
[15:41:34] ================ [PASSED] drm_dp_mst_helper ================
[15:41:34] ================== drm_exec (7 subtests) ===================
[15:41:34] [PASSED] sanitycheck
[15:41:34] [PASSED] test_lock
[15:41:34] [PASSED] test_lock_unlock
[15:41:34] [PASSED] test_duplicates
[15:41:34] [PASSED] test_prepare
[15:41:34] [PASSED] test_prepare_array
[15:41:34] [PASSED] test_multiple_loops
[15:41:34] ==================== [PASSED] drm_exec =====================
[15:41:34] =========== drm_format_helper_test (17 subtests) ===========
[15:41:34] ============== drm_test_fb_xrgb8888_to_gray8  ==============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ========== [PASSED] drm_test_fb_xrgb8888_to_gray8 ==========
[15:41:34] ============= drm_test_fb_xrgb8888_to_rgb332  ==============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb332 ==========
[15:41:34] ============= drm_test_fb_xrgb8888_to_rgb565  ==============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb565 ==========
[15:41:34] ============ drm_test_fb_xrgb8888_to_xrgb1555  =============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ======== [PASSED] drm_test_fb_xrgb8888_to_xrgb1555 =========
[15:41:34] ============ drm_test_fb_xrgb8888_to_argb1555  =============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ======== [PASSED] drm_test_fb_xrgb8888_to_argb1555 =========
[15:41:34] ============ drm_test_fb_xrgb8888_to_rgba5551  =============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ======== [PASSED] drm_test_fb_xrgb8888_to_rgba5551 =========
[15:41:34] ============= drm_test_fb_xrgb8888_to_rgb888  ==============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb888 ==========
[15:41:34] ============= drm_test_fb_xrgb8888_to_bgr888  ==============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ========= [PASSED] drm_test_fb_xrgb8888_to_bgr888 ==========
[15:41:34] ============ drm_test_fb_xrgb8888_to_argb8888  =============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ======== [PASSED] drm_test_fb_xrgb8888_to_argb8888 =========
[15:41:34] =========== drm_test_fb_xrgb8888_to_xrgb2101010  ===========
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ======= [PASSED] drm_test_fb_xrgb8888_to_xrgb2101010 =======
[15:41:34] =========== drm_test_fb_xrgb8888_to_argb2101010  ===========
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ======= [PASSED] drm_test_fb_xrgb8888_to_argb2101010 =======
[15:41:34] ============== drm_test_fb_xrgb8888_to_mono  ===============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ========== [PASSED] drm_test_fb_xrgb8888_to_mono ===========
[15:41:34] ==================== drm_test_fb_swab  =====================
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ================ [PASSED] drm_test_fb_swab =================
[15:41:34] ============ drm_test_fb_xrgb8888_to_xbgr8888  =============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ======== [PASSED] drm_test_fb_xrgb8888_to_xbgr8888 =========
[15:41:34] ============ drm_test_fb_xrgb8888_to_abgr8888  =============
[15:41:34] [PASSED] single_pixel_source_buffer
[15:41:34] [PASSED] single_pixel_clip_rectangle
[15:41:34] [PASSED] well_known_colors
[15:41:34] [PASSED] destination_pitch
[15:41:34] ======== [PASSED] drm_test_fb_xrgb8888_to_abgr8888 =========
[15:41:34] ================= drm_test_fb_clip_offset  =================
[15:41:34] [PASSED] pass through
[15:41:34] [PASSED] horizontal offset
[15:41:34] [PASSED] vertical offset
[15:41:34] [PASSED] horizontal and vertical offset
[15:41:34] [PASSED] horizontal offset (custom pitch)
[15:41:34] [PASSED] vertical offset (custom pitch)
[15:41:34] [PASSED] horizontal and vertical offset (custom pitch)
[15:41:34] ============= [PASSED] drm_test_fb_clip_offset =============
[15:41:34] =================== drm_test_fb_memcpy  ====================
[15:41:34] [PASSED] single_pixel_source_buffer: XR24 little-endian (0x34325258)
[15:41:34] [PASSED] single_pixel_source_buffer: XRA8 little-endian (0x38415258)
[15:41:34] [PASSED] single_pixel_source_buffer: YU24 little-endian (0x34325559)
[15:41:34] [PASSED] single_pixel_clip_rectangle: XB24 little-endian (0x34324258)
[15:41:34] [PASSED] single_pixel_clip_rectangle: XRA8 little-endian (0x38415258)
[15:41:34] [PASSED] single_pixel_clip_rectangle: YU24 little-endian (0x34325559)
[15:41:34] [PASSED] well_known_colors: XB24 little-endian (0x34324258)
[15:41:34] [PASSED] well_known_colors: XRA8 little-endian (0x38415258)
[15:41:34] [PASSED] well_known_colors: YU24 little-endian (0x34325559)
[15:41:34] [PASSED] destination_pitch: XB24 little-endian (0x34324258)
[15:41:34] [PASSED] destination_pitch: XRA8 little-endian (0x38415258)
[15:41:34] [PASSED] destination_pitch: YU24 little-endian (0x34325559)
[15:41:34] =============== [PASSED] drm_test_fb_memcpy ================
[15:41:34] ============= [PASSED] drm_format_helper_test ==============
[15:41:34] ================= drm_format (18 subtests) =================
[15:41:34] [PASSED] drm_test_format_block_width_invalid
[15:41:34] [PASSED] drm_test_format_block_width_one_plane
[15:41:34] [PASSED] drm_test_format_block_width_two_plane
[15:41:34] [PASSED] drm_test_format_block_width_three_plane
[15:41:34] [PASSED] drm_test_format_block_width_tiled
[15:41:34] [PASSED] drm_test_format_block_height_invalid
[15:41:34] [PASSED] drm_test_format_block_height_one_plane
[15:41:34] [PASSED] drm_test_format_block_height_two_plane
[15:41:34] [PASSED] drm_test_format_block_height_three_plane
[15:41:34] [PASSED] drm_test_format_block_height_tiled
[15:41:34] [PASSED] drm_test_format_min_pitch_invalid
[15:41:34] [PASSED] drm_test_format_min_pitch_one_plane_8bpp
[15:41:34] [PASSED] drm_test_format_min_pitch_one_plane_16bpp
[15:41:34] [PASSED] drm_test_format_min_pitch_one_plane_24bpp
[15:41:34] [PASSED] drm_test_format_min_pitch_one_plane_32bpp
[15:41:34] [PASSED] drm_test_format_min_pitch_two_plane
[15:41:34] [PASSED] drm_test_format_min_pitch_three_plane_8bpp
[15:41:34] [PASSED] drm_test_format_min_pitch_tiled
[15:41:34] =================== [PASSED] drm_format ====================
[15:41:34] ============== drm_framebuffer (10 subtests) ===============
[15:41:34] ========== drm_test_framebuffer_check_src_coords  ==========
[15:41:34] [PASSED] Success: source fits into fb
[15:41:34] [PASSED] Fail: overflowing fb with x-axis coordinate
[15:41:34] [PASSED] Fail: overflowing fb with y-axis coordinate
[15:41:34] [PASSED] Fail: overflowing fb with source width
[15:41:34] [PASSED] Fail: overflowing fb with source height
[15:41:34] ====== [PASSED] drm_test_framebuffer_check_src_coords ======
[15:41:34] [PASSED] drm_test_framebuffer_cleanup
[15:41:34] =============== drm_test_framebuffer_create  ===============
[15:41:34] [PASSED] ABGR8888 normal sizes
[15:41:34] [PASSED] ABGR8888 max sizes
[15:41:34] [PASSED] ABGR8888 pitch greater than min required
[15:41:34] [PASSED] ABGR8888 pitch less than min required
[15:41:34] [PASSED] ABGR8888 Invalid width
[15:41:34] [PASSED] ABGR8888 Invalid buffer handle
[15:41:34] [PASSED] No pixel format
[15:41:34] [PASSED] ABGR8888 Width 0
[15:41:34] [PASSED] ABGR8888 Height 0
[15:41:34] [PASSED] ABGR8888 Out of bound height * pitch combination
[15:41:34] [PASSED] ABGR8888 Large buffer offset
[15:41:34] [PASSED] ABGR8888 Buffer offset for inexistent plane
[15:41:34] [PASSED] ABGR8888 Invalid flag
[15:41:34] [PASSED] ABGR8888 Set DRM_MODE_FB_MODIFIERS without modifiers
[15:41:34] [PASSED] ABGR8888 Valid buffer modifier
[15:41:34] [PASSED] ABGR8888 Invalid buffer modifier(DRM_FORMAT_MOD_SAMSUNG_64_32_TILE)
[15:41:34] [PASSED] ABGR8888 Extra pitches without DRM_MODE_FB_MODIFIERS
[15:41:34] [PASSED] ABGR8888 Extra pitches with DRM_MODE_FB_MODIFIERS
[15:41:34] [PASSED] NV12 Normal sizes
[15:41:34] [PASSED] NV12 Max sizes
[15:41:34] [PASSED] NV12 Invalid pitch
[15:41:34] [PASSED] NV12 Invalid modifier/missing DRM_MODE_FB_MODIFIERS flag
[15:41:34] [PASSED] NV12 different  modifier per-plane
[15:41:34] [PASSED] NV12 with DRM_FORMAT_MOD_SAMSUNG_64_32_TILE
[15:41:34] [PASSED] NV12 Valid modifiers without DRM_MODE_FB_MODIFIERS
[15:41:34] [PASSED] NV12 Modifier for inexistent plane
[15:41:34] [PASSED] NV12 Handle for inexistent plane
[15:41:34] [PASSED] NV12 Handle for inexistent plane without DRM_MODE_FB_MODIFIERS
[15:41:34] [PASSED] YVU420 DRM_MODE_FB_MODIFIERS set without modifier
[15:41:34] [PASSED] YVU420 Normal sizes
[15:41:34] [PASSED] YVU420 Max sizes
[15:41:34] [PASSED] YVU420 Invalid pitch
[15:41:34] [PASSED] YVU420 Different pitches
[15:41:34] [PASSED] YVU420 Different buffer offsets/pitches
[15:41:34] [PASSED] YVU420 Modifier set just for plane 0, without DRM_MODE_FB_MODIFIERS
[15:41:34] [PASSED] YVU420 Modifier set just for planes 0, 1, without DRM_MODE_FB_MODIFIERS
[15:41:34] [PASSED] YVU420 Modifier set just for plane 0, 1, with DRM_MODE_FB_MODIFIERS
[15:41:34] [PASSED] YVU420 Valid modifier
[15:41:34] [PASSED] YVU420 Different modifiers per plane
[15:41:34] [PASSED] YVU420 Modifier for inexistent plane
[15:41:34] [PASSED] YUV420_10BIT Invalid modifier(DRM_FORMAT_MOD_LINEAR)
[15:41:34] [PASSED] X0L2 Normal sizes
[15:41:34] [PASSED] X0L2 Max sizes
[15:41:34] [PASSED] X0L2 Invalid pitch
[15:41:34] [PASSED] X0L2 Pitch greater than minimum required
[15:41:34] [PASSED] X0L2 Handle for inexistent plane
[15:41:34] [PASSED] X0L2 Offset for inexistent plane, without DRM_MODE_FB_MODIFIERS set
[15:41:34] [PASSED] X0L2 Modifier without DRM_MODE_FB_MODIFIERS set
[15:41:34] [PASSED] X0L2 Valid modifier
[15:41:34] [PASSED] X0L2 Modifier for inexistent plane
[15:41:34] =========== [PASSED] drm_test_framebuffer_create ===========
[15:41:34] [PASSED] drm_test_framebuffer_free
[15:41:34] [PASSED] drm_test_framebuffer_init
[15:41:34] [PASSED] drm_test_framebuffer_init_bad_format
[15:41:34] [PASSED] drm_test_framebuffer_init_dev_mismatch
[15:41:34] [PASSED] drm_test_framebuffer_lookup
[15:41:34] [PASSED] drm_test_framebuffer_lookup_inexistent
[15:41:34] [PASSED] drm_test_framebuffer_modifiers_not_supported
[15:41:34] ================= [PASSED] drm_framebuffer =================
[15:41:34] ================ drm_gem_shmem (8 subtests) ================
[15:41:34] [PASSED] drm_gem_shmem_test_obj_create
[15:41:34] [PASSED] drm_gem_shmem_test_obj_create_private
[15:41:34] [PASSED] drm_gem_shmem_test_pin_pages
[15:41:34] [PASSED] drm_gem_shmem_test_vmap
[15:41:34] [PASSED] drm_gem_shmem_test_get_sg_table
[15:41:34] [PASSED] drm_gem_shmem_test_get_pages_sgt
[15:41:34] [PASSED] drm_gem_shmem_test_madvise
[15:41:34] [PASSED] drm_gem_shmem_test_purge
[15:41:34] ================== [PASSED] drm_gem_shmem ==================
[15:41:34] === drm_atomic_helper_connector_hdmi_check (29 subtests) ===
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode_vic_1
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode_vic_1
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode_vic_1
[15:41:34] ====== drm_test_check_broadcast_rgb_cea_mode_yuv420  =======
[15:41:34] [PASSED] Automatic
[15:41:34] [PASSED] Full
[15:41:34] [PASSED] Limited 16:235
[15:41:34] == [PASSED] drm_test_check_broadcast_rgb_cea_mode_yuv420 ===
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_changed
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_not_changed
[15:41:34] [PASSED] drm_test_check_disable_connector
[15:41:34] [PASSED] drm_test_check_hdmi_funcs_reject_rate
[15:41:34] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_rgb
[15:41:34] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_yuv420
[15:41:34] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv422
[15:41:34] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv420
[15:41:34] [PASSED] drm_test_check_driver_unsupported_fallback_yuv420
[15:41:34] [PASSED] drm_test_check_output_bpc_crtc_mode_changed
[15:41:34] [PASSED] drm_test_check_output_bpc_crtc_mode_not_changed
[15:41:34] [PASSED] drm_test_check_output_bpc_dvi
[15:41:34] [PASSED] drm_test_check_output_bpc_format_vic_1
[15:41:34] [PASSED] drm_test_check_output_bpc_format_display_8bpc_only
[15:41:34] [PASSED] drm_test_check_output_bpc_format_display_rgb_only
[15:41:34] [PASSED] drm_test_check_output_bpc_format_driver_8bpc_only
[15:41:34] [PASSED] drm_test_check_output_bpc_format_driver_rgb_only
[15:41:34] [PASSED] drm_test_check_tmds_char_rate_rgb_8bpc
[15:41:34] [PASSED] drm_test_check_tmds_char_rate_rgb_10bpc
[15:41:34] [PASSED] drm_test_check_tmds_char_rate_rgb_12bpc
[15:41:34] ============ drm_test_check_hdmi_color_format  =============
[15:41:34] [PASSED] AUTO -> RGB
[15:41:34] [PASSED] YCBCR422 -> YUV422
[15:41:34] [PASSED] YCBCR420 -> YUV420
[15:41:34] [PASSED] YCBCR444 -> YUV444
[15:41:34] [PASSED] RGB -> RGB
[15:41:34] ======== [PASSED] drm_test_check_hdmi_color_format =========
[15:41:34] ======== drm_test_check_hdmi_color_format_420_only  ========
[15:41:34] [PASSED] RGB should fail
[15:41:34] [PASSED] YUV444 should fail
[15:41:34] [PASSED] YUV422 should fail
[15:41:34] [PASSED] YUV420 should work
[15:41:34] ==== [PASSED] drm_test_check_hdmi_color_format_420_only ====
[15:41:34] ===== [PASSED] drm_atomic_helper_connector_hdmi_check ======
[15:41:34] === drm_atomic_helper_connector_hdmi_reset (6 subtests) ====
[15:41:34] [PASSED] drm_test_check_broadcast_rgb_value
[15:41:34] [PASSED] drm_test_check_bpc_8_value
[15:41:34] [PASSED] drm_test_check_bpc_10_value
[15:41:34] [PASSED] drm_test_check_bpc_12_value
[15:41:34] [PASSED] drm_test_check_format_value
[15:41:34] [PASSED] drm_test_check_tmds_char_value
[15:41:34] ===== [PASSED] drm_atomic_helper_connector_hdmi_reset ======
[15:41:34] = drm_atomic_helper_connector_hdmi_mode_valid (7 subtests) =
[15:41:34] [PASSED] drm_test_check_mode_valid
[15:41:34] [PASSED] drm_test_check_mode_valid_reject
[15:41:34] [PASSED] drm_test_check_mode_valid_reject_rate
[15:41:34] [PASSED] drm_test_check_mode_valid_reject_max_clock
[15:41:34] [PASSED] drm_test_check_mode_valid_yuv420_only_max_clock
[15:41:34] [PASSED] drm_test_check_mode_valid_reject_yuv420_only_connector
[15:41:34] [PASSED] drm_test_check_mode_valid_accept_yuv420_also_connector_rgb
[15:41:34] === [PASSED] drm_atomic_helper_connector_hdmi_mode_valid ===
[15:41:34] = drm_atomic_helper_connector_hdmi_infoframes (5 subtests) =
[15:41:34] [PASSED] drm_test_check_infoframes
[15:41:34] [PASSED] drm_test_check_reject_avi_infoframe
[15:41:34] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_8
[15:41:34] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_10
[15:41:34] [PASSED] drm_test_check_reject_audio_infoframe
[15:41:34] === [PASSED] drm_atomic_helper_connector_hdmi_infoframes ===
[15:41:34] ================= drm_managed (2 subtests) =================
[15:41:34] [PASSED] drm_test_managed_release_action
[15:41:34] [PASSED] drm_test_managed_run_action
[15:41:34] =================== [PASSED] drm_managed ===================
[15:41:34] =================== drm_mm (6 subtests) ====================
[15:41:34] [PASSED] drm_test_mm_init
[15:41:34] [PASSED] drm_test_mm_debug
[15:41:34] [PASSED] drm_test_mm_align32
[15:41:34] [PASSED] drm_test_mm_align64
[15:41:34] [PASSED] drm_test_mm_lowest
[15:41:34] [PASSED] drm_test_mm_highest
[15:41:34] ===================== [PASSED] drm_mm ======================
[15:41:34] ============= drm_modes_analog_tv (5 subtests) =============
[15:41:34] [PASSED] drm_test_modes_analog_tv_mono_576i
[15:41:34] [PASSED] drm_test_modes_analog_tv_ntsc_480i
[15:41:34] [PASSED] drm_test_modes_analog_tv_ntsc_480i_inlined
[15:41:34] [PASSED] drm_test_modes_analog_tv_pal_576i
[15:41:34] [PASSED] drm_test_modes_analog_tv_pal_576i_inlined
[15:41:34] =============== [PASSED] drm_modes_analog_tv ===============
[15:41:34] ============== drm_plane_helper (2 subtests) ===============
[15:41:34] =============== drm_test_check_plane_state  ================
[15:41:34] [PASSED] clipping_simple
[15:41:34] [PASSED] clipping_rotate_reflect
[15:41:34] [PASSED] positioning_simple
[15:41:34] [PASSED] upscaling
[15:41:34] [PASSED] downscaling
[15:41:34] [PASSED] rounding1
[15:41:34] [PASSED] rounding2
[15:41:34] [PASSED] rounding3
[15:41:34] [PASSED] rounding4
[15:41:34] =========== [PASSED] drm_test_check_plane_state ============
[15:41:34] =========== drm_test_check_invalid_plane_state  ============
[15:41:34] [PASSED] positioning_invalid
[15:41:34] [PASSED] upscaling_invalid
[15:41:34] [PASSED] downscaling_invalid
[15:41:34] ======= [PASSED] drm_test_check_invalid_plane_state ========
[15:41:34] ================ [PASSED] drm_plane_helper =================
[15:41:34] ====== drm_connector_helper_tv_get_modes (1 subtest) =======
[15:41:34] ====== drm_test_connector_helper_tv_get_modes_check  =======
[15:41:34] [PASSED] None
[15:41:34] [PASSED] PAL
[15:41:34] [PASSED] NTSC
[15:41:34] [PASSED] Both, NTSC Default
[15:41:34] [PASSED] Both, PAL Default
[15:41:34] [PASSED] Both, NTSC Default, with PAL on command-line
[15:41:34] [PASSED] Both, PAL Default, with NTSC on command-line
[15:41:34] == [PASSED] drm_test_connector_helper_tv_get_modes_check ===
[15:41:34] ======== [PASSED] drm_connector_helper_tv_get_modes ========
[15:41:34] ================== drm_rect (9 subtests) ===================
[15:41:34] [PASSED] drm_test_rect_clip_scaled_div_by_zero
[15:41:34] [PASSED] drm_test_rect_clip_scaled_not_clipped
[15:41:34] [PASSED] drm_test_rect_clip_scaled_clipped
[15:41:34] [PASSED] drm_test_rect_clip_scaled_signed_vs_unsigned
[15:41:34] ================= drm_test_rect_intersect  =================
[15:41:34] [PASSED] top-left x bottom-right: 2x2+1+1 x 2x2+0+0
[15:41:34] [PASSED] top-right x bottom-left: 2x2+0+0 x 2x2+1-1
[15:41:34] [PASSED] bottom-left x top-right: 2x2+1-1 x 2x2+0+0
[15:41:34] [PASSED] bottom-right x top-left: 2x2+0+0 x 2x2+1+1
[15:41:34] [PASSED] right x left: 2x1+0+0 x 3x1+1+0
[15:41:34] [PASSED] left x right: 3x1+1+0 x 2x1+0+0
[15:41:34] [PASSED] up x bottom: 1x2+0+0 x 1x3+0-1
[15:41:34] [PASSED] bottom x up: 1x3+0-1 x 1x2+0+0
[15:41:34] [PASSED] touching corner: 1x1+0+0 x 2x2+1+1
[15:41:34] [PASSED] touching side: 1x1+0+0 x 1x1+1+0
[15:41:34] [PASSED] equal rects: 2x2+0+0 x 2x2+0+0
[15:41:34] [PASSED] inside another: 2x2+0+0 x 1x1+1+1
[15:41:34] [PASSED] far away: 1x1+0+0 x 1x1+3+6
[15:41:34] [PASSED] points intersecting: 0x0+5+10 x 0x0+5+10
[15:41:34] [PASSED] points not intersecting: 0x0+0+0 x 0x0+5+10
[15:41:34] ============= [PASSED] drm_test_rect_intersect =============
[15:41:34] ================ drm_test_rect_calc_hscale  ================
[15:41:34] [PASSED] normal use
[15:41:34] [PASSED] out of max range
[15:41:34] [PASSED] out of min range
[15:41:34] [PASSED] zero dst
[15:41:34] [PASSED] negative src
[15:41:34] [PASSED] negative dst
[15:41:34] ============ [PASSED] drm_test_rect_calc_hscale ============
[15:41:34] ================ drm_test_rect_calc_vscale  ================
[15:41:34] [PASSED] normal use
[15:41:34] [PASSED] out of max range
[15:41:34] [PASSED] out of min range
[15:41:34] [PASSED] zero dst
[15:41:34] [PASSED] negative src
[15:41:34] [PASSED] negative dst
[15:41:34] ============ [PASSED] drm_test_rect_calc_vscale ============
[15:41:34] ================== drm_test_rect_rotate  ===================
[15:41:34] [PASSED] reflect-x
[15:41:34] [PASSED] reflect-y
[15:41:34] [PASSED] rotate-0
[15:41:34] [PASSED] rotate-90
[15:41:34] [PASSED] rotate-180
[15:41:34] [PASSED] rotate-270
[15:41:34] ============== [PASSED] drm_test_rect_rotate ===============
[15:41:34] ================ drm_test_rect_rotate_inv  =================
[15:41:34] [PASSED] reflect-x
[15:41:34] [PASSED] reflect-y
[15:41:34] [PASSED] rotate-0
[15:41:34] [PASSED] rotate-90
[15:41:34] [PASSED] rotate-180
[15:41:34] [PASSED] rotate-270
[15:41:34] ============ [PASSED] drm_test_rect_rotate_inv =============
[15:41:34] ==================== [PASSED] drm_rect =====================
[15:41:34] ============ drm_sysfb_modeset_test (1 subtest) ============
[15:41:34] ============ drm_test_sysfb_build_fourcc_list  =============
[15:41:34] [PASSED] no native formats
[15:41:34] [PASSED] XRGB8888 as native format
[15:41:34] [PASSED] remove duplicates
[15:41:34] [PASSED] convert alpha formats
[15:41:34] [PASSED] random formats
[15:41:34] ======== [PASSED] drm_test_sysfb_build_fourcc_list =========
[15:41:34] ============= [PASSED] drm_sysfb_modeset_test ==============
[15:41:34] ================== drm_fixp (2 subtests) ===================
[15:41:34] [PASSED] drm_test_int2fixp
[15:41:34] [PASSED] drm_test_sm2fixp
[15:41:34] ==================== [PASSED] drm_fixp =====================
[15:41:34] ============================================================
[15:41:34] Testing complete. Ran 637 tests: passed: 637
[15:41:34] Elapsed time: 26.696s total, 1.732s configuring, 24.798s building, 0.147s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/ttm/tests/.kunitconfig
[15:41:34] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[15:41:36] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[15:41:46] Starting KUnit Kernel (1/1)...
[15:41:46] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[15:41:46] ================= ttm_device (5 subtests) ==================
[15:41:46] [PASSED] ttm_device_init_basic
[15:41:46] [PASSED] ttm_device_init_multiple
[15:41:46] [PASSED] ttm_device_fini_basic
[15:41:46] [PASSED] ttm_device_init_no_vma_man
[15:41:46] ================== ttm_device_init_pools  ==================
[15:41:46] [PASSED] No DMA allocations, no DMA32 required
[15:41:46] [PASSED] DMA allocations, DMA32 required
[15:41:46] [PASSED] No DMA allocations, DMA32 required
[15:41:46] [PASSED] DMA allocations, no DMA32 required
[15:41:46] ============== [PASSED] ttm_device_init_pools ==============
[15:41:46] =================== [PASSED] ttm_device ====================
[15:41:46] ================== ttm_pool (8 subtests) ===================
[15:41:46] ================== ttm_pool_alloc_basic  ===================
[15:41:46] [PASSED] One page
[15:41:46] [PASSED] More than one page
[15:41:46] [PASSED] Above the allocation limit
[15:41:46] [PASSED] One page, with coherent DMA mappings enabled
[15:41:46] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[15:41:46] ============== [PASSED] ttm_pool_alloc_basic ===============
[15:41:46] ============== ttm_pool_alloc_basic_dma_addr  ==============
[15:41:46] [PASSED] One page
[15:41:46] [PASSED] More than one page
[15:41:46] [PASSED] Above the allocation limit
[15:41:46] [PASSED] One page, with coherent DMA mappings enabled
[15:41:46] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[15:41:46] ========== [PASSED] ttm_pool_alloc_basic_dma_addr ==========
[15:41:46] [PASSED] ttm_pool_alloc_order_caching_match
[15:41:46] [PASSED] ttm_pool_alloc_caching_mismatch
[15:41:46] [PASSED] ttm_pool_alloc_order_mismatch
[15:41:46] [PASSED] ttm_pool_free_dma_alloc
[15:41:46] [PASSED] ttm_pool_free_no_dma_alloc
[15:41:46] [PASSED] ttm_pool_fini_basic
[15:41:46] ==================== [PASSED] ttm_pool =====================
[15:41:46] ================ ttm_resource (8 subtests) =================
[15:41:46] ================= ttm_resource_init_basic  =================
[15:41:46] [PASSED] Init resource in TTM_PL_SYSTEM
[15:41:46] [PASSED] Init resource in TTM_PL_VRAM
[15:41:46] [PASSED] Init resource in a private placement
[15:41:46] [PASSED] Init resource in TTM_PL_SYSTEM, set placement flags
[15:41:46] ============= [PASSED] ttm_resource_init_basic =============
[15:41:46] [PASSED] ttm_resource_init_pinned
[15:41:46] [PASSED] ttm_resource_fini_basic
[15:41:46] [PASSED] ttm_resource_manager_init_basic
[15:41:46] [PASSED] ttm_resource_manager_usage_basic
[15:41:46] [PASSED] ttm_resource_manager_set_used_basic
[15:41:46] [PASSED] ttm_sys_man_alloc_basic
[15:41:46] [PASSED] ttm_sys_man_free_basic
[15:41:46] ================== [PASSED] ttm_resource ===================
[15:41:46] =================== ttm_tt (15 subtests) ===================
[15:41:46] ==================== ttm_tt_init_basic  ====================
[15:41:46] [PASSED] Page-aligned size
[15:41:46] [PASSED] Extra pages requested
[15:41:46] ================ [PASSED] ttm_tt_init_basic ================
[15:41:46] [PASSED] ttm_tt_init_misaligned
[15:41:46] [PASSED] ttm_tt_fini_basic
[15:41:46] [PASSED] ttm_tt_fini_sg
[15:41:46] [PASSED] ttm_tt_fini_shmem
[15:41:46] [PASSED] ttm_tt_create_basic
[15:41:46] [PASSED] ttm_tt_create_invalid_bo_type
[15:41:46] [PASSED] ttm_tt_create_ttm_exists
[15:41:46] [PASSED] ttm_tt_create_failed
[15:41:46] [PASSED] ttm_tt_destroy_basic
[15:41:46] [PASSED] ttm_tt_populate_null_ttm
[15:41:46] [PASSED] ttm_tt_populate_populated_ttm
[15:41:46] [PASSED] ttm_tt_unpopulate_basic
[15:41:46] [PASSED] ttm_tt_unpopulate_empty_ttm
[15:41:46] [PASSED] ttm_tt_swapin_basic
[15:41:46] ===================== [PASSED] ttm_tt ======================
[15:41:46] =================== ttm_bo (14 subtests) ===================
[15:41:46] =========== ttm_bo_reserve_optimistic_no_ticket  ===========
[15:41:46] [PASSED] Cannot be interrupted and sleeps
[15:41:46] [PASSED] Cannot be interrupted, locks straight away
[15:41:46] [PASSED] Can be interrupted, sleeps
[15:41:46] ======= [PASSED] ttm_bo_reserve_optimistic_no_ticket =======
[15:41:46] [PASSED] ttm_bo_reserve_locked_no_sleep
[15:41:46] [PASSED] ttm_bo_reserve_no_wait_ticket
[15:41:46] [PASSED] ttm_bo_reserve_double_resv
[15:41:46] [PASSED] ttm_bo_reserve_interrupted
[15:41:46] [PASSED] ttm_bo_reserve_deadlock
[15:41:46] [PASSED] ttm_bo_unreserve_basic
[15:41:46] [PASSED] ttm_bo_unreserve_pinned
[15:41:46] [PASSED] ttm_bo_unreserve_bulk
[15:41:46] [PASSED] ttm_bo_fini_basic
[15:41:46] [PASSED] ttm_bo_fini_shared_resv
[15:41:46] [PASSED] ttm_bo_pin_basic
[15:41:46] [PASSED] ttm_bo_pin_unpin_resource
[15:41:46] [PASSED] ttm_bo_multiple_pin_one_unpin
[15:41:46] ===================== [PASSED] ttm_bo ======================
[15:41:46] ============== ttm_bo_validate (22 subtests) ===============
[15:41:46] ============== ttm_bo_init_reserved_sys_man  ===============
[15:41:46] [PASSED] Buffer object for userspace
[15:41:46] [PASSED] Kernel buffer object
[15:41:46] [PASSED] Shared buffer object
[15:41:46] ========== [PASSED] ttm_bo_init_reserved_sys_man ===========
[15:41:46] ============== ttm_bo_init_reserved_mock_man  ==============
[15:41:46] [PASSED] Buffer object for userspace
[15:41:46] [PASSED] Kernel buffer object
[15:41:46] [PASSED] Shared buffer object
[15:41:46] ========== [PASSED] ttm_bo_init_reserved_mock_man ==========
[15:41:46] [PASSED] ttm_bo_init_reserved_resv
[15:41:46] ================== ttm_bo_validate_basic  ==================
[15:41:46] [PASSED] Buffer object for userspace
[15:41:46] [PASSED] Kernel buffer object
[15:41:46] [PASSED] Shared buffer object
[15:41:46] ============== [PASSED] ttm_bo_validate_basic ==============
[15:41:46] [PASSED] ttm_bo_validate_invalid_placement
[15:41:46] ============= ttm_bo_validate_same_placement  ==============
[15:41:46] [PASSED] System manager
[15:41:46] [PASSED] VRAM manager
[15:41:46] ========= [PASSED] ttm_bo_validate_same_placement ==========
[15:41:46] [PASSED] ttm_bo_validate_failed_alloc
[15:41:46] [PASSED] ttm_bo_validate_pinned
[15:41:46] [PASSED] ttm_bo_validate_busy_placement
[15:41:46] ================ ttm_bo_validate_multihop  =================
[15:41:46] [PASSED] Buffer object for userspace
[15:41:46] [PASSED] Kernel buffer object
[15:41:46] [PASSED] Shared buffer object
[15:41:46] ============ [PASSED] ttm_bo_validate_multihop =============
[15:41:46] ========== ttm_bo_validate_no_placement_signaled  ==========
[15:41:46] [PASSED] Buffer object in system domain, no page vector
[15:41:46] [PASSED] Buffer object in system domain with an existing page vector
[15:41:46] ====== [PASSED] ttm_bo_validate_no_placement_signaled ======
[15:41:46] ======== ttm_bo_validate_no_placement_not_signaled  ========
[15:41:46] [PASSED] Buffer object for userspace
[15:41:46] [PASSED] Kernel buffer object
[15:41:46] [PASSED] Shared buffer object
[15:41:46] ==== [PASSED] ttm_bo_validate_no_placement_not_signaled ====
[15:41:46] [PASSED] ttm_bo_validate_move_fence_signaled
[15:41:46] ========= ttm_bo_validate_move_fence_not_signaled  =========
[15:41:46] [PASSED] Waits for GPU
[15:41:46] [PASSED] Tries to lock straight away
[15:41:46] ===== [PASSED] ttm_bo_validate_move_fence_not_signaled =====
[15:41:46] [PASSED] ttm_bo_validate_swapout
[15:41:46] [PASSED] ttm_bo_validate_happy_evict
[15:41:46] [PASSED] ttm_bo_validate_all_pinned_evict
[15:41:46] [PASSED] ttm_bo_validate_allowed_only_evict
[15:41:46] [PASSED] ttm_bo_validate_deleted_evict
[15:41:46] [PASSED] ttm_bo_validate_busy_domain_evict
[15:41:46] [PASSED] ttm_bo_validate_evict_gutting
[15:41:46] [PASSED] ttm_bo_validate_recrusive_evict
[15:41:46] ================= [PASSED] ttm_bo_validate =================
[15:41:46] ============================================================
[15:41:46] Testing complete. Ran 102 tests: passed: 102
[15:41:46] Elapsed time: 12.119s total, 1.807s configuring, 10.097s building, 0.185s running

+ cleanup
++ stat -c %u:%g /kernel
+ chown -R 1003:1003 /kernel

✗ Xe.CI.BAT: failure for drm/xe: Add structured SIGID error logging infrastructure (rev3)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 4655 bytes --]

== Series Details ==

Series: drm/xe: Add structured SIGID error logging infrastructure (rev3)
URL   : https://patchwork.freedesktop.org/series/171022/
State : failure

== Summary ==

CI Bug Log - changes from xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd_BAT -> xe-pw-171022v3_BAT
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with xe-pw-171022v3_BAT absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in xe-pw-171022v3_BAT, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
  to document this new failure mode, which will reduce false positives in CI.

  

Participating hosts (12 -> 12)
------------------------------

  No changes in participating hosts

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in xe-pw-171022v3_BAT:

### IGT changes ###

#### Possible regressions ####

  * igt@xe_exec_fault_mode@invalid-va:
    - bat-bmg-1:          [PASS][1] -> [DMESG-WARN][2] +1 other test dmesg-warn
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-bmg-1/igt@xe_exec_fault_mode@invalid-va.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-bmg-1/igt@xe_exec_fault_mode@invalid-va.html
    - bat-lnl-2:          [PASS][3] -> [DMESG-WARN][4] +1 other test dmesg-warn
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-lnl-2/igt@xe_exec_fault_mode@invalid-va.html
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-lnl-2/igt@xe_exec_fault_mode@invalid-va.html
    - bat-wcl-1:          [PASS][5] -> [DMESG-WARN][6] +1 other test dmesg-warn
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-wcl-1/igt@xe_exec_fault_mode@invalid-va.html
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-wcl-1/igt@xe_exec_fault_mode@invalid-va.html
    - bat-ptl-1:          [PASS][7] -> [DMESG-WARN][8] +1 other test dmesg-warn
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-ptl-1/igt@xe_exec_fault_mode@invalid-va.html
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-ptl-1/igt@xe_exec_fault_mode@invalid-va.html
    - bat-ptl-vm:         [PASS][9] -> [DMESG-WARN][10] +1 other test dmesg-warn
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-ptl-vm/igt@xe_exec_fault_mode@invalid-va.html
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-ptl-vm/igt@xe_exec_fault_mode@invalid-va.html
    - bat-lnl-1:          [PASS][11] -> [DMESG-WARN][12] +1 other test dmesg-warn
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-lnl-1/igt@xe_exec_fault_mode@invalid-va.html
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-lnl-1/igt@xe_exec_fault_mode@invalid-va.html

  * igt@xe_exec_system_allocator@fault:
    - bat-wcl-2:          [PASS][13] -> [DMESG-WARN][14] +1 other test dmesg-warn
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-wcl-2/igt@xe_exec_system_allocator@fault.html
   [14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-wcl-2/igt@xe_exec_system_allocator@fault.html
    - bat-bmg-vm:         [PASS][15] -> [DMESG-WARN][16] +1 other test dmesg-warn
   [15]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-bmg-vm/igt@xe_exec_system_allocator@fault.html
   [16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-bmg-vm/igt@xe_exec_system_allocator@fault.html
    - bat-ptl-2:          [PASS][17] -> [DMESG-WARN][18] +1 other test dmesg-warn
   [17]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-ptl-2/igt@xe_exec_system_allocator@fault.html
   [18]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-ptl-2/igt@xe_exec_system_allocator@fault.html

  


Build changes
-------------

  * Linux: xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd -> xe-pw-171022v3

  IGT_9034: be1d1af352dbd4ca4557202a8ed0d6d60f95e0bf @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd: 5e24f68d311764bf343f9def49b752b509dfd5fd
  xe-pw-171022v3: 171022v3

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/index.html

[-- Attachment #2: Type: text/html, Size: 5319 bytes --]

✗ Xe.CI.FULL: failure for drm/xe: Add structured SIGID error logging infrastructure (rev3)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 80192 bytes --]

== Series Details ==

Series: drm/xe: Add structured SIGID error logging infrastructure (rev3)
URL   : https://patchwork.freedesktop.org/series/171022/
State : failure

== Summary ==

CI Bug Log - changes from xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd_FULL -> xe-pw-171022v3_FULL
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with xe-pw-171022v3_FULL absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in xe-pw-171022v3_FULL, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
  to document this new failure mode, which will reduce false positives in CI.

  

Participating hosts (2 -> 2)
------------------------------

  No changes in participating hosts

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in xe-pw-171022v3_FULL:

### IGT changes ###

#### Possible regressions ####

  * igt@xe_exec_system_allocator@fault:
    - shard-bmg:          [PASS][1] -> [DMESG-WARN][2] +6 other tests dmesg-warn
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-1/igt@xe_exec_system_allocator@fault.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-9/igt@xe_exec_system_allocator@fault.html

  * igt@xe_waitfence@exec_queue-reset-wait:
    - shard-lnl:          [PASS][3] -> [DMESG-WARN][4] +9 other tests dmesg-warn
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-lnl-7/igt@xe_waitfence@exec_queue-reset-wait.html
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-lnl-5/igt@xe_waitfence@exec_queue-reset-wait.html

  
#### Warnings ####

  * igt@xe_exec_fault_mode@invalid-va:
    - shard-bmg:          [SKIP][5] ([Intel XE#8714]) -> [DMESG-WARN][6] +2 other tests dmesg-warn
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_exec_fault_mode@invalid-va.html
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@xe_exec_fault_mode@invalid-va.html

  * igt@xe_survivability@runtime-survivability:
    - shard-bmg:          [DMESG-WARN][7] ([Intel XE#6627] / [Intel XE#7419]) -> [DMESG-WARN][8]
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-3/igt@xe_survivability@runtime-survivability.html
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@xe_survivability@runtime-survivability.html

  * igt@xe_wedged@wedged-at-any-timeout:
    - shard-bmg:          [DMESG-WARN][9] ([Intel XE#5545]) -> [DMESG-WARN][10]
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-2/igt@xe_wedged@wedged-at-any-timeout.html
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-2/igt@xe_wedged@wedged-at-any-timeout.html

  
Known issues
------------

  Here are the changes found in xe-pw-171022v3_FULL that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@core_getversion@all-cards:
    - shard-bmg:          [PASS][11] -> [FAIL][12] ([Intel XE#8711] / [Intel XE#8714])
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@core_getversion@all-cards.html
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@core_getversion@all-cards.html

  * igt@core_getversion@basic:
    - shard-bmg:          [PASS][13] -> [FAIL][14] ([Intel XE#8714])
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@core_getversion@basic.html
   [14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@core_getversion@basic.html

  * igt@fbdev@info:
    - shard-bmg:          [PASS][15] -> [SKIP][16] ([Intel XE#2134])
   [15]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@fbdev@info.html
   [16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@fbdev@info.html

  * igt@intel_hwmon@hwmon-read:
    - shard-bmg:          [PASS][17] -> [SKIP][18] ([Intel XE#5177] / [Intel XE#8714])
   [17]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@intel_hwmon@hwmon-read.html
   [18]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@intel_hwmon@hwmon-read.html

  * igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs@pipe-c-dp-2:
    - shard-bmg:          NOTRUN -> [SKIP][19] ([Intel XE#2652]) +15 other tests skip
   [19]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs@pipe-c-dp-2.html

  * igt@kms_content_protection@srm@pipe-a-dp-2:
    - shard-bmg:          NOTRUN -> [FAIL][20] ([Intel XE#1178] / [Intel XE#3304] / [Intel XE#7374]) +1 other test fail
   [20]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_content_protection@srm@pipe-a-dp-2.html

  * igt@kms_flip@flip-vs-expired-vblank-interruptible@c-edp1:
    - shard-lnl:          [PASS][21] -> [FAIL][22] ([Intel XE#301] / [Intel XE#3149])
   [21]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-lnl-4/igt@kms_flip@flip-vs-expired-vblank-interruptible@c-edp1.html
   [22]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-lnl-5/igt@kms_flip@flip-vs-expired-vblank-interruptible@c-edp1.html

  * igt@kms_pm_dc@dc3co-vpb-simulation@pr-xrgb8888:
    - shard-bmg:          NOTRUN -> [SKIP][23] ([Intel XE#8395] / [Intel XE#8396])
   [23]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_pm_dc@dc3co-vpb-simulation@pr-xrgb8888.html

  * igt@kms_pm_dc@dc3co-vpb-simulation@psr2-xrgb8888:
    - shard-bmg:          NOTRUN -> [SKIP][24] ([Intel XE#8396]) +1 other test skip
   [24]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_pm_dc@dc3co-vpb-simulation@psr2-xrgb8888.html

  * igt@kms_sharpness_filter@invalid-plane-with-filter@pipe-a-edp-1-invalid-plane-with-filter:
    - shard-lnl:          [PASS][25] -> [DMESG-WARN][26] ([Intel XE#8551]) +1 other test dmesg-warn
   [25]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-lnl-4/igt@kms_sharpness_filter@invalid-plane-with-filter@pipe-a-edp-1-invalid-plane-with-filter.html
   [26]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-lnl-7/igt@kms_sharpness_filter@invalid-plane-with-filter@pipe-a-edp-1-invalid-plane-with-filter.html

  * igt@xe_exec_balancer@many-execqueues-cm-virtual-userptr-rebind:
    - shard-bmg:          NOTRUN -> [SKIP][27] ([Intel XE#8714]) +237 other tests skip
   [27]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_exec_balancer@many-execqueues-cm-virtual-userptr-rebind.html

  * igt@xe_exec_system_allocator@threads-shared-vm-many-malloc-race:
    - shard-bmg:          [PASS][28] -> [SKIP][29] ([Intel XE#8714]) +837 other tests skip
   [28]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_exec_system_allocator@threads-shared-vm-many-malloc-race.html
   [29]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_exec_system_allocator@threads-shared-vm-many-malloc-race.html

  * igt@xe_live_ktest@xe_bo:
    - shard-bmg:          [PASS][30] -> [SKIP][31] ([Intel XE#2229]) +1 other test skip
   [30]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@xe_live_ktest@xe_bo.html
   [31]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_live_ktest@xe_bo.html

  * igt@xe_multigpu_svm@mgpu-xgpu-access-prefetch:
    - shard-bmg:          NOTRUN -> [SKIP][32] ([Intel XE#6964] / [Intel XE#8714])
   [32]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_multigpu_svm@mgpu-xgpu-access-prefetch.html

  
#### Possible fixes ####

  * igt@core_setmaster@master-drop-set-user:
    - shard-bmg:          [FAIL][33] ([Intel XE#8599] / [Intel XE#8714]) -> [PASS][34]
   [33]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@core_setmaster@master-drop-set-user.html
   [34]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@core_setmaster@master-drop-set-user.html

  * igt@fbdev@write:
    - shard-bmg:          [SKIP][35] ([Intel XE#2134]) -> [PASS][36]
   [35]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@fbdev@write.html
   [36]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@fbdev@write.html

  * igt@kms_flip@flip-vs-expired-vblank@a-edp1:
    - shard-lnl:          [FAIL][37] ([Intel XE#301]) -> [PASS][38] +1 other test pass
   [37]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-lnl-3/igt@kms_flip@flip-vs-expired-vblank@a-edp1.html
   [38]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-lnl-4/igt@kms_flip@flip-vs-expired-vblank@a-edp1.html

  * igt@kms_flip@wf_vblank-ts-check:
    - shard-bmg:          [SKIP][39] ([Intel XE#8714]) -> [PASS][40] +834 other tests pass
   [39]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_flip@wf_vblank-ts-check.html
   [40]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_flip@wf_vblank-ts-check.html

  * igt@kms_pm_rpm@legacy-planes-dpms:
    - shard-bmg:          [SKIP][41] ([Intel XE#8710] / [Intel XE#8714]) -> [PASS][42]
   [41]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_pm_rpm@legacy-planes-dpms.html
   [42]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_pm_rpm@legacy-planes-dpms.html

  * igt@xe_module_load@force-load:
    - shard-bmg:          [FAIL][43] ([Intel XE#8714]) -> [PASS][44] +1 other test pass
   [43]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_module_load@force-load.html
   [44]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@xe_module_load@force-load.html

  
#### Warnings ####

  * igt@kms_big_fb@4-tiled-16bpp-rotate-270:
    - shard-bmg:          [SKIP][45] ([Intel XE#2327]) -> [SKIP][46] ([Intel XE#8714]) +4 other tests skip
   [45]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_big_fb@4-tiled-16bpp-rotate-270.html
   [46]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_big_fb@4-tiled-16bpp-rotate-270.html

  * igt@kms_big_fb@linear-64bpp-rotate-270:
    - shard-bmg:          [SKIP][47] ([Intel XE#8714]) -> [SKIP][48] ([Intel XE#2327]) +2 other tests skip
   [47]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_big_fb@linear-64bpp-rotate-270.html
   [48]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_big_fb@linear-64bpp-rotate-270.html

  * igt@kms_big_fb@linear-max-hw-stride-32bpp-rotate-0-hflip:
    - shard-bmg:          [SKIP][49] ([Intel XE#8714]) -> [SKIP][50] ([Intel XE#7059] / [Intel XE#7085])
   [49]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_big_fb@linear-max-hw-stride-32bpp-rotate-0-hflip.html
   [50]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_big_fb@linear-max-hw-stride-32bpp-rotate-0-hflip.html

  * igt@kms_big_fb@linear-max-hw-stride-64bpp-rotate-0-hflip:
    - shard-bmg:          [SKIP][51] ([Intel XE#7059] / [Intel XE#7085]) -> [SKIP][52] ([Intel XE#8714])
   [51]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_big_fb@linear-max-hw-stride-64bpp-rotate-0-hflip.html
   [52]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_big_fb@linear-max-hw-stride-64bpp-rotate-0-hflip.html

  * igt@kms_big_fb@y-tiled-addfb-size-overflow:
    - shard-bmg:          [SKIP][53] ([Intel XE#8714]) -> [SKIP][54] ([Intel XE#610] / [Intel XE#7387]) +1 other test skip
   [53]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_big_fb@y-tiled-addfb-size-overflow.html
   [54]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_big_fb@y-tiled-addfb-size-overflow.html

  * igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip:
    - shard-bmg:          [SKIP][55] ([Intel XE#8714]) -> [SKIP][56] ([Intel XE#1124]) +11 other tests skip
   [55]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip.html
   [56]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip.html

  * igt@kms_big_fb@y-tiled-max-hw-stride-64bpp-rotate-0-hflip:
    - shard-bmg:          [SKIP][57] ([Intel XE#1124]) -> [SKIP][58] ([Intel XE#8714]) +14 other tests skip
   [57]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_big_fb@y-tiled-max-hw-stride-64bpp-rotate-0-hflip.html
   [58]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_big_fb@y-tiled-max-hw-stride-64bpp-rotate-0-hflip.html

  * igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow:
    - shard-bmg:          [SKIP][59] ([Intel XE#607] / [Intel XE#7361]) -> [SKIP][60] ([Intel XE#8714])
   [59]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow.html
   [60]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow.html

  * igt@kms_bw@connected-linear-tiling-4-displays-target-2160x1440p:
    - shard-bmg:          [SKIP][61] ([Intel XE#7679]) -> [SKIP][62] ([Intel XE#8714]) +2 other tests skip
   [61]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_bw@connected-linear-tiling-4-displays-target-2160x1440p.html
   [62]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_bw@connected-linear-tiling-4-displays-target-2160x1440p.html

  * igt@kms_bw@linear-tiling-1-displays-target-2560x1440p:
    - shard-bmg:          [SKIP][63] ([Intel XE#8714]) -> [SKIP][64] ([Intel XE#367]) +3 other tests skip
   [63]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_bw@linear-tiling-1-displays-target-2560x1440p.html
   [64]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_bw@linear-tiling-1-displays-target-2560x1440p.html

  * igt@kms_bw@linear-tiling-4-displays-target-2560x1440p:
    - shard-bmg:          [SKIP][65] ([Intel XE#367]) -> [SKIP][66] ([Intel XE#8714]) +1 other test skip
   [65]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_bw@linear-tiling-4-displays-target-2560x1440p.html
   [66]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_bw@linear-tiling-4-displays-target-2560x1440p.html

  * igt@kms_ccs@bad-aux-stride-yf-tiled-ccs:
    - shard-bmg:          [SKIP][67] ([Intel XE#8714]) -> [SKIP][68] ([Intel XE#2887]) +16 other tests skip
   [67]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_ccs@bad-aux-stride-yf-tiled-ccs.html
   [68]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_ccs@bad-aux-stride-yf-tiled-ccs.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-mc-ccs:
    - shard-bmg:          [SKIP][69] ([Intel XE#3432]) -> [SKIP][70] ([Intel XE#8714]) +1 other test skip
   [69]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-mc-ccs.html
   [70]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-mc-ccs.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-rc-ccs:
    - shard-bmg:          [SKIP][71] ([Intel XE#8714]) -> [SKIP][72] ([Intel XE#3432])
   [71]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-rc-ccs.html
   [72]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-rc-ccs.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs:
    - shard-bmg:          [SKIP][73] ([Intel XE#2652]) -> [SKIP][74] ([Intel XE#8714])
   [73]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs.html
   [74]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs:
    - shard-bmg:          [SKIP][75] ([Intel XE#2887]) -> [SKIP][76] ([Intel XE#8714]) +19 other tests skip
   [75]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs.html
   [76]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs.html

  * igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs:
    - shard-bmg:          [SKIP][77] ([Intel XE#8714]) -> [SKIP][78] ([Intel XE#2652]) +1 other test skip
   [77]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs.html
   [78]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs.html

  * igt@kms_chamelium_color@ctm-limited-range:
    - shard-bmg:          [SKIP][79] ([Intel XE#2325] / [Intel XE#7358]) -> [SKIP][80] ([Intel XE#8714])
   [79]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_chamelium_color@ctm-limited-range.html
   [80]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_chamelium_color@ctm-limited-range.html

  * igt@kms_chamelium_color@ctm-red-to-blue:
    - shard-bmg:          [SKIP][81] ([Intel XE#8714]) -> [SKIP][82] ([Intel XE#2325] / [Intel XE#7358]) +1 other test skip
   [81]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_chamelium_color@ctm-red-to-blue.html
   [82]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_chamelium_color@ctm-red-to-blue.html

  * igt@kms_chamelium_color_pipeline@plane-ctm3x4:
    - shard-bmg:          [SKIP][83] ([Intel XE#7358]) -> [SKIP][84] ([Intel XE#8714])
   [83]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_chamelium_color_pipeline@plane-ctm3x4.html
   [84]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_chamelium_color_pipeline@plane-ctm3x4.html

  * igt@kms_chamelium_color_pipeline@plane-lut1d-ctm3x4:
    - shard-bmg:          [SKIP][85] ([Intel XE#8714]) -> [SKIP][86] ([Intel XE#7358]) +2 other tests skip
   [85]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_chamelium_color_pipeline@plane-lut1d-ctm3x4.html
   [86]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_chamelium_color_pipeline@plane-lut1d-ctm3x4.html

  * igt@kms_chamelium_edid@dp-edid-change-during-hibernate:
    - shard-bmg:          [SKIP][87] ([Intel XE#2252]) -> [SKIP][88] ([Intel XE#8714]) +11 other tests skip
   [87]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_chamelium_edid@dp-edid-change-during-hibernate.html
   [88]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_chamelium_edid@dp-edid-change-during-hibernate.html

  * igt@kms_chamelium_frames@hdmi-cmp-planar-formats:
    - shard-bmg:          [SKIP][89] ([Intel XE#8714]) -> [SKIP][90] ([Intel XE#2252]) +9 other tests skip
   [89]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_chamelium_frames@hdmi-cmp-planar-formats.html
   [90]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_chamelium_frames@hdmi-cmp-planar-formats.html

  * igt@kms_content_protection@dp-mst-lic-type-0-hdcp14:
    - shard-bmg:          [SKIP][91] ([Intel XE#6974]) -> [SKIP][92] ([Intel XE#8714])
   [91]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_content_protection@dp-mst-lic-type-0-hdcp14.html
   [92]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_content_protection@dp-mst-lic-type-0-hdcp14.html

  * igt@kms_content_protection@dp-mst-lic-type-1:
    - shard-bmg:          [SKIP][93] ([Intel XE#8714]) -> [SKIP][94] ([Intel XE#2390] / [Intel XE#6974]) +2 other tests skip
   [93]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_content_protection@dp-mst-lic-type-1.html
   [94]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_content_protection@dp-mst-lic-type-1.html

  * igt@kms_content_protection@legacy:
    - shard-bmg:          [SKIP][95] ([Intel XE#8714]) -> [FAIL][96] ([Intel XE#1178] / [Intel XE#3304] / [Intel XE#7374]) +1 other test fail
   [95]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_content_protection@legacy.html
   [96]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_content_protection@legacy.html

  * igt@kms_content_protection@legacy-hdcp14:
    - shard-bmg:          [FAIL][97] ([Intel XE#1178] / [Intel XE#3304] / [Intel XE#7374]) -> [SKIP][98] ([Intel XE#8714])
   [97]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_content_protection@legacy-hdcp14.html
   [98]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_content_protection@legacy-hdcp14.html

  * igt@kms_content_protection@lic-type-1:
    - shard-bmg:          [SKIP][99] ([Intel XE#8714]) -> [SKIP][100] ([Intel XE#7642])
   [99]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_content_protection@lic-type-1.html
   [100]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_content_protection@lic-type-1.html

  * igt@kms_content_protection@uevent:
    - shard-bmg:          [FAIL][101] ([Intel XE#6707] / [Intel XE#7439]) -> [SKIP][102] ([Intel XE#8714])
   [101]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_content_protection@uevent.html
   [102]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_content_protection@uevent.html

  * igt@kms_cursor_crc@cursor-offscreen-128x42:
    - shard-bmg:          [SKIP][103] ([Intel XE#2320]) -> [SKIP][104] ([Intel XE#8714]) +5 other tests skip
   [103]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_cursor_crc@cursor-offscreen-128x42.html
   [104]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_cursor_crc@cursor-offscreen-128x42.html

  * igt@kms_cursor_crc@cursor-onscreen-32x10:
    - shard-bmg:          [SKIP][105] ([Intel XE#8714]) -> [SKIP][106] ([Intel XE#2320]) +4 other tests skip
   [105]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_cursor_crc@cursor-onscreen-32x10.html
   [106]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_cursor_crc@cursor-onscreen-32x10.html

  * igt@kms_cursor_crc@cursor-onscreen-512x170:
    - shard-bmg:          [SKIP][107] ([Intel XE#2321] / [Intel XE#7355]) -> [SKIP][108] ([Intel XE#8714]) +1 other test skip
   [107]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_cursor_crc@cursor-onscreen-512x170.html
   [108]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_cursor_crc@cursor-onscreen-512x170.html

  * igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle:
    - shard-bmg:          [SKIP][109] ([Intel XE#8714]) -> [SKIP][110] ([Intel XE#2286] / [Intel XE#6035])
   [109]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle.html
   [110]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle.html

  * igt@kms_dirtyfb@drrs-dirtyfb-ioctl:
    - shard-bmg:          [SKIP][111] ([Intel XE#1508]) -> [SKIP][112] ([Intel XE#8714])
   [111]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_dirtyfb@drrs-dirtyfb-ioctl.html
   [112]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_dirtyfb@drrs-dirtyfb-ioctl.html

  * igt@kms_dirtyfb@fbc-dirtyfb-ioctl:
    - shard-bmg:          [SKIP][113] ([Intel XE#8714]) -> [SKIP][114] ([Intel XE#4210] / [Intel XE#7467])
   [113]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_dirtyfb@fbc-dirtyfb-ioctl.html
   [114]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_dirtyfb@fbc-dirtyfb-ioctl.html

  * igt@kms_dirtyfb@psr-dirtyfb-ioctl:
    - shard-bmg:          [SKIP][115] ([Intel XE#8714]) -> [SKIP][116] ([Intel XE#1508])
   [115]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_dirtyfb@psr-dirtyfb-ioctl.html
   [116]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_dirtyfb@psr-dirtyfb-ioctl.html

  * igt@kms_dsc@dsc-basic-bigjoiner:
    - shard-bmg:          [SKIP][117] ([Intel XE#8265]) -> [SKIP][118] ([Intel XE#8714]) +5 other tests skip
   [117]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_dsc@dsc-basic-bigjoiner.html
   [118]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_dsc@dsc-basic-bigjoiner.html

  * igt@kms_dsc@dsc-with-output-formats-bigjoiner:
    - shard-bmg:          [SKIP][119] ([Intel XE#8714]) -> [SKIP][120] ([Intel XE#8265]) +3 other tests skip
   [119]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_dsc@dsc-with-output-formats-bigjoiner.html
   [120]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_dsc@dsc-with-output-formats-bigjoiner.html

  * igt@kms_fbc_dirty_rect@fbc-dirty-rectangle-different-formats:
    - shard-bmg:          [SKIP][121] ([Intel XE#8714]) -> [SKIP][122] ([Intel XE#4422] / [Intel XE#7442])
   [121]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_fbc_dirty_rect@fbc-dirty-rectangle-different-formats.html
   [122]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_fbc_dirty_rect@fbc-dirty-rectangle-different-formats.html

  * igt@kms_feature_discovery@display-3x:
    - shard-bmg:          [SKIP][123] ([Intel XE#2373] / [Intel XE#7448]) -> [SKIP][124] ([Intel XE#8714])
   [123]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_feature_discovery@display-3x.html
   [124]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_feature_discovery@display-3x.html

  * igt@kms_feature_discovery@psr1:
    - shard-bmg:          [SKIP][125] ([Intel XE#2374] / [Intel XE#6127]) -> [SKIP][126] ([Intel XE#8714])
   [125]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_feature_discovery@psr1.html
   [126]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_feature_discovery@psr1.html

  * igt@kms_flip@flip-vs-expired-vblank-interruptible:
    - shard-lnl:          [FAIL][127] ([Intel XE#301]) -> [FAIL][128] ([Intel XE#301] / [Intel XE#3149])
   [127]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-lnl-4/igt@kms_flip@flip-vs-expired-vblank-interruptible.html
   [128]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-lnl-5/igt@kms_flip@flip-vs-expired-vblank-interruptible.html

  * igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling:
    - shard-bmg:          [SKIP][129] ([Intel XE#7178] / [Intel XE#7349]) -> [SKIP][130] ([Intel XE#8714])
   [129]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling.html
   [130]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-downscaling:
    - shard-bmg:          [SKIP][131] ([Intel XE#7178] / [Intel XE#7351]) -> [SKIP][132] ([Intel XE#8714]) +2 other tests skip
   [131]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-downscaling.html
   [132]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-downscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling:
    - shard-bmg:          [SKIP][133] ([Intel XE#8714]) -> [SKIP][134] ([Intel XE#7178] / [Intel XE#7349])
   [133]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling.html
   [134]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-16bpp-ytile-downscaling:
    - shard-bmg:          [SKIP][135] ([Intel XE#8714]) -> [SKIP][136] ([Intel XE#7178] / [Intel XE#7351]) +3 other tests skip
   [135]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-16bpp-ytile-downscaling.html
   [136]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-16bpp-ytile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-p016-linear-to-p016-linear-reflect-x:
    - shard-bmg:          [SKIP][137] ([Intel XE#7179]) -> [SKIP][138] ([Intel XE#8714]) +1 other test skip
   [137]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_flip_scaled_crc@flip-p016-linear-to-p016-linear-reflect-x.html
   [138]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_flip_scaled_crc@flip-p016-linear-to-p016-linear-reflect-x.html

  * igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-indfb-draw-mmap-wc:
    - shard-bmg:          [SKIP][139] ([Intel XE#8714]) -> [SKIP][140] ([Intel XE#2311]) +73 other tests skip
   [139]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-indfb-draw-mmap-wc.html
   [140]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-indfb-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@drrs-abgr161616f-draw-render:
    - shard-bmg:          [SKIP][141] ([Intel XE#7061] / [Intel XE#7356]) -> [SKIP][142] ([Intel XE#8714]) +4 other tests skip
   [141]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_frontbuffer_tracking@drrs-abgr161616f-draw-render.html
   [142]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_frontbuffer_tracking@drrs-abgr161616f-draw-render.html

  * igt@kms_frontbuffer_tracking@drrshdr-abgr161616f-draw-mmap-wc:
    - shard-bmg:          [SKIP][143] ([Intel XE#7061]) -> [SKIP][144] ([Intel XE#8714]) +7 other tests skip
   [143]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_frontbuffer_tracking@drrshdr-abgr161616f-draw-mmap-wc.html
   [144]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_frontbuffer_tracking@drrshdr-abgr161616f-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-blt:
    - shard-bmg:          [SKIP][145] ([Intel XE#8714]) -> [SKIP][146] ([Intel XE#4141]) +15 other tests skip
   [145]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-blt.html
   [146]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-onoff:
    - shard-bmg:          [SKIP][147] ([Intel XE#4141]) -> [SKIP][148] ([Intel XE#8714]) +17 other tests skip
   [147]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-onoff.html
   [148]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbc-argb161616f-draw-render:
    - shard-bmg:          [SKIP][149] ([Intel XE#8714]) -> [SKIP][150] ([Intel XE#7061] / [Intel XE#7356]) +6 other tests skip
   [149]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_frontbuffer_tracking@fbc-argb161616f-draw-render.html
   [150]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_frontbuffer_tracking@fbc-argb161616f-draw-render.html

  * igt@kms_frontbuffer_tracking@fbc-tiling-y:
    - shard-bmg:          [SKIP][151] ([Intel XE#8714]) -> [SKIP][152] ([Intel XE#2352] / [Intel XE#7399])
   [151]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_frontbuffer_tracking@fbc-tiling-y.html
   [152]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_frontbuffer_tracking@fbc-tiling-y.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-shrfb-plflip-blt:
    - shard-bmg:          [SKIP][153] ([Intel XE#2311]) -> [SKIP][154] ([Intel XE#8714]) +70 other tests skip
   [153]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-shrfb-plflip-blt.html
   [154]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-shrfb-plflip-blt.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y:
    - shard-bmg:          [SKIP][155] ([Intel XE#2352] / [Intel XE#7399]) -> [SKIP][156] ([Intel XE#8714])
   [155]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y.html
   [156]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y.html

  * igt@kms_frontbuffer_tracking@fbcdrrshdr-argb161616f-draw-blt:
    - shard-bmg:          [SKIP][157] ([Intel XE#8714]) -> [SKIP][158] ([Intel XE#7061]) +4 other tests skip
   [157]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_frontbuffer_tracking@fbcdrrshdr-argb161616f-draw-blt.html
   [158]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_frontbuffer_tracking@fbcdrrshdr-argb161616f-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsrhdr-2p-primscrn-indfb-pgflip-blt:
    - shard-bmg:          [SKIP][159] ([Intel XE#8714]) -> [SKIP][160] ([Intel XE#2313]) +72 other tests skip
   [159]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_frontbuffer_tracking@fbcpsrhdr-2p-primscrn-indfb-pgflip-blt.html
   [160]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_frontbuffer_tracking@fbcpsrhdr-2p-primscrn-indfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsrhdr-tiling-y:
    - shard-bmg:          [SKIP][161] ([Intel XE#8714]) -> [SKIP][162] ([Intel XE#7399])
   [161]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_frontbuffer_tracking@fbcpsrhdr-tiling-y.html
   [162]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_frontbuffer_tracking@fbcpsrhdr-tiling-y.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-indfb-plflip-blt:
    - shard-bmg:          [SKIP][163] ([Intel XE#2313]) -> [SKIP][164] ([Intel XE#8714]) +73 other tests skip
   [163]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_frontbuffer_tracking@psr-2p-primscrn-indfb-plflip-blt.html
   [164]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_frontbuffer_tracking@psr-2p-primscrn-indfb-plflip-blt.html

  * igt@kms_hdr@brightness-with-hdr:
    - shard-bmg:          [SKIP][165] ([Intel XE#8714]) -> [SKIP][166] ([Intel XE#3374] / [Intel XE#3544])
   [165]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_hdr@brightness-with-hdr.html
   [166]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_hdr@brightness-with-hdr.html

  * igt@kms_hdr@invalid-hdr:
    - shard-bmg:          [SKIP][167] ([Intel XE#1503]) -> [SKIP][168] ([Intel XE#8714])
   [167]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_hdr@invalid-hdr.html
   [168]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_hdr@invalid-hdr.html

  * igt@kms_joiner@basic-big-joiner:
    - shard-bmg:          [SKIP][169] ([Intel XE#6901]) -> [SKIP][170] ([Intel XE#8714])
   [169]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_joiner@basic-big-joiner.html
   [170]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_joiner@basic-big-joiner.html

  * igt@kms_joiner@basic-max-non-joiner:
    - shard-bmg:          [SKIP][171] ([Intel XE#8714]) -> [SKIP][172] ([Intel XE#4298] / [Intel XE#5873])
   [171]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_joiner@basic-max-non-joiner.html
   [172]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_joiner@basic-max-non-joiner.html

  * igt@kms_joiner@invalid-modeset-force-ultra-joiner:
    - shard-bmg:          [SKIP][173] ([Intel XE#6911] / [Intel XE#7466]) -> [SKIP][174] ([Intel XE#8714])
   [173]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_joiner@invalid-modeset-force-ultra-joiner.html
   [174]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_joiner@invalid-modeset-force-ultra-joiner.html

  * igt@kms_mst@mst-suspend-read-crc:
    - shard-bmg:          [SKIP][175] ([Intel XE#8714]) -> [SKIP][176] ([Intel XE#8348])
   [175]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_mst@mst-suspend-read-crc.html
   [176]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_mst@mst-suspend-read-crc.html

  * igt@kms_panel_fitting@legacy:
    - shard-bmg:          [SKIP][177] ([Intel XE#8714]) -> [SKIP][178] ([Intel XE#2486])
   [177]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_panel_fitting@legacy.html
   [178]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_panel_fitting@legacy.html

  * igt@kms_plane@pixel-format-y-tiled-ccs-modifier-source-clamping:
    - shard-bmg:          [SKIP][179] ([Intel XE#8714]) -> [SKIP][180] ([Intel XE#7283]) +3 other tests skip
   [179]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_plane@pixel-format-y-tiled-ccs-modifier-source-clamping.html
   [180]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_plane@pixel-format-y-tiled-ccs-modifier-source-clamping.html

  * igt@kms_plane@pixel-format-y-tiled-modifier:
    - shard-bmg:          [SKIP][181] ([Intel XE#7283]) -> [SKIP][182] ([Intel XE#8714]) +7 other tests skip
   [181]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_plane@pixel-format-y-tiled-modifier.html
   [182]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_plane@pixel-format-y-tiled-modifier.html

  * igt@kms_plane_lowres@tiling-y:
    - shard-bmg:          [SKIP][183] ([Intel XE#8714]) -> [SKIP][184] ([Intel XE#2393])
   [183]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_plane_lowres@tiling-y.html
   [184]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_plane_lowres@tiling-y.html

  * igt@kms_plane_multiple@2x-tiling-y:
    - shard-bmg:          [SKIP][185] ([Intel XE#8714]) -> [SKIP][186] ([Intel XE#5021] / [Intel XE#7377])
   [185]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_plane_multiple@2x-tiling-y.html
   [186]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_plane_multiple@2x-tiling-y.html

  * igt@kms_plane_multiple@tiling-yf:
    - shard-bmg:          [SKIP][187] ([Intel XE#8714]) -> [SKIP][188] ([Intel XE#5020] / [Intel XE#7348])
   [187]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_plane_multiple@tiling-yf.html
   [188]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_plane_multiple@tiling-yf.html

  * igt@kms_pm_backlight@brightness-with-dpms:
    - shard-bmg:          [SKIP][189] ([Intel XE#8714]) -> [SKIP][190] ([Intel XE#2938] / [Intel XE#7376] / [Intel XE#7760])
   [189]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_pm_backlight@brightness-with-dpms.html
   [190]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_pm_backlight@brightness-with-dpms.html

  * igt@kms_pm_backlight@fade:
    - shard-bmg:          [SKIP][191] ([Intel XE#7376] / [Intel XE#7760] / [Intel XE#870]) -> [SKIP][192] ([Intel XE#8714])
   [191]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_pm_backlight@fade.html
   [192]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_pm_backlight@fade.html

  * igt@kms_pm_backlight@fade-with-dpms:
    - shard-bmg:          [SKIP][193] ([Intel XE#8714]) -> [SKIP][194] ([Intel XE#7376] / [Intel XE#7760] / [Intel XE#870])
   [193]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_pm_backlight@fade-with-dpms.html
   [194]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_pm_backlight@fade-with-dpms.html

  * igt@kms_pm_dc@dc3co-vpb-framegap:
    - shard-bmg:          [SKIP][195] ([Intel XE#8395] / [Intel XE#8396]) -> [SKIP][196] ([Intel XE#8714]) +1 other test skip
   [195]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_pm_dc@dc3co-vpb-framegap.html
   [196]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_pm_dc@dc3co-vpb-framegap.html

  * igt@kms_pm_dc@dc3co-vpb-simulation:
    - shard-bmg:          [SKIP][197] ([Intel XE#8714]) -> [SKIP][198] ([Intel XE#8395] / [Intel XE#8396])
   [197]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_pm_dc@dc3co-vpb-simulation.html
   [198]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_pm_dc@dc3co-vpb-simulation.html

  * igt@kms_pm_dc@dc5-psr:
    - shard-bmg:          [SKIP][199] ([Intel XE#8714]) -> [SKIP][200] ([Intel XE#7794])
   [199]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_pm_dc@dc5-psr.html
   [200]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_pm_dc@dc5-psr.html

  * igt@kms_pm_dc@deep-pkgc:
    - shard-bmg:          [SKIP][201] ([Intel XE#2505] / [Intel XE#7447]) -> [SKIP][202] ([Intel XE#8714])
   [201]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_pm_dc@deep-pkgc.html
   [202]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_pm_dc@deep-pkgc.html

  * igt@kms_pm_rpm@dpms-lpsp:
    - shard-bmg:          [SKIP][203] ([Intel XE#8714]) -> [SKIP][204] ([Intel XE#1439] / [Intel XE#3141] / [Intel XE#7383] / [Intel XE#836])
   [203]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_pm_rpm@dpms-lpsp.html
   [204]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_pm_rpm@dpms-lpsp.html

  * igt@kms_pm_rpm@dpms-mode-unset-lpsp:
    - shard-bmg:          [SKIP][205] ([Intel XE#8714]) -> [SKIP][206] ([Intel XE#1439] / [Intel XE#7402] / [Intel XE#836])
   [205]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_pm_rpm@dpms-mode-unset-lpsp.html
   [206]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_pm_rpm@dpms-mode-unset-lpsp.html

  * igt@kms_psr2_sf@pr-cursor-plane-move-continuous-exceed-sf:
    - shard-bmg:          [SKIP][207] ([Intel XE#1489]) -> [SKIP][208] ([Intel XE#8714]) +6 other tests skip
   [207]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_psr2_sf@pr-cursor-plane-move-continuous-exceed-sf.html
   [208]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_psr2_sf@pr-cursor-plane-move-continuous-exceed-sf.html

  * igt@kms_psr2_sf@psr2-plane-move-sf-dmg-area:
    - shard-bmg:          [SKIP][209] ([Intel XE#8714]) -> [SKIP][210] ([Intel XE#1489]) +11 other tests skip
   [209]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_psr2_sf@psr2-plane-move-sf-dmg-area.html
   [210]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@kms_psr2_sf@psr2-plane-move-sf-dmg-area.html

  * igt@kms_psr2_su@frontbuffer-xrgb8888:
    - shard-bmg:          [SKIP][211] ([Intel XE#8714]) -> [SKIP][212] ([Intel XE#2387] / [Intel XE#7429])
   [211]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_psr2_su@frontbuffer-xrgb8888.html
   [212]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_psr2_su@frontbuffer-xrgb8888.html

  * igt@kms_psr2_su@page_flip-xrgb8888:
    - shard-bmg:          [SKIP][213] ([Intel XE#2387] / [Intel XE#7429]) -> [SKIP][214] ([Intel XE#8714]) +1 other test skip
   [213]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@kms_psr2_su@page_flip-xrgb8888.html
   [214]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_psr2_su@page_flip-xrgb8888.html

  * igt@kms_psr@fbc-psr2-cursor-plane-move:
    - shard-bmg:          [SKIP][215] ([Intel XE#8714]) -> [SKIP][216] ([Intel XE#2234] / [Intel XE#2850]) +13 other tests skip
   [215]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_psr@fbc-psr2-cursor-plane-move.html
   [216]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_psr@fbc-psr2-cursor-plane-move.html

  * igt@kms_psr@psr-primary-page-flip:
    - shard-bmg:          [SKIP][217] ([Intel XE#2234] / [Intel XE#2850]) -> [SKIP][218] ([Intel XE#8714]) +15 other tests skip
   [217]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_psr@psr-primary-page-flip.html
   [218]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_psr@psr-primary-page-flip.html

  * igt@kms_psr@psr2-primary-render:
    - shard-bmg:          [SKIP][219] ([Intel XE#8714]) -> [SKIP][220] ([Intel XE#2234])
   [219]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_psr@psr2-primary-render.html
   [220]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_psr@psr2-primary-render.html

  * igt@kms_psr_stress_test@flip-primary-invalidate-overlay:
    - shard-bmg:          [SKIP][221] ([Intel XE#7795]) -> [SKIP][222] ([Intel XE#8714])
   [221]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_psr_stress_test@flip-primary-invalidate-overlay.html
   [222]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_psr_stress_test@flip-primary-invalidate-overlay.html

  * igt@kms_rotation_crc@primary-rotation-90:
    - shard-bmg:          [SKIP][223] ([Intel XE#8714]) -> [SKIP][224] ([Intel XE#3904] / [Intel XE#7342]) +1 other test skip
   [223]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_rotation_crc@primary-rotation-90.html
   [224]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@kms_rotation_crc@primary-rotation-90.html

  * igt@kms_rotation_crc@primary-y-tiled-reflect-x-180:
    - shard-bmg:          [SKIP][225] ([Intel XE#8714]) -> [SKIP][226] ([Intel XE#2330] / [Intel XE#5813])
   [225]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_rotation_crc@primary-y-tiled-reflect-x-180.html
   [226]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@kms_rotation_crc@primary-y-tiled-reflect-x-180.html

  * igt@kms_rotation_crc@sprite-rotation-270:
    - shard-bmg:          [SKIP][227] ([Intel XE#3904] / [Intel XE#7342]) -> [SKIP][228] ([Intel XE#8714])
   [227]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@kms_rotation_crc@sprite-rotation-270.html
   [228]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_rotation_crc@sprite-rotation-270.html

  * igt@kms_scaling_modes@scaling-mode-center:
    - shard-bmg:          [SKIP][229] ([Intel XE#8714]) -> [SKIP][230] ([Intel XE#2413]) +2 other tests skip
   [229]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_scaling_modes@scaling-mode-center.html
   [230]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_scaling_modes@scaling-mode-center.html

  * igt@kms_setmode@basic-clone-single-crtc:
    - shard-bmg:          [SKIP][231] ([Intel XE#8714]) -> [SKIP][232] ([Intel XE#1435] / [Intel XE#8695]) +1 other test skip
   [231]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_setmode@basic-clone-single-crtc.html
   [232]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_setmode@basic-clone-single-crtc.html

  * igt@kms_sharpness_filter@filter-tap:
    - shard-bmg:          [SKIP][233] ([Intel XE#8714]) -> [SKIP][234] ([Intel XE#6503]) +1 other test skip
   [233]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_sharpness_filter@filter-tap.html
   [234]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_sharpness_filter@filter-tap.html

  * igt@kms_sharpness_filter@invalid-filter-with-scaling-mode:
    - shard-bmg:          [SKIP][235] ([Intel XE#6503]) -> [SKIP][236] ([Intel XE#8714]) +2 other tests skip
   [235]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@kms_sharpness_filter@invalid-filter-with-scaling-mode.html
   [236]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_sharpness_filter@invalid-filter-with-scaling-mode.html

  * igt@kms_vrr@lobf-dc3co:
    - shard-bmg:          [SKIP][237] ([Intel XE#8397]) -> [SKIP][238] ([Intel XE#8714])
   [237]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@kms_vrr@lobf-dc3co.html
   [238]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@kms_vrr@lobf-dc3co.html

  * igt@kms_vrr@seamless-rr-switch-virtual:
    - shard-bmg:          [SKIP][239] ([Intel XE#8714]) -> [SKIP][240] ([Intel XE#1499]) +1 other test skip
   [239]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@kms_vrr@seamless-rr-switch-virtual.html
   [240]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@kms_vrr@seamless-rr-switch-virtual.html

  * igt@xe_compute@ccs-mode-basic:
    - shard-bmg:          [SKIP][241] ([Intel XE#6599]) -> [SKIP][242] ([Intel XE#8714])
   [241]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_compute@ccs-mode-basic.html
   [242]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_compute@ccs-mode-basic.html

  * igt@xe_compute@ccs-mode-compute-kernel:
    - shard-bmg:          [SKIP][243] ([Intel XE#8714]) -> [SKIP][244] ([Intel XE#6599])
   [243]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_compute@ccs-mode-compute-kernel.html
   [244]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@xe_compute@ccs-mode-compute-kernel.html

  * igt@xe_configfs@engines-allowed-invalid:
    - shard-bmg:          [ABORT][245] ([Intel XE#8007]) -> [SKIP][246] ([Intel XE#8714])
   [245]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@xe_configfs@engines-allowed-invalid.html
   [246]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_configfs@engines-allowed-invalid.html

  * igt@xe_evict@evict-mixed-threads-small-multi-queue:
    - shard-bmg:          [SKIP][247] ([Intel XE#8370]) -> [SKIP][248] ([Intel XE#8714])
   [247]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_evict@evict-mixed-threads-small-multi-queue.html
   [248]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_evict@evict-mixed-threads-small-multi-queue.html

  * igt@xe_evict@evict-small-multi-queue-cm:
    - shard-bmg:          [SKIP][249] ([Intel XE#8714]) -> [SKIP][250] ([Intel XE#8370])
   [249]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_evict@evict-small-multi-queue-cm.html
   [250]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@xe_evict@evict-small-multi-queue-cm.html

  * igt@xe_exec_basic@multigpu-many-execqueues-many-vm-userptr-invalidate:
    - shard-bmg:          [SKIP][251] ([Intel XE#2322] / [Intel XE#7372]) -> [SKIP][252] ([Intel XE#8714]) +11 other tests skip
   [251]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_exec_basic@multigpu-many-execqueues-many-vm-userptr-invalidate.html
   [252]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_exec_basic@multigpu-many-execqueues-many-vm-userptr-invalidate.html

  * igt@xe_exec_basic@multigpu-once-null-rebind:
    - shard-bmg:          [SKIP][253] ([Intel XE#8714]) -> [SKIP][254] ([Intel XE#2322] / [Intel XE#7372]) +10 other tests skip
   [253]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_exec_basic@multigpu-once-null-rebind.html
   [254]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@xe_exec_basic@multigpu-once-null-rebind.html

  * igt@xe_exec_fault_mode@many-execqueues-multi-queue-userptr:
    - shard-bmg:          [SKIP][255] ([Intel XE#8714]) -> [SKIP][256] ([Intel XE#8374]) +14 other tests skip
   [255]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_exec_fault_mode@many-execqueues-multi-queue-userptr.html
   [256]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@xe_exec_fault_mode@many-execqueues-multi-queue-userptr.html

  * igt@xe_exec_fault_mode@many-execqueues-multi-queue-userptr-invalidate-imm:
    - shard-bmg:          [SKIP][257] ([Intel XE#8374]) -> [SKIP][258] ([Intel XE#8714]) +13 other tests skip
   [257]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_exec_fault_mode@many-execqueues-multi-queue-userptr-invalidate-imm.html
   [258]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_exec_fault_mode@many-execqueues-multi-queue-userptr-invalidate-imm.html

  * igt@xe_exec_multi_queue@two-queues-basic-smem:
    - shard-bmg:          [SKIP][259] ([Intel XE#8714]) -> [SKIP][260] ([Intel XE#8364]) +33 other tests skip
   [259]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_exec_multi_queue@two-queues-basic-smem.html
   [260]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@xe_exec_multi_queue@two-queues-basic-smem.html

  * igt@xe_exec_multi_queue@two-queues-preempt-mode-fault-dyn-priority-smem:
    - shard-bmg:          [SKIP][261] ([Intel XE#8364]) -> [SKIP][262] ([Intel XE#8714]) +35 other tests skip
   [261]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@xe_exec_multi_queue@two-queues-preempt-mode-fault-dyn-priority-smem.html
   [262]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_exec_multi_queue@two-queues-preempt-mode-fault-dyn-priority-smem.html

  * igt@xe_exec_reset@cm-multi-queue-cat-error:
    - shard-bmg:          [SKIP][263] ([Intel XE#8369]) -> [SKIP][264] ([Intel XE#8714]) +2 other tests skip
   [263]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_exec_reset@cm-multi-queue-cat-error.html
   [264]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_exec_reset@cm-multi-queue-cat-error.html

  * igt@xe_exec_reset@cm-multi-queue-close-execqueues:
    - shard-bmg:          [SKIP][265] ([Intel XE#8714]) -> [SKIP][266] ([Intel XE#8369]) +1 other test skip
   [265]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_exec_reset@cm-multi-queue-close-execqueues.html
   [266]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@xe_exec_reset@cm-multi-queue-close-execqueues.html

  * igt@xe_exec_reset@long-spin-reuse-many-preempt-gt1-threads:
    - shard-bmg:          [FAIL][267] ([Intel XE#7850]) -> [SKIP][268] ([Intel XE#8714])
   [267]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-8/igt@xe_exec_reset@long-spin-reuse-many-preempt-gt1-threads.html
   [268]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_exec_reset@long-spin-reuse-many-preempt-gt1-threads.html

  * igt@xe_exec_threads@threads-multi-queue-fd-userptr-invalidate-race:
    - shard-bmg:          [SKIP][269] ([Intel XE#8714]) -> [SKIP][270] ([Intel XE#8378]) +10 other tests skip
   [269]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_exec_threads@threads-multi-queue-fd-userptr-invalidate-race.html
   [270]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@xe_exec_threads@threads-multi-queue-fd-userptr-invalidate-race.html

  * igt@xe_exec_threads@threads-multi-queue-mixed-shared-vm-userptr-rebind:
    - shard-bmg:          [SKIP][271] ([Intel XE#8378]) -> [SKIP][272] ([Intel XE#8714]) +11 other tests skip
   [271]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_exec_threads@threads-multi-queue-mixed-shared-vm-userptr-rebind.html
   [272]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_exec_threads@threads-multi-queue-mixed-shared-vm-userptr-rebind.html

  * igt@xe_multigpu_svm@mgpu-atomic-op-basic:
    - shard-bmg:          [SKIP][273] ([Intel XE#6964]) -> [SKIP][274] ([Intel XE#6964] / [Intel XE#8714]) +5 other tests skip
   [273]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@xe_multigpu_svm@mgpu-atomic-op-basic.html
   [274]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_multigpu_svm@mgpu-atomic-op-basic.html

  * igt@xe_multigpu_svm@mgpu-latency-copy-basic:
    - shard-bmg:          [SKIP][275] ([Intel XE#6964] / [Intel XE#8714]) -> [SKIP][276] ([Intel XE#6964]) +2 other tests skip
   [275]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_multigpu_svm@mgpu-latency-copy-basic.html
   [276]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@xe_multigpu_svm@mgpu-latency-copy-basic.html

  * igt@xe_oa@oa-tlb-invalidate:
    - shard-bmg:          [SKIP][277] ([Intel XE#2248] / [Intel XE#7325] / [Intel XE#7393]) -> [SKIP][278] ([Intel XE#8714])
   [277]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@xe_oa@oa-tlb-invalidate.html
   [278]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_oa@oa-tlb-invalidate.html

  * igt@xe_page_reclaim@basic-mixed:
    - shard-bmg:          [SKIP][279] ([Intel XE#7793]) -> [SKIP][280] ([Intel XE#8714]) +3 other tests skip
   [279]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_page_reclaim@basic-mixed.html
   [280]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_page_reclaim@basic-mixed.html

  * igt@xe_page_reclaim@binds-null-vma:
    - shard-bmg:          [SKIP][281] ([Intel XE#8714]) -> [SKIP][282] ([Intel XE#7793]) +2 other tests skip
   [281]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_page_reclaim@binds-null-vma.html
   [282]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@xe_page_reclaim@binds-null-vma.html

  * igt@xe_pat@pat-index-xehpc:
    - shard-bmg:          [SKIP][283] ([Intel XE#8714]) -> [SKIP][284] ([Intel XE#1420] / [Intel XE#7590])
   [283]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_pat@pat-index-xehpc.html
   [284]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@xe_pat@pat-index-xehpc.html

  * igt@xe_pat@pat-index-xelp:
    - shard-bmg:          [SKIP][285] ([Intel XE#8714]) -> [SKIP][286] ([Intel XE#2245] / [Intel XE#7590])
   [285]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_pat@pat-index-xelp.html
   [286]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-10/igt@xe_pat@pat-index-xelp.html

  * igt@xe_pat@pat-index-xelpg:
    - shard-bmg:          [SKIP][287] ([Intel XE#2236] / [Intel XE#7590]) -> [SKIP][288] ([Intel XE#8714])
   [287]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_pat@pat-index-xelpg.html
   [288]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_pat@pat-index-xelpg.html

  * igt@xe_pat@pat-sw-hw-reset-compare:
    - shard-bmg:          [FAIL][289] ([Intel XE#7695]) -> [SKIP][290] ([Intel XE#8714])
   [289]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-4/igt@xe_pat@pat-sw-hw-reset-compare.html
   [290]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_pat@pat-sw-hw-reset-compare.html

  * igt@xe_pm@d3cold-i2c:
    - shard-bmg:          [SKIP][291] ([Intel XE#8714]) -> [SKIP][292] ([Intel XE#5694] / [Intel XE#7370])
   [291]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_pm@d3cold-i2c.html
   [292]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@xe_pm@d3cold-i2c.html

  * igt@xe_pm@d3cold-mmap-system:
    - shard-bmg:          [SKIP][293] ([Intel XE#8714]) -> [SKIP][294] ([Intel XE#2284] / [Intel XE#7370]) +1 other test skip
   [293]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_pm@d3cold-mmap-system.html
   [294]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-8/igt@xe_pm@d3cold-mmap-system.html

  * igt@xe_pm@s3-d3cold-basic-exec:
    - shard-bmg:          [SKIP][295] ([Intel XE#2284] / [Intel XE#7370]) -> [SKIP][296] ([Intel XE#8714]) +2 other tests skip
   [295]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@xe_pm@s3-d3cold-basic-exec.html
   [296]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_pm@s3-d3cold-basic-exec.html

  * igt@xe_pxp@pxp-stale-bo-bind-post-termination-irq:
    - shard-bmg:          [SKIP][297] ([Intel XE#8714]) -> [SKIP][298] ([Intel XE#4733] / [Intel XE#7417]) +3 other tests skip
   [297]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_pxp@pxp-stale-bo-bind-post-termination-irq.html
   [298]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@xe_pxp@pxp-stale-bo-bind-post-termination-irq.html

  * igt@xe_pxp@pxp-stale-bo-exec-post-termination-irq:
    - shard-bmg:          [SKIP][299] ([Intel XE#4733] / [Intel XE#7417]) -> [SKIP][300] ([Intel XE#8714]) +2 other tests skip
   [299]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-9/igt@xe_pxp@pxp-stale-bo-exec-post-termination-irq.html
   [300]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_pxp@pxp-stale-bo-exec-post-termination-irq.html

  * igt@xe_query@multigpu-query-invalid-cs-cycles:
    - shard-bmg:          [SKIP][301] ([Intel XE#944]) -> [SKIP][302] ([Intel XE#8714]) +3 other tests skip
   [301]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-10/igt@xe_query@multigpu-query-invalid-cs-cycles.html
   [302]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-7/igt@xe_query@multigpu-query-invalid-cs-cycles.html

  * igt@xe_query@multigpu-query-invalid-size:
    - shard-bmg:          [SKIP][303] ([Intel XE#8714]) -> [SKIP][304] ([Intel XE#944]) +3 other tests skip
   [303]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_query@multigpu-query-invalid-size.html
   [304]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@xe_query@multigpu-query-invalid-size.html

  
  [Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
  [Intel XE#1178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1178
  [Intel XE#1420]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1420
  [Intel XE#1435]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1435
  [Intel XE#1439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1439
  [Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489
  [Intel XE#1499]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1499
  [Intel XE#1503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1503
  [Intel XE#1508]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1508
  [Intel XE#2134]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2134
  [Intel XE#2229]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2229
  [Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234
  [Intel XE#2236]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2236
  [Intel XE#2245]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2245
  [Intel XE#2248]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2248
  [Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252
  [Intel XE#2284]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2284
  [Intel XE#2286]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2286
  [Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
  [Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
  [Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320
  [Intel XE#2321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2321
  [Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322
  [Intel XE#2325]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2325
  [Intel XE#2327]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2327
  [Intel XE#2330]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2330
  [Intel XE#2352]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2352
  [Intel XE#2373]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2373
  [Intel XE#2374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2374
  [Intel XE#2387]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2387
  [Intel XE#2390]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2390
  [Intel XE#2393]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2393
  [Intel XE#2413]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2413
  [Intel XE#2486]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2486
  [Intel XE#2505]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2505
  [Intel XE#2652]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2652
  [Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850
  [Intel XE#2887]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2887
  [Intel XE#2938]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2938
  [Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
  [Intel XE#3141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3141
  [Intel XE#3149]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3149
  [Intel XE#3304]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3304
  [Intel XE#3374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3374
  [Intel XE#3432]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3432
  [Intel XE#3544]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3544
  [Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
  [Intel XE#3904]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3904
  [Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141
  [Intel XE#4210]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4210
  [Intel XE#4298]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4298
  [Intel XE#4422]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4422
  [Intel XE#4733]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4733
  [Intel XE#5020]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5020
  [Intel XE#5021]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5021
  [Intel XE#5177]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5177
  [Intel XE#5545]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5545
  [Intel XE#5694]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5694
  [Intel XE#5813]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5813
  [Intel XE#5873]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5873
  [Intel XE#6035]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6035
  [Intel XE#607]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/607
  [Intel XE#610]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/610
  [Intel XE#6127]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6127
  [Intel XE#6503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6503
  [Intel XE#6599]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6599
  [Intel XE#6627]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6627
  [Intel XE#6707]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6707
  [Intel XE#6901]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6901
  [Intel XE#6911]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6911
  [Intel XE#6964]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6964
  [Intel XE#6974]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6974
  [Intel XE#7059]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7059
  [Intel XE#7061]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7061
  [Intel XE#7085]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7085
  [Intel XE#7178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7178
  [Intel XE#7179]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7179
  [Intel XE#7283]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7283
  [Intel XE#7325]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7325
  [Intel XE#7342]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7342
  [Intel XE#7348]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7348
  [Intel XE#7349]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7349
  [Intel XE#7351]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7351
  [Intel XE#7355]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7355
  [Intel XE#7356]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7356
  [Intel XE#7358]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7358
  [Intel XE#7361]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7361
  [Intel XE#7370]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7370
  [Intel XE#7372]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7372
  [Intel XE#7374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7374
  [Intel XE#7376]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7376
  [Intel XE#7377]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7377
  [Intel XE#7383]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7383
  [Intel XE#7387]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7387
  [Intel XE#7393]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7393
  [Intel XE#7399]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7399
  [Intel XE#7402]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7402
  [Intel XE#7417]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7417
  [Intel XE#7419]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7419
  [Intel XE#7429]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7429
  [Intel XE#7439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7439
  [Intel XE#7442]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7442
  [Intel XE#7447]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7447
  [Intel XE#7448]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7448
  [Intel XE#7466]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7466
  [Intel XE#7467]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7467
  [Intel XE#7590]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7590
  [Intel XE#7642]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7642
  [Intel XE#7679]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7679
  [Intel XE#7695]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7695
  [Intel XE#7760]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7760
  [Intel XE#7793]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7793
  [Intel XE#7794]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7794
  [Intel XE#7795]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7795
  [Intel XE#7850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7850
  [Intel XE#8007]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8007
  [Intel XE#8265]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8265
  [Intel XE#8348]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8348
  [Intel XE#836]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/836
  [Intel XE#8364]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8364
  [Intel XE#8369]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8369
  [Intel XE#8370]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8370
  [Intel XE#8374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8374
  [Intel XE#8378]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8378
  [Intel XE#8395]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8395
  [Intel XE#8396]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8396
  [Intel XE#8397]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8397
  [Intel XE#8551]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8551
  [Intel XE#8599]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8599
  [Intel XE#8695]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8695
  [Intel XE#870]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/870
  [Intel XE#8710]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8710
  [Intel XE#8711]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8711
  [Intel XE#8714]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8714
  [Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944


Build changes
-------------

  * Linux: xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd -> xe-pw-171022v3

  IGT_9034: be1d1af352dbd4ca4557202a8ed0d6d60f95e0bf @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd: 5e24f68d311764bf343f9def49b752b509dfd5fd
  xe-pw-171022v3: 171022v3

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/index.html

[-- Attachment #2: Type: text/html, Size: 99380 bytes --]

Re: [PATCH v3 10/23] drm/xe/log: Add hardware error signatures

[Mallesh, Koujalagi]

On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
> Extend our error signatures definitions xe_sigid to cover also
> hardware-originated errors and make them distinguishable from
> initially defined software-initiated errors.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> Cc: Yoni Levitt <yoni.levitt@intel.com>
> ---
> v2: update comment (Sashiko)
> ---
>   drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 16 ++++++++++++++--
>   1 file changed, 14 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> index 99717fdf74a6..69cce4b45635 100644
> --- a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> @@ -159,14 +159,19 @@
>    * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery (reset). [RETRY]
>    * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault. [COLLECT]
>    * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault. [RECOVER]
> + * @XE_SIGID_HW: Generic hardware failure.
> + * @XE_SIGID_PCIE: PCIe interface errors.
> + * @XE_SIGID_DEVICE_MEMORY: Device memory errors
Add . @ end
> + * @XE_SIGID_CORE_COMPUTE: Compute/shader core errors.
> + * @XE_SIGID_FABRIC: Fabric errors.
> + * @XE_SIGID_SOC_INTERNAL: SoC-internal errors.
>    *
>    * The situations the driver detects and reports in software. Values are
>    * numbered sequentially, are only ever appended, and are never renumbered or
>    * reused. The tag in brackets is the default resolution bucket (see the `Xe
>    * Error Signatures (SIGID)`_ section).
>    *
> - * Firmware- and hardware-originated signatures are not listed here; they are
> - * logged as reported by those layers.
> + * Firmware- and hardware-originated signatures are numbered separately.
>    */
>   enum xe_sigid {
>   	XE_SIGID_SW			= INTEL_SIGID_GPU_XE_SOFTWARE_START,
> @@ -178,6 +183,13 @@ enum xe_sigid {
>   	XE_SIGID_GT_TDR			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
>   	XE_SIGID_MEM_FAULT		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
>   	XE_SIGID_IO_BUS			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
> +
> +	XE_SIGID_HW			= INTEL_SIGID_GPU_XE_HARDWARE_START,
> +	XE_SIGID_PCIE			= INTEL_SIGID_GPU_XE_HARDWARE_START + 1,
> +	XE_SIGID_DEVICE_MEMORY		= INTEL_SIGID_GPU_XE_HARDWARE_START + 2,
> +	XE_SIGID_CORE_COMPUTE		= INTEL_SIGID_GPU_XE_HARDWARE_START + 3,
> +	XE_SIGID_FABRIC			= INTEL_SIGID_GPU_XE_HARDWARE_START + 4,
> +	XE_SIGID_SOC_INTERNAL		= INTEL_SIGID_GPU_XE_HARDWARE_START + 5,

Since we've resolution bucket for SW sigid so do we need resolution 
bucket for HW sigid as well? If so how are we going to put HW sigid to 
resolution bucket?

Thanks,

-/Mallesh

>   };
>   
>   #endif

Re: [PATCH v3 03/23] drm/xe/log: Introduce structured component/location identifiers

[Mallesh, Koujalagi]

On 30-07-2026 08:50 pm, Michal Wajdeczko wrote:
> Introduce structured identifiers for each component type that
> could emit a SIGID log entry and for their locations. We plan
> to store those IDs in the CPER records for better filtering.
> Define also structured identifiers for the supported locations.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> Reviewed-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> ---
> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> Cc: Raag Jadav <raag.jadav@intel.com>
> Cc: Riana Tauro <riana.tauro@intel.com>
> ---
> v2: fix typo, define reserved ids (Michal)
> v3: fix kernel-doc to match code (Sashiko)
> ---
>   drivers/gpu/drm/xe/abi/xe_log_abi.h | 186 ++++++++++++++++++++++++++++
>   1 file changed, 186 insertions(+)
>   create mode 100644 drivers/gpu/drm/xe/abi/xe_log_abi.h
>
> diff --git a/drivers/gpu/drm/xe/abi/xe_log_abi.h b/drivers/gpu/drm/xe/abi/xe_log_abi.h
> new file mode 100644
> index 000000000000..4861a5b58c10
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/abi/xe_log_abi.h
> @@ -0,0 +1,186 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +#ifndef _ABI_XE_LOG_ABI_H_
> +#define _ABI_XE_LOG_ABI_H_
> +
> +#include <linux/bits.h>
> +#include <linux/bitfield.h>
> +
> +#include "abi/xe_sigid_abi.h"
> +
> +/**
> + * enum xe_log_component_bits - bits for components structure definitions
> + *
> + * Component identifiers are structured based on::
> + *
> + *     COMPONENT = CLASS(8b).TYPE(8b)
> + *

Are 8b sufficient for CLASS and TYPE?  In future we need to increase that.

> + * and the structure looks like this::
> + *
> + *     ├── SYSTEM(0)
> + *     │   └── ...
> + *     ├── DRIVER(1)
> + *     │   └── ...
> + *     ├── FEATURE(2)
> + *     │   └── ...
> + *     ├── FIRMWARE(4)
> + *     │   └── ...
> + *     └── HARDWARE(8)
> + *         └── ...
> + *
> + * Examples::
> + *
> + *     COMPONENT(0.type) = SYSTEM.type = system component
> + *     COMPONENT(1.type) = DRIVER.type = driver core component
> + *     COMPONENT(3.type) = DRIVER_FEATURE.type = driver feature
> + *     COMPONENT(5.type) = DRIVER_FIRMWARE.type = firmware driver component
> + *     COMPONENT(9.type) = DRIVER_HARDWARE.type = hardware driver component
> + *
> + */
> +enum xe_log_component_bits {
> +	/* private: */
> +	XE_LOG_COMPONENT_CLASS_MASK = GENMASK_U16(7, 0),
> +	XE_LOG_COMPONENT_TYPE_MASK = GENMASK_U16(15, 8),
> +	/* private: component classes */
> +	XE_LOG_COMPONENT_CLASS_SYSTEM = 0u,
> +	XE_LOG_COMPONENT_CLASS_DRIVER = 1u,
> +	XE_LOG_COMPONENT_CLASS_FEATURE = 2u,
> +	XE_LOG_COMPONENT_CLASS_FIRMWARE = 4u,
> +	XE_LOG_COMPONENT_CLASS_HARDWARE = 8u,
> +	XE_LOG_COMPONENT_CLASS_DRIVER_FEATURE = XE_LOG_COMPONENT_CLASS_DRIVER |
> +						XE_LOG_COMPONENT_CLASS_FEATURE,
> +	XE_LOG_COMPONENT_CLASS_DRIVER_FIRMWARE = XE_LOG_COMPONENT_CLASS_DRIVER |
> +						 XE_LOG_COMPONENT_CLASS_FIRMWARE,
> +	XE_LOG_COMPONENT_CLASS_DRIVER_HARDWARE = XE_LOG_COMPONENT_CLASS_DRIVER |
> +						 XE_LOG_COMPONENT_CLASS_HARDWARE,
> +	/* private: reserved identifiers */
> +	XE_LOG_COMPONENT_NONE = 0u,
> +};
> +
> +#define MAKE_XE_LOG_COMPONENT(_CLASS, type) \
> +	(FIELD_PREP_CONST(XE_LOG_COMPONENT_CLASS_MASK, \
> +			  XE_LOG_COMPONENT_CLASS_##_CLASS) | \
> +	 FIELD_PREP_CONST(XE_LOG_COMPONENT_TYPE_MASK, (type)))
> +
> +/**
> + * enum xe_log_location_bits - bits for location structure definitions
> + *
> + * Location identifiers are structured based on::
> + *
> + *     LOCATION = TYPE(8b).ID(8b)
> + *

Are 8b sufficient for Type and ID?

Everything else looks good.

Reviewed-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>

> + * and the structure looks like this::
> + *
> + *     ├── DEVICE(0)
> + *     │   └── MBZ(0)
> + *     ├── TILE(1)
> + *     │   ├── Tile0(0)
> + *     │   ├── ...
> + *     │   └── TileN(n)
> + *     ├── GT(1)
> + *     │   ├── GT0(0)
> + *     │   ├── ...
> + *     │   └── GTn(n)
> + *     └── ...
> + *
> + * Examples::
> + *
> + *     LOCATION(0.0) = NONE
> + *     LOCATION(1.0) = DEVICE.0 = "Device"
> + *     LOCATION(2.1) = TILE.1 = "Tile1"
> + *     LOCATION(3.2) = GT.2 = "GT2"
> + *
> + */
> +enum xe_log_location_bits {
> +	/* private: */
> +	XE_LOG_LOCATION_TYPE_MASK = GENMASK_U16(7, 0),
> +	XE_LOG_LOCATION_ID_MASK = GENMASK_U16(15, 8),
> +	/* private: location types */
> +	XE_LOG_LOCATION_TYPE_DEVICE = 1u,
> +	XE_LOG_LOCATION_TYPE_TILE = 2u,
> +	XE_LOG_LOCATION_TYPE_GT = 3u,
> +	/* private: reserved identifiers */
> +	XE_LOG_LOCATION_NONE = 0u,
> +};
> +
> +#define PREP_XE_LOG_LOCATION(type, id) \
> +	(FIELD_PREP(XE_LOG_LOCATION_TYPE_MASK, (type)) | \
> +	 FIELD_PREP(XE_LOG_LOCATION_ID_MASK, (id)))
> +
> +#define MAKE_XE_LOG_LOCATION(_TYPE, id) \
> +	PREP_XE_LOG_LOCATION(XE_LOG_LOCATION_TYPE_##_TYPE, (id))
> +
> +/**
> + * DEFINE_XE_LOG_COMPONENTS() - Define log components.
> + * @define: name of the inner macro to expand.
> + *
> + * Use this super macro to define custom code for the log components.
> + * The following parameters are available for each component::
> + *
> + *     define(CLASS, ID, TAG, SIGID, NAME)
> + *
> + * where:
> + *
> + *     @ID is the unique component identifier within CLASS.SUBCLASS.CATEGORY
> + *     @TAG is unique component tag (across all components)
> + *     @SIGID is the default xe_sigid for the component (without the XE_SIGID_ prefix)
> + */
> +#define DEFINE_XE_LOG_COMPONENTS(define) \
> +	/* */									\
> +	define(SYSTEM, 1, PCI, SW, "Linux PCI Subsystem")			\
> +	define(SYSTEM, 2, DRM, SW, "DRM")					\
> +	/* */									\
> +	define(DRIVER, 1, XE, SW, "Xe Driver")					\
> +	define(DRIVER, 2, PROBE, PROBE, "Driver Initialization")		\
> +	define(DRIVER, 3, WEDGED, WEDGED, "Device Malfunction")			\
> +	define(DRIVER, 4, RTP, SW, "Register Table Processing")			\
> +	define(DRIVER, 5, WA, SW, "Workarounds")				\
> +	define(DRIVER, 6, PAGEFAULT, MEM_FAULT, "Page Fault")			\
> +	/* */									\
> +	define(DRIVER_HARDWARE, 1, REGS, IO_BUS, "Registers")			\
> +	define(DRIVER_HARDWARE, 2, GGTT, IO_BUS, "Global GTT")			\
> +	define(DRIVER_HARDWARE, 3, GT, GT_TDR, "Graphics Technology")		\
> +	define(DRIVER_HARDWARE, 4, LMTT, IO_BUS, "LMEM Translation Table")	\
> +	define(DRIVER_HARDWARE, 5, MEMIRQ, IO_BUS, "Memory Based IRQ")		\
> +	/* */									\
> +	define(DRIVER_FEATURE, 1, PF, SW, "SR-IOV Physical Function")		\
> +	define(DRIVER_FEATURE, 2, VF, SW, "SR-IOV Virtual Function")		\
> +	define(DRIVER_FEATURE, 3, SURVIVABILITY, SURVIVABILITY, "Survivability") \
> +	define(DRIVER_FEATURE, 4, RAS, SW, "Reliability, Accessibility, Serviceability") \
> +	/* */									\
> +	define(DRIVER_FIRMWARE, 1, GUC, RUNTIME_FW, "GuC")			\
> +	define(DRIVER_FIRMWARE, 2, HUC, RUNTIME_FW, "HuC")			\
> +	define(DRIVER_FIRMWARE, 3, GSC, RUNTIME_FW, "GSC")			\
> +	define(DRIVER_FIRMWARE, 16, PCODE, DEVICE_FW, "PCode")			\
> +	define(DRIVER_FIRMWARE, 17, SYSCTRL, DEVICE_FW, "System Controller")	\
> +	/* eod */
> +
> +/**
> + * enum xe_log_component_tags - TAGs of all supported components
> + */
> +enum xe_log_component_tags {
> +	/* private: */
> +#define MAKE_XE_LOG_COMPONENT_ENUM(_CLASS, _ID, _TAG, _SIG, _NAME) \
> +	XE_LOG_COMPONENT_##_TAG = MAKE_XE_LOG_COMPONENT(_CLASS, (_ID)), \
> +	XE_LOG_COMPONENT_##_CLASS##_##_ID = XE_LOG_COMPONENT_##_TAG, \
> +	/* eod */
> +	DEFINE_XE_LOG_COMPONENTS(MAKE_XE_LOG_COMPONENT_ENUM)
> +#undef MAKE_XE_LOG_COMPONENT_ENUM
> +};
> +
> +/**
> + * enum xe_log_component_sigids - SIGIDs of all supported components
> + */
> +enum xe_log_component_sigids {
> +	/* private: */
> +#define MAKE_XE_LOG_COMPONENT_SIGID(_CLASS, _ID, _TAG, _SIG, _NAME) \
> +	XE_LOG_COMPONENT_##_TAG##_SIGID = XE_SIGID_##_SIG, \
> +	/* eod */
> +	DEFINE_XE_LOG_COMPONENTS(MAKE_XE_LOG_COMPONENT_SIGID)
> +#undef MAKE_XE_LOG_COMPONENT_SIGID
> +};
> +
> +#endif

Re: [PATCH v3 05/23] drm/xe/log: Add SIGID log helpers for severity

[Mallesh, Koujalagi]

On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
> There are only few CPER severity levels defined, add simple helper
> for each of them, to avoid forcing developers to write full severity
> name in every function call.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
LGTM,
Reviewed-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> ---
> v2: drop support for any_to_pdev (Michal)
> ---
>   drivers/gpu/drm/xe/xe_log.h | 16 ++++++++++++++++
>   1 file changed, 16 insertions(+)
>
> diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
> index d475e816ee0b..73daf37d6463 100644
> --- a/drivers/gpu/drm/xe/xe_log.h
> +++ b/drivers/gpu/drm/xe/xe_log.h
> @@ -17,4 +17,20 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
>   		 u32 component, u32 location, const void *data, size_t len,
>   		 const char *fmt, ...);
>   
> +#define xe_log_emit_fatal(pdev, sig, comp, loc, data, len, fmt, args...) \
> +	xe_log_emit((pdev), CPER_SEV_FATAL, (sig), (comp), (loc), \
> +		    (data), (len), fmt, ##args)
> +
> +#define xe_log_emit_recoverable(pdev, sig, comp, loc, data, len, fmt, args...) \
> +	xe_log_emit((pdev), CPER_SEV_RECOVERABLE, (sig), (comp), (loc), \
> +		    (data), (len), fmt, ##args)
> +
> +#define xe_log_emit_corrected(pdev, sig, comp, loc, data, len, fmt, args...) \
> +	xe_log_emit((pdev), CPER_SEV_CORRECTED, (sig), (comp), (loc), \
> +		    (data), (len), fmt, ##args)
> +
> +#define xe_log_emit_info(pdev, sig, comp, loc, data, len, fmt, args...) \
> +	xe_log_emit((pdev), CPER_SEV_INFORMATIONAL, (sig), (comp), (loc), \
> +		    (data), (len), fmt, ##args)
> +
>   #endif

Re: [PATCH v3 06/23] drm/xe/log: Add SIGID log helpers for location

[Mallesh, Koujalagi]

On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
> We can determine the location of the SIGID error source based on the
> type of the xe pointer being currently available. Add helper macros
> that will accept any of xe_device, xe_tile or xe_gt pointers instead
> of plain pci_dev to generate valid XE_LOG_LOCATION identifier and then
> call low-level xe_log_emit(pdev) function.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
LGTM,
Reviewed-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> ---
> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> ---
>   drivers/gpu/drm/xe/xe_log.h | 36 ++++++++++++++++++++++++++++++++++++
>   1 file changed, 36 insertions(+)
>
> diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
> index 73daf37d6463..510cedae6e14 100644
> --- a/drivers/gpu/drm/xe/xe_log.h
> +++ b/drivers/gpu/drm/xe/xe_log.h
> @@ -8,7 +8,9 @@
>   
>   #include <linux/cper.h>
>   
> +#include "abi/xe_log_abi.h"
>   #include "abi/xe_sigid_abi.h"
> +#include "xe_any.h"
>   
>   struct pci_dev;
>   
> @@ -33,4 +35,38 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
>   	xe_log_emit((pdev), CPER_SEV_INFORMATIONAL, (sig), (comp), (loc), \
>   		    (data), (len), fmt, ##args)
>   
> +#define xe_log_location_type(any)							\
> +	_Generic((any),									\
> +		 struct xe_gt * : XE_LOG_LOCATION_TYPE_GT,				\
> +		 const struct xe_gt * : XE_LOG_LOCATION_TYPE_GT,			\
> +		 struct xe_tile * : XE_LOG_LOCATION_TYPE_TILE,				\
> +		 const struct xe_tile * : XE_LOG_LOCATION_TYPE_TILE,			\
> +		 struct xe_device * : XE_LOG_LOCATION_TYPE_DEVICE,			\
> +		 const struct xe_device * : XE_LOG_LOCATION_TYPE_DEVICE,		\
> +		 struct pci_dev * : XE_LOG_LOCATION_TYPE_DEVICE,			\
> +		 struct device * : XE_LOG_LOCATION_TYPE_DEVICE)
> +
> +#define xe_log_location(any) \
> +	PREP_XE_LOG_LOCATION(xe_log_location_type(any), xe_any_id(any))
> +
> +/**
> + * xe_log_from() - Emit a structured SIGID log entry using @any pointer as location.
> + * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
> + * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE, ...)
> + * @sigid: signature identifier, see &enum xe_sigid
> + * @component: component identifer
> + * @data: pointer to the additional details, or ERR_PTR, or NULL if not applicable
> + * @len: length of the @data in bytes, or 0 if not applicable
> + * @fmt: printf-style format string
> + * @args: arguments for the @fmt format string
> + *
> + * The location used to emit SIGID entry will be based on the @any pointer type.
> + * See xe_log_emit() for more details.
> + */
> +#define xe_log_from(any, cper_sev, sigid, component, data, len, fmt, args...) do {	\
> +	typeof(any) ___any = (any);							\
> +	xe_log_emit(xe_any_to_pdev(___any), (cper_sev), (sigid), (component),		\
> +		    xe_log_location(___any), (data), (len), fmt, ##args);		\
> +} while (0)
> +
>   #endif

Re: [PATCH v3 07/23] drm/xe/log: Add SIGID log helpers for location & severity

[Mallesh, Koujalagi]

On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
> There are only few CPER severity levels defined, add more helpers
> to avoid forcing developers to write full CPER severity name in
> every function call.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
LGTM,
Reviewed-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> ---
> v2: fix argument list (Sashiko)
> ---
>   drivers/gpu/drm/xe/xe_log.h | 16 ++++++++++++++++
>   1 file changed, 16 insertions(+)
>
> diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
> index 510cedae6e14..916218560297 100644
> --- a/drivers/gpu/drm/xe/xe_log.h
> +++ b/drivers/gpu/drm/xe/xe_log.h
> @@ -69,4 +69,20 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
>   		    xe_log_location(___any), (data), (len), fmt, ##args);		\
>   } while (0)
>   
> +#define xe_log_from_fatal(any, sig, comp, data, len, fmt, args...) \
> +	xe_log_from((any), CPER_SEV_FATAL, (sig), (comp), \
> +		    (data), (len), fmt, ##args)
> +
> +#define xe_log_from_recoverable(any, sig, comp, data, len, fmt, args...) \
> +	xe_log_from((any), CPER_SEV_RECOVERABLE, (sig), (comp), \
> +		    (data), (len), fmt, ##args)
> +
> +#define xe_log_from_corrected(any, sig, comp, data, len, fmt, args...) \
> +	xe_log_from((any), CPER_SEV_CORRECTED, (sig), (comp), \
> +		    (data), (len), fmt, ##args)
> +
> +#define xe_log_from_info(any, sig, comp, data, len, fmt, args...) \
> +	xe_log_from((any), CPER_SEV_INFORMATIONAL, (sig), (comp), \
> +		    (data), (len), fmt, ##args)
> +
>   #endif

Re: [PATCH v3 08/23] drm/xe/log: Add SIGID log helpers for components

[Mallesh, Koujalagi]

On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
> Our component list already defines relation between the component
> name, identified by the TAG, and its numerical identifier and the
> assigned SIGID. We can also already prepare location identifier
> based on the pointer type used to emit the log entry. Add helper
> that will prepare SIGID, COMPONENT and LOCATION parameters for
> xe_log_emit() using provided components TAG and the pointer.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
LGTM,
Reviewed-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> ---
> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> ---
> v2: rebased/simplified (Michal)
> ---
>   drivers/gpu/drm/xe/xe_log.h | 18 ++++++++++++++++++
>   1 file changed, 18 insertions(+)
>
> diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
> index 916218560297..c30db02950b0 100644
> --- a/drivers/gpu/drm/xe/xe_log.h
> +++ b/drivers/gpu/drm/xe/xe_log.h
> @@ -85,4 +85,22 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
>   	xe_log_from((any), CPER_SEV_INFORMATIONAL, (sig), (comp), \
>   		    (data), (len), fmt, ##args)
>   
> +/**
> + * xe_log_comp() - Emit a structured SIGID log entry on the component behalf.
> + * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
> + * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE, ...)
> + * @TAG: the component tag to use
> + * @data: pointer to the additional details, or ERR_PTR, or NULL if not applicable
> + * @len: length of the @data in bytes, or 0 if not applicable
> + * @fmt: printf-style free text format string (not a stable interface)
> + * @args: arguments for the @fmt format string
> + *
> + * The SIGID will be determined from the component's @TAG.
> + * The component identifier will be determined from the component's @TAG.
> + * The location used to emit SIGID entry will be based on the @any pointer type.
> + */
> +#define xe_log_comp(any, cper_sev, TAG, data, len, fmt, args...) \
> +	xe_log_from((any), (cper_sev), (int)XE_LOG_COMPONENT_##TAG##_SIGID, \
> +		    XE_LOG_COMPONENT_##TAG, (data), (len), fmt, ##args)
> +
>   #endif

Re: [PATCH v3 09/23] drm/xe/log: Add SIGID log helpers for errno-only

[Mallesh, Koujalagi]

On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
> For the software based SIGID errors, we will usually want to pass
> only the errno value as the data to be logged in the dmesg line or
> the CPER record. Add simple wrappers for that.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> ---
> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> ---
> v2: include linux/err.h (Sashiko)
>      add xe_log_err_corrected (Michal)
> ---
>   drivers/gpu/drm/xe/xe_log.h | 52 +++++++++++++++++++++++++++++++++++++
>   1 file changed, 52 insertions(+)
>
> diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
> index c30db02950b0..5716fb7eeb31 100644
> --- a/drivers/gpu/drm/xe/xe_log.h
> +++ b/drivers/gpu/drm/xe/xe_log.h
> @@ -7,6 +7,7 @@
>   #define _XE_LOG_H_
>   
>   #include <linux/cper.h>
> +#include <linux/err.h>
>   
>   #include "abi/xe_log_abi.h"
>   #include "abi/xe_sigid_abi.h"
> @@ -103,4 +104,55 @@ void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
>   	xe_log_from((any), (cper_sev), (int)XE_LOG_COMPONENT_##TAG##_SIGID, \
>   		    XE_LOG_COMPONENT_##TAG, (data), (len), fmt, ##args)
>   
> +/**
> + * xe_log_err() - Emit a structured SIGID error log entry on the component behalf.
> + * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
> + * @TAG: the component tag to use
> + * @err: negative errno for the failing operation, or 0 if not applicable
> + * @fmt: printf-style free text format string (not a stable interface)
> + * @args: arguments for the @fmt format string
> + *
> + * The log entry will be emitted with @CPER_SEV_RECOVERABLE severity.
> + */
> +#define xe_log_err(any, TAG, err, fmt, args...) \
> +	xe_log_comp((any), CPER_SEV_RECOVERABLE, TAG, ERR_PTR(err), 0, fmt, ##args)
> +
> +/**
> + * xe_log_err_fatal() - Emit a structured SIGID error log entry on the component behalf.
> + * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
> + * @TAG: the component tag to use
> + * @err: negative errno for the failing operation, or 0 if not applicable
> + * @fmt: printf-style free text format string (not a stable interface)
> + * @args: arguments for the @fmt format string
> + *
> + * The log entry will be emitted with @CPER_SEV_FATAL severity.
> + */
> +#define xe_log_err_fatal(any, TAG, err, fmt, args...) \
> +	xe_log_comp((any), CPER_SEV_FATAL, TAG, ERR_PTR(err), 0, fmt, ##args)
> +
> +/**
> + * xe_log_err_corrected() - Emit a structured SIGID error log entry on the component behalf.
> + * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
> + * @TAG: the component tag to use
> + * @err: negative errno for the failing operation, or 0 if not applicable
> + * @fmt: printf-style free text format string (not a stable interface)
> + * @args: arguments for the @fmt format string
> + *
> + * The log entry will be emitted with @CPER_SEV_CORRECTED severity.
> + */
> +#define xe_log_err_corrected(any, TAG, err, fmt, args...) \
> +	xe_log_comp((any), CPER_SEV_CORRECTED, TAG, ERR_PTR(err), 0, fmt, ##args)
> +
> +/**
> + * xe_log_info() - Emit a structured SIGID information log entry on the component behalf.
> + * @any: the &xe_device or &xe_tile or &xe_gt pointer this report relates to
> + * @TAG: the component tag to use
> + * @fmt: printf-style free text format string (not a stable interface)
> + * @args: arguments for the @fmt format string
> + *
> + * The log entry will be emitted with @CPER_SEV_INFORMATIONAL severity.
> + */
> +#define xe_log_info(any, TAG, fmt, args...) \
> +	xe_log_comp((any), CPER_SEV_INFORMATIONAL, TAG, NULL, 0, fmt, ##args)
> +
Please add severity based helper function such as xe_log_comp_fatal(any, 
TAG, ...) etc.

Since we've severity based helper function for (xe_log_emit_*, 
xe_log_from_*) for consistency (1:1 mapping).

With that

Reviewed-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>

>   #endif

Re: [PATCH v3 11/23] drm/xe/log: Extend components list with hardware items

[Mallesh, Koujalagi]

On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
> Update our super macro with new top level hardware components.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
LGTM,
Reviewed-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> ---
> v2: follow enum xe_ras_component values (Aravind)
> ---
>   drivers/gpu/drm/xe/abi/xe_log_abi.h | 12 ++++++++++++
>   1 file changed, 12 insertions(+)
>
> diff --git a/drivers/gpu/drm/xe/abi/xe_log_abi.h b/drivers/gpu/drm/xe/abi/xe_log_abi.h
> index 4861a5b58c10..b3373d4b29d5 100644
> --- a/drivers/gpu/drm/xe/abi/xe_log_abi.h
> +++ b/drivers/gpu/drm/xe/abi/xe_log_abi.h
> @@ -129,6 +129,10 @@ enum xe_log_location_bits {
>    *     @SIGID is the default xe_sigid for the component (without the XE_SIGID_ prefix)
>    */
>   #define DEFINE_XE_LOG_COMPONENTS(define) \
> +	DEFINE_XE_LOG_SOFTWARE_COMPONENTS(define) \
> +	DEFINE_XE_LOG_HARDWARE_COMPONENTS(define)
> +
> +#define DEFINE_XE_LOG_SOFTWARE_COMPONENTS(define) \
>   	/* */									\
>   	define(SYSTEM, 1, PCI, SW, "Linux PCI Subsystem")			\
>   	define(SYSTEM, 2, DRM, SW, "DRM")					\
> @@ -156,6 +160,14 @@ enum xe_log_location_bits {
>   	define(DRIVER_FIRMWARE, 3, GSC, RUNTIME_FW, "GSC")			\
>   	define(DRIVER_FIRMWARE, 16, PCODE, DEVICE_FW, "PCode")			\
>   	define(DRIVER_FIRMWARE, 17, SYSCTRL, DEVICE_FW, "System Controller")	\
> +
> +#define DEFINE_XE_LOG_HARDWARE_COMPONENTS(define) \
> +	define(HARDWARE, 1, DEVMEM, DEVICE_MEMORY, "Device Memory")		\
> +	define(HARDWARE, 2, HWCORE, CORE_COMPUTE, "Core Compute")		\
> +	/*     HARDWARE, 3, RESERVED */						\
> +	define(HARDWARE, 4, PCIE, PCIE, "PCIe Interface")			\
> +	define(HARDWARE, 5, FABRIC, FABRIC, "Fabric")				\
> +	define(HARDWARE, 6, SOC, SOC_INTERNAL, "SoC Internal")			\
>   	/* eod */
>   
>   /**

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Tauro, Riana]

Hi Mallesh/Michal

On 30-07-2026 20:50, Michal Wajdeczko wrote:
> From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
>
> Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
> strings that have no stable shape. That is readable for a human, but it
> gives fleet tooling nothing durable to match on: the wording changes
> between releases, lines can be rate-limited or dropped under an error
> storm, and there is no consistent way to ask "which recognised fault
> just happened?".
>
> Introduce a signature identifier (SIGID): a small, stable integer that
> names one recognised Xe fault situation and serves as the primary handle
> for triage. A SIGID maps, through published end-user documentation, to a
> description and a recommended action; the driver only has to emit the
> right SIGID next to the usual human-readable text.
>
> Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> Assisted-by: Copilot:Opus-4.8
> Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---
> Cc: Yoni Levitt <yoni.levitt@intel.com>
> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> Cc: Raag Jadav <raag.jadav@intel.com>
> Cc: Riana Tauro <riana.tauro@intel.com>
> ---
> v2: CORRECTED is still an error (Michal)
>      prepare to decorate dmesg with comp/loc (Michal)
> ---
>   Documentation/gpu/xe/index.rst        |   1 +
>   Documentation/gpu/xe/xe_sigid.rst     |  14 ++
>   drivers/gpu/drm/xe/Makefile           |   1 +
>   drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183 ++++++++++++++++++++++++++
>   drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
>   drivers/gpu/drm/xe/xe_log.h           |  20 +++
>   6 files changed, 354 insertions(+)
>   create mode 100644 Documentation/gpu/xe/xe_sigid.rst
>   create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>   create mode 100644 drivers/gpu/drm/xe/xe_log.c
>   create mode 100644 drivers/gpu/drm/xe/xe_log.h
>
> diff --git a/Documentation/gpu/xe/index.rst b/Documentation/gpu/xe/index.rst
> index 665c0e93601c..0247a255f7e6 100644
> --- a/Documentation/gpu/xe/index.rst
> +++ b/Documentation/gpu/xe/index.rst
> @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for drm/xe is provided by
>      xe-drm-usage-stats.rst
>      xe_configfs
>      xe_gt_stats
> +   xe_sigid
> diff --git a/Documentation/gpu/xe/xe_sigid.rst b/Documentation/gpu/xe/xe_sigid.rst
> new file mode 100644
> index 000000000000..45d84a62f185
> --- /dev/null
> +++ b/Documentation/gpu/xe/xe_sigid.rst
> @@ -0,0 +1,14 @@
> +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> +
> +========
> +Xe SIGID
> +========
> +
> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> +   :doc: Xe Error Signatures (SIGID)
> +
> +Signature Identifiers
> +=====================
> +
> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> +   :internal:
> diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
> index 67ada1d6c2fb..7ac3954737f9 100644
> --- a/drivers/gpu/drm/xe/Makefile
> +++ b/drivers/gpu/drm/xe/Makefile
> @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
>   	xe_hw_fence.o \
>   	xe_irq.o \
>   	xe_late_bind_fw.o \
> +	xe_log.o \
>   	xe_lrc.o \
>   	xe_mem_pool.o \
>   	xe_migrate.o \
> diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> new file mode 100644
> index 000000000000..99717fdf74a6
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> @@ -0,0 +1,183 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +#ifndef _ABI_XE_SIGID_ABI_H_
> +#define _ABI_XE_SIGID_ABI_H_
> +
> +/**
> + * DOC: Xe Error Signatures (SIGID)
> + *
> + * What SIGID stands for
> + * ---------------------
> + *
> + * SIGID is short for *Signature Identifier*. A SIGID is a small, stable integer
> + * that names one *recognised Xe fault situation* -- nothing more. It is the
> + * primary handle used for triage: a SIGID maps to a human description and a
The SIG ID maps to a report site as mentioned in "How to pick a sigid" 
not a human description.

> + * recommended first action. A coarse first-order action is documented in-tree
> + * per SIGID (see "First-order action" below) so the id is actionable on its
> + * own; published end-user documentation refines it with finer, cross-product
> + * detail. The driver's only job is to emit the right SIGID next to the usual
> + * human-readable text.
> + *
> + * Why this exists
> + * ---------------
> + *
> + * Today the driver reports faults with ad-hoc ``drm_err()`` / ``xe_gt_err()``
> + * strings that have no stable shape. That is fine for a human reading dmesg,
> + * but it gives fleet tooling nothing durable to match on: the wording changes
> + * between releases, lines can be rate-limited or dropped under an error storm,
> + * and there is no consistent way to ask "which recognised fault just happened?"
> + * A SIGID answers exactly that one question, identically across driver and
> + * firmware versions, and (eventually) across other Intel devices in a node.
> + *
> + * What a SIGID is (and is not)
> + * ----------------------------
> + *
> + * A SIGID names *which situation* is being reported. It deliberately does not
This should also be consistent with "report site" instead of situation.
> + * encode the detailed reason or the outcome. Those are carried alongside it::
> + *
> + *   SIGID    -> which recognised situation is being reported
> + *   severity -> how serious this instance is (see below -- not fixed per SIGID)
> + *   errno    -> the failing operation's error, shown with %pe
> + *   message  -> free-form human-readable context
> + *
> + * Severity is independent of the SIGID. The same situation can be reported at
> + * different severities depending on the instance and the recovery taken, so a
> + * SIGID is never tied to one severity; the reporting site chooses it by calling
> + * the matching xe_log_*() helper (see xe_log.h).
> + *

It'd be more intuitive for readers if section "When to use SIGID 
logging" is moved before how to pick one.
> + * How to pick a SIGID (the uniqueness rule)
> + * -----------------------------------------
> + *
> + * Pick per *report site*, not per incident. Each site emits the single most
> + * specific recognised situation *for that site* -- so the question is never
> + * "classify this whole failure", it is "what does this site detect?", which has
> + * one answer. A single underlying failure therefore legitimately produces a
> + * *chain* of reports from different layers, each with its own SIGID -- e.g. a
> + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by the firmware
> + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path, and an
> + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain lets triage
> + * follow a fault from origin to final effect; it is not a duplicate.
> + *
> + * If a site does not match any defined situation, keep using the ordinary
> + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a SIGID: a wrong
> + * or over-broad classification is harder to retire than a missing one. When a
> + * new situation is genuinely worth triaging, add it to the list below.
> + *
> + * Scope: software-emitted signatures only
> + * ---------------------------------------
> + *
> + * This header enumerates only the situations that the *driver itself* detects
> + * and reports from software: probe abort, wedged, survivability, driver-
> + * detected firmware failures, engine TDR, memory faults and IO/bus faults.
> + * These are the only values the driver assigns.
> + *
> + * Signatures that *originate* in firmware or hardware are a different thing:
> + * they are produced and identified by the firmware or the hardware itself
> + * (e.g. via their own records or error counters), and the driver merely logs
> + * them as they are given to us. They are deliberately *not* enumerated here --
> + * minting a driver-side id for a firmware/hardware-reported error would only
> + * duplicate an identifier the reporting layer already owns. The two
> + * driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
> + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the driver*
> + * observed a firmware problem, not a signature reported by the firmware.
> + *
> + * Numbering
> + * ---------

This section also needs to be on the top. It can be missed if it is at 
the bottom of the document.

> + *
> + * SIGIDs are a single flat list numbered sequentially within the assigned range,
> + * in the order the situations were introduced. Values are stable: once assigned
> + * they are only ever appended, never renumbered or reused.
> + *
> + * A retired situation is deprecated in place, never re-purposed.
> + *
> + * First-order action (resolution buckets)
> + * ---------------------------------------
> + *
> + * So that a SIGID is actionable on its own, each one is tagged with a coarse
> + * *resolution bucket*: the first thing an operator should do on seeing it. The
> + * bucket is a stable, driver-owned hint; external documentation may refine it,
> + * but the in-tree value always stands on its own. Every new SIGID must pick a
> + * bucket, which forces the question "what should someone do about this?" to be
> + * answered up front. The buckets are::
> + *
> + *   COLLECT  -- capture logs and open a bug report
> + *   RETRY    -- transient or already recovered; watch for recurrence
> + *   UPDATE   -- a firmware update / flash is required
> + *   RECOVER  -- an explicit recovery step is needed (rebind, bus reset)


Do we actually need resolution buckets defined here? RECOVER or UPDATE 
seem a bit vague since states like
  WEDGED/SURVIVABILITY have different ways to recover depending on 
context. Wouldn't detailed resolution steps in another
document be better than in logs?

> + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
> + *
> + * The bucket is documentation only -- it is recorded per SIGID in the enum
> + * kernel-doc below and is not printed on the (deliberately lean) dmesg line.
> + *
> + * When to use SIGID logging
> + * -------------------------
> + *
> + * The xe_log_*() helpers are for these recognised fault situations only --
> + * important, operator-relevant faults and events. They are not a replacement
> + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off diagnostics;
> + * using them for ordinary logging would dilute the fault stream. Not every
> + * ``xe_err()`` needs to become a SIGID report -- only those that correspond to
> + * a published situation.
> + *
> + * dmesg vs. the machine record
> + * ----------------------------
> + *
> + * The dmesg line stays close to a normal xe error message so it remains
> + * readable for admins; the only stable, machine-matchable token on it is
> + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI: the surrounding
> + * text may change freely, and lines may be dropped. The durable record for
> + * tooling is the CPER record carrying the same SIGID (generation is a planned
> + * follow-up).
> + */
> +
> +/*
> + * Top level Intel Error Signature Identifiers.
> + */
> +#define INTEL_SIGID_INVALID			0
> +#define INTEL_SIGID_GPU_START			100

why does the sigid start from 100?

> +#define INTEL_SIGID_GPU_END			999
> +
> +#define INTEL_SIGID_GPU_XE_START		100
> +#define INTEL_SIGID_GPU_XE_END			299
> +
> +#define INTEL_SIGID_GPU_XE_SOFTWARE_START	100
> +#define INTEL_SIGID_GPU_XE_SOFTWARE_END		199
> +#define INTEL_SIGID_GPU_XE_HARDWARE_START	200
> +#define INTEL_SIGID_GPU_XE_HARDWARE_END		299
> +
> +/**
> + * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
> + * @XE_SIGID_SW: Software component failure. [COLLECT]
> + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
> + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer usable. [RECOVER]
> + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode. [UPDATE]
> + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure, GuC/HuC/GSC. [RETRY]
> + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure, PCODE/sysctrl. [RETRY]

Pcode or sysctrl errors cannot be retried. Pcode init failures cause 
survivability mode.
RAS sysctrl errors require a secondary bus reset. We could have other 
firmwares in future with different
recovery.
That is why it would be better to drop resolution buckets in logs.

@aravind thoughts?

Thanks
Riana

> + * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery (reset). [RETRY]
> + * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault. [COLLECT]
> + * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault. [RECOVER]
> + *
> + * The situations the driver detects and reports in software. Values are
> + * numbered sequentially, are only ever appended, and are never renumbered or
> + * reused. The tag in brackets is the default resolution bucket (see the `Xe
> + * Error Signatures (SIGID)`_ section).
> + *
> + * Firmware- and hardware-originated signatures are not listed here; they are
> + * logged as reported by those layers.
> + */
> +enum xe_sigid {
> +	XE_SIGID_SW			= INTEL_SIGID_GPU_XE_SOFTWARE_START,
> +	XE_SIGID_PROBE			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 1,
> +	XE_SIGID_WEDGED			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 2,
> +	XE_SIGID_SURVIVABILITY		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 3,
> +	XE_SIGID_RUNTIME_FW		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 4,
> +	XE_SIGID_DEVICE_FW		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 5,
> +	XE_SIGID_GT_TDR			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
> +	XE_SIGID_MEM_FAULT		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
> +	XE_SIGID_IO_BUS			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
> +};
> +
> +#endif
> diff --git a/drivers/gpu/drm/xe/xe_log.c b/drivers/gpu/drm/xe/xe_log.c
> new file mode 100644
> index 000000000000..70a41bdf1a01
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/xe_log.c
> @@ -0,0 +1,135 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +#include "xe_log.h"
> +#include "xe_printk.h"
> +
> +static void log_emit_cper(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
> +			  u32 component, u32 location, const void *data, size_t len,
> +			  struct va_format *vaf)
> +{
> +	/* TODO */
> +}
> +
> +static bool is_hw_sigid(enum xe_sigid sigid)
> +{
> +	return (int)sigid >= INTEL_SIGID_GPU_XE_HARDWARE_START;
> +}
> +
> +static bool is_sev_error(int cper_sev)
> +{
> +	return cper_sev != CPER_SEV_INFORMATIONAL;
> +}
> +
> +static const char *log_hwe_prefix(int cper_sev, enum xe_sigid sigid)
> +{
> +	return is_sev_error(cper_sev) && is_hw_sigid(sigid) ? HW_ERR : "";
> +}
> +
> +static const char *log_sev_prefix(int cper_sev)
> +{
> +	switch (cper_sev) {
> +	case CPER_SEV_FATAL:
> +		return "FATAL ";
> +	case CPER_SEV_RECOVERABLE:
> +		return "";
> +	case CPER_SEV_CORRECTED:
> +		return "CORRECTED ";
> +	default:
> +		return "";
> +	}
> +}
> +
> +#define __LOG_DRM_PRINTK_FMT(fmt, args...)	"[drm] " fmt, ##args
> +#define __LOG_DRM_PRINTK_ERR_FMT(fmt, args...)	__LOG_DRM_PRINTK_FMT("*ERROR* " fmt, args)
> +
> +static void log_dmesg_vprintk(struct pci_dev *pdev, int cper_sev, struct va_format *vaf)
> +{
> +	if (cper_sev == CPER_SEV_INFORMATIONAL)
> +		pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
> +	else
> +		pci_err(pdev, __LOG_DRM_PRINTK_ERR_FMT("%pV", vaf));
> +}
> +
> +static void log_dmesg_printf(struct pci_dev *pdev, int cper_sev, const char *fmt, ...)
> +{
> +	struct va_format vaf;
> +	va_list args;
> +
> +	va_start(args, fmt);
> +	vaf.fmt = fmt;
> +	vaf.va = &args;
> +
> +	log_dmesg_vprintk(pdev, cper_sev, &vaf);
> +
> +	va_end(args);
> +}
> +
> +static void log_emit_dmesg(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
> +			   u32 component, u32 location, const void *data, size_t len,
> +			   struct va_format *vaf)
> +{
> +	const char *hwe_prefix = log_hwe_prefix(cper_sev, sigid);
> +	const char *sev_prefix = log_sev_prefix(cper_sev);
> +
> +	/* TODO: add component/location details */
> +
> +	if (IS_ERR(data))
> +		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%pe) %s%pV",
> +				 sigid, sev_prefix, data, hwe_prefix, vaf);
> +	else if (data && len)
> +		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%*phN) %s%pV",
> +				 sigid, sev_prefix, (int)len, data, hwe_prefix, vaf);
> +	else
> +		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s%s%pV",
> +				 sigid, sev_prefix, hwe_prefix, vaf);
> +}
> +
> +/**
> + * xe_log_emit() - Emit a structured SIGID log entry
> + * @pdev: the &pci_dev device
> + * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE, ...)
> + * @sigid: signature identifier, see &enum xe_sigid
> + * @component: component identifer
> + * @location: location details of the @component
> + * @data: pointer to the additional details, or ERR_PTR, or NULL if not applicable
> + * @len: length of the @data in bytes, or 0 if not applicable
> + * @fmt: printf-style format string
> + * @...: format arguments
> + *
> + * Emits a dmesg line that includes a single stable, machine-matchable token
> + * ``SIGID=<n>`` followed by the optional severity token (like ``FATAL``) and,
> + * when @data pointer is set, either the error printed with %pe or a packed hex
> + * dump of the @data binary blob. The dmesg line will also include printf-style
> + * text message.
> + *
> + * Note that the full dmesg line, with the free text message, is only a debugging
> + * aid, not an interface! Only the ``SIGID=<n>`` token is stable there.
> + * The durable machine record is the CPER carrying the same SIGID.
> + *
> + * Note: generation of the CPER record is a planned follow-up.
> + *
> + * Examples::
> + *
> + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=104 FATAL (-EPROTO) Invalid GuC reply
> + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=106 (-ETIMEDOUT) Engine 'rcs0' hung
> + *   <6> xe 0000:03:00.0: [drm] *ERROR* SIGID=103 In survivability mode
> + */
> +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
> +		 u32 component, u32 location, const void *data, size_t len,
> +		 const char *fmt, ...)
> +{
> +	struct va_format vaf;
> +	va_list args;
> +
> +	va_start(args, fmt);
> +	vaf.fmt = fmt;
> +	vaf.va = &args;
> +
> +	log_emit_dmesg(pdev, cper_sev, sigid, component, location, data, len, &vaf);
> +	log_emit_cper(pdev, cper_sev, sigid, component, location, data, len, &vaf);
> +
> +	va_end(args);
> +}
> diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
> new file mode 100644
> index 000000000000..d475e816ee0b
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/xe_log.h
> @@ -0,0 +1,20 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +#ifndef _XE_LOG_H_
> +#define _XE_LOG_H_
> +
> +#include <linux/cper.h>
> +
> +#include "abi/xe_sigid_abi.h"
> +
> +struct pci_dev;
> +
> +__printf(8, 9)
> +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
> +		 u32 component, u32 location, const void *data, size_t len,
> +		 const char *fmt, ...);
> +
> +#endif

Re: [PATCH v3 03/23] drm/xe/log: Introduce structured component/location identifiers

[Michal Wajdeczko]

On 8/3/2026 10:00 AM, Mallesh, Koujalagi wrote:
> 
> On 30-07-2026 08:50 pm, Michal Wajdeczko wrote:
>> Introduce structured identifiers for each component type that
>> could emit a SIGID log entry and for their locations. We plan
>> to store those IDs in the CPER records for better filtering.
>> Define also structured identifiers for the supported locations.
>>
>> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
>> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
>> Reviewed-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
>> ---
>> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
>> Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
>> Cc: Raag Jadav <raag.jadav@intel.com>
>> Cc: Riana Tauro <riana.tauro@intel.com>
>> ---
>> v2: fix typo, define reserved ids (Michal)
>> v3: fix kernel-doc to match code (Sashiko)
>> ---
>>   drivers/gpu/drm/xe/abi/xe_log_abi.h | 186 ++++++++++++++++++++++++++++
>>   1 file changed, 186 insertions(+)
>>   create mode 100644 drivers/gpu/drm/xe/abi/xe_log_abi.h
>>
>> diff --git a/drivers/gpu/drm/xe/abi/xe_log_abi.h b/drivers/gpu/drm/xe/abi/xe_log_abi.h
>> new file mode 100644
>> index 000000000000..4861a5b58c10
>> --- /dev/null
>> +++ b/drivers/gpu/drm/xe/abi/xe_log_abi.h
>> @@ -0,0 +1,186 @@
>> +/* SPDX-License-Identifier: MIT */
>> +/*
>> + * Copyright © 2026 Intel Corporation
>> + */
>> +
>> +#ifndef _ABI_XE_LOG_ABI_H_
>> +#define _ABI_XE_LOG_ABI_H_
>> +
>> +#include <linux/bits.h>
>> +#include <linux/bitfield.h>
>> +
>> +#include "abi/xe_sigid_abi.h"
>> +
>> +/**
>> + * enum xe_log_component_bits - bits for components structure definitions
>> + *
>> + * Component identifiers are structured based on::
>> + *
>> + *     COMPONENT = CLASS(8b).TYPE(8b)
>> + *
> 
> Are 8b sufficient for CLASS and TYPE?  In future we need to increase that.

we can make it 16b and 16b (as component parameter is already u32)

but ...

are you sure that we will define anytime soon more than 255 component types per class, or have more than 255 classes?

> 
>> + * and the structure looks like this::
>> + *
>> + *     ├── SYSTEM(0)
>> + *     │   └── ...
>> + *     ├── DRIVER(1)
>> + *     │   └── ...
>> + *     ├── FEATURE(2)
>> + *     │   └── ...
>> + *     ├── FIRMWARE(4)
>> + *     │   └── ...
>> + *     └── HARDWARE(8)
>> + *         └── ...
>> + *
>> + * Examples::
>> + *
>> + *     COMPONENT(0.type) = SYSTEM.type = system component
>> + *     COMPONENT(1.type) = DRIVER.type = driver core component
>> + *     COMPONENT(3.type) = DRIVER_FEATURE.type = driver feature
>> + *     COMPONENT(5.type) = DRIVER_FIRMWARE.type = firmware driver component
>> + *     COMPONENT(9.type) = DRIVER_HARDWARE.type = hardware driver component
>> + *
>> + */
>> +enum xe_log_component_bits {
>> +    /* private: */
>> +    XE_LOG_COMPONENT_CLASS_MASK = GENMASK_U16(7, 0),
>> +    XE_LOG_COMPONENT_TYPE_MASK = GENMASK_U16(15, 8),
>> +    /* private: component classes */
>> +    XE_LOG_COMPONENT_CLASS_SYSTEM = 0u,
>> +    XE_LOG_COMPONENT_CLASS_DRIVER = 1u,
>> +    XE_LOG_COMPONENT_CLASS_FEATURE = 2u,
>> +    XE_LOG_COMPONENT_CLASS_FIRMWARE = 4u,
>> +    XE_LOG_COMPONENT_CLASS_HARDWARE = 8u,
>> +    XE_LOG_COMPONENT_CLASS_DRIVER_FEATURE = XE_LOG_COMPONENT_CLASS_DRIVER |
>> +                        XE_LOG_COMPONENT_CLASS_FEATURE,
>> +    XE_LOG_COMPONENT_CLASS_DRIVER_FIRMWARE = XE_LOG_COMPONENT_CLASS_DRIVER |
>> +                         XE_LOG_COMPONENT_CLASS_FIRMWARE,
>> +    XE_LOG_COMPONENT_CLASS_DRIVER_HARDWARE = XE_LOG_COMPONENT_CLASS_DRIVER |
>> +                         XE_LOG_COMPONENT_CLASS_HARDWARE,
>> +    /* private: reserved identifiers */
>> +    XE_LOG_COMPONENT_NONE = 0u,
>> +};
>> +
>> +#define MAKE_XE_LOG_COMPONENT(_CLASS, type) \
>> +    (FIELD_PREP_CONST(XE_LOG_COMPONENT_CLASS_MASK, \
>> +              XE_LOG_COMPONENT_CLASS_##_CLASS) | \
>> +     FIELD_PREP_CONST(XE_LOG_COMPONENT_TYPE_MASK, (type)))
>> +
>> +/**
>> + * enum xe_log_location_bits - bits for location structure definitions
>> + *
>> + * Location identifiers are structured based on::
>> + *
>> + *     LOCATION = TYPE(8b).ID(8b)
>> + *
> 
> Are 8b sufficient for Type and ID?

we can make it 16b & 16b (as location parameter is already u32)

but ...

do you have any new location candidates in mind that would require more than 255 IDs or that we would need to define more than 255 location types?

currently we have:
	TILE	max ID = XE_MAX_TILES_PER_DEVICE(2) = 2
	GT	max ID = XE_MAX_GT_PER_TILE(2) * XE_MAX_TILES_PER_DEVICE(2) = 4

even if we add:
	VF	max ID = 63

still everything < 255

unless we would like to use someday:
	PASID	-> 20b 

but then 16b/16b wont work either

I can change location bits to TYPE(8b) and ID(24b) if you think it is required now

> 
> Everything else looks good.
> 
> Reviewed-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> 
>> + * and the structure looks like this::
>> + *
>> + *     ├── DEVICE(0)
>> + *     │   └── MBZ(0)
>> + *     ├── TILE(1)
>> + *     │   ├── Tile0(0)
>> + *     │   ├── ...
>> + *     │   └── TileN(n)
>> + *     ├── GT(1)
>> + *     │   ├── GT0(0)
>> + *     │   ├── ...
>> + *     │   └── GTn(n)
>> + *     └── ...
>> + *
>> + * Examples::
>> + *
>> + *     LOCATION(0.0) = NONE
>> + *     LOCATION(1.0) = DEVICE.0 = "Device"
>> + *     LOCATION(2.1) = TILE.1 = "Tile1"
>> + *     LOCATION(3.2) = GT.2 = "GT2"
>> + *
>> + */
>> +enum xe_log_location_bits {
>> +    /* private: */
>> +    XE_LOG_LOCATION_TYPE_MASK = GENMASK_U16(7, 0),
>> +    XE_LOG_LOCATION_ID_MASK = GENMASK_U16(15, 8),
>> +    /* private: location types */
>> +    XE_LOG_LOCATION_TYPE_DEVICE = 1u,
>> +    XE_LOG_LOCATION_TYPE_TILE = 2u,
>> +    XE_LOG_LOCATION_TYPE_GT = 3u,
>> +    /* private: reserved identifiers */
>> +    XE_LOG_LOCATION_NONE = 0u,
>> +};
>> +
>> +#define PREP_XE_LOG_LOCATION(type, id) \
>> +    (FIELD_PREP(XE_LOG_LOCATION_TYPE_MASK, (type)) | \
>> +     FIELD_PREP(XE_LOG_LOCATION_ID_MASK, (id)))
>> +
>> +#define MAKE_XE_LOG_LOCATION(_TYPE, id) \
>> +    PREP_XE_LOG_LOCATION(XE_LOG_LOCATION_TYPE_##_TYPE, (id))
>> +
>> +/**
>> + * DEFINE_XE_LOG_COMPONENTS() - Define log components.
>> + * @define: name of the inner macro to expand.
>> + *
>> + * Use this super macro to define custom code for the log components.
>> + * The following parameters are available for each component::
>> + *
>> + *     define(CLASS, ID, TAG, SIGID, NAME)
>> + *
>> + * where:
>> + *
>> + *     @ID is the unique component identifier within CLASS.SUBCLASS.CATEGORY
>> + *     @TAG is unique component tag (across all components)
>> + *     @SIGID is the default xe_sigid for the component (without the XE_SIGID_ prefix)
>> + */
>> +#define DEFINE_XE_LOG_COMPONENTS(define) \
>> +    /* */                                    \
>> +    define(SYSTEM, 1, PCI, SW, "Linux PCI Subsystem")            \
>> +    define(SYSTEM, 2, DRM, SW, "DRM")                    \
>> +    /* */                                    \
>> +    define(DRIVER, 1, XE, SW, "Xe Driver")                    \
>> +    define(DRIVER, 2, PROBE, PROBE, "Driver Initialization")        \
>> +    define(DRIVER, 3, WEDGED, WEDGED, "Device Malfunction")            \
>> +    define(DRIVER, 4, RTP, SW, "Register Table Processing")            \
>> +    define(DRIVER, 5, WA, SW, "Workarounds")                \
>> +    define(DRIVER, 6, PAGEFAULT, MEM_FAULT, "Page Fault")            \
>> +    /* */                                    \
>> +    define(DRIVER_HARDWARE, 1, REGS, IO_BUS, "Registers")            \
>> +    define(DRIVER_HARDWARE, 2, GGTT, IO_BUS, "Global GTT")            \
>> +    define(DRIVER_HARDWARE, 3, GT, GT_TDR, "Graphics Technology")        \
>> +    define(DRIVER_HARDWARE, 4, LMTT, IO_BUS, "LMEM Translation Table")    \
>> +    define(DRIVER_HARDWARE, 5, MEMIRQ, IO_BUS, "Memory Based IRQ")        \
>> +    /* */                                    \
>> +    define(DRIVER_FEATURE, 1, PF, SW, "SR-IOV Physical Function")        \
>> +    define(DRIVER_FEATURE, 2, VF, SW, "SR-IOV Virtual Function")        \
>> +    define(DRIVER_FEATURE, 3, SURVIVABILITY, SURVIVABILITY, "Survivability") \
>> +    define(DRIVER_FEATURE, 4, RAS, SW, "Reliability, Accessibility, Serviceability") \
>> +    /* */                                    \
>> +    define(DRIVER_FIRMWARE, 1, GUC, RUNTIME_FW, "GuC")            \
>> +    define(DRIVER_FIRMWARE, 2, HUC, RUNTIME_FW, "HuC")            \
>> +    define(DRIVER_FIRMWARE, 3, GSC, RUNTIME_FW, "GSC")            \
>> +    define(DRIVER_FIRMWARE, 16, PCODE, DEVICE_FW, "PCode")            \
>> +    define(DRIVER_FIRMWARE, 17, SYSCTRL, DEVICE_FW, "System Controller")    \
>> +    /* eod */
>> +
>> +/**
>> + * enum xe_log_component_tags - TAGs of all supported components
>> + */
>> +enum xe_log_component_tags {
>> +    /* private: */
>> +#define MAKE_XE_LOG_COMPONENT_ENUM(_CLASS, _ID, _TAG, _SIG, _NAME) \
>> +    XE_LOG_COMPONENT_##_TAG = MAKE_XE_LOG_COMPONENT(_CLASS, (_ID)), \
>> +    XE_LOG_COMPONENT_##_CLASS##_##_ID = XE_LOG_COMPONENT_##_TAG, \
>> +    /* eod */
>> +    DEFINE_XE_LOG_COMPONENTS(MAKE_XE_LOG_COMPONENT_ENUM)
>> +#undef MAKE_XE_LOG_COMPONENT_ENUM
>> +};
>> +
>> +/**
>> + * enum xe_log_component_sigids - SIGIDs of all supported components
>> + */
>> +enum xe_log_component_sigids {
>> +    /* private: */
>> +#define MAKE_XE_LOG_COMPONENT_SIGID(_CLASS, _ID, _TAG, _SIG, _NAME) \
>> +    XE_LOG_COMPONENT_##_TAG##_SIGID = XE_SIGID_##_SIG, \
>> +    /* eod */
>> +    DEFINE_XE_LOG_COMPONENTS(MAKE_XE_LOG_COMPONENT_SIGID)
>> +#undef MAKE_XE_LOG_COMPONENT_SIGID
>> +};
>> +
>> +#endif

Re: [PATCH v3 10/23] drm/xe/log: Add hardware error signatures

[Michal Wajdeczko]

On 7/31/2026 1:41 PM, Mallesh, Koujalagi wrote:
> 
> On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
>> Extend our error signatures definitions xe_sigid to cover also
>> hardware-originated errors and make them distinguishable from
>> initially defined software-initiated errors.
>>
>> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
>> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
>> Cc: Yoni Levitt <yoni.levitt@intel.com>
>> ---
>> v2: update comment (Sashiko)
>> ---
>>   drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 16 ++++++++++++++--
>>   1 file changed, 14 insertions(+), 2 deletions(-)
>>
>> diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>> index 99717fdf74a6..69cce4b45635 100644
>> --- a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>> +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>> @@ -159,14 +159,19 @@
>>    * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery (reset). [RETRY]
>>    * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault. [COLLECT]
>>    * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault. [RECOVER]
>> + * @XE_SIGID_HW: Generic hardware failure.
>> + * @XE_SIGID_PCIE: PCIe interface errors.
>> + * @XE_SIGID_DEVICE_MEMORY: Device memory errors
> Add . @ end
>> + * @XE_SIGID_CORE_COMPUTE: Compute/shader core errors.
>> + * @XE_SIGID_FABRIC: Fabric errors.
>> + * @XE_SIGID_SOC_INTERNAL: SoC-internal errors.
>>    *
>>    * The situations the driver detects and reports in software. Values are
>>    * numbered sequentially, are only ever appended, and are never renumbered or
>>    * reused. The tag in brackets is the default resolution bucket (see the `Xe
>>    * Error Signatures (SIGID)`_ section).
>>    *
>> - * Firmware- and hardware-originated signatures are not listed here; they are
>> - * logged as reported by those layers.
>> + * Firmware- and hardware-originated signatures are numbered separately.
>>    */
>>   enum xe_sigid {
>>       XE_SIGID_SW            = INTEL_SIGID_GPU_XE_SOFTWARE_START,
>> @@ -178,6 +183,13 @@ enum xe_sigid {
>>       XE_SIGID_GT_TDR            = INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
>>       XE_SIGID_MEM_FAULT        = INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
>>       XE_SIGID_IO_BUS            = INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
>> +
>> +    XE_SIGID_HW            = INTEL_SIGID_GPU_XE_HARDWARE_START,
>> +    XE_SIGID_PCIE            = INTEL_SIGID_GPU_XE_HARDWARE_START + 1,
>> +    XE_SIGID_DEVICE_MEMORY        = INTEL_SIGID_GPU_XE_HARDWARE_START + 2,
>> +    XE_SIGID_CORE_COMPUTE        = INTEL_SIGID_GPU_XE_HARDWARE_START + 3,
>> +    XE_SIGID_FABRIC            = INTEL_SIGID_GPU_XE_HARDWARE_START + 4,
>> +    XE_SIGID_SOC_INTERNAL        = INTEL_SIGID_GPU_XE_HARDWARE_START + 5,
> 
> Since we've resolution bucket for SW sigid so do we need resolution bucket for HW sigid as well? If so how are we going to put HW sigid to resolution bucket?
there was discussion about this already [1]

and I guess we can add [COLLECT] here as an overall recommendation for all HW SIGIDs,
as likely all such errors will sooner or later be reported as separate SW incidents with its own resolutions
and official documentation will have more detailed recommendations (out of our scope here)

[1] https://patchwork.freedesktop.org/patch/742246/?series=171022&rev=1#comment_1368419

> 
> Thanks,
> 
> -/Mallesh
> 
>>   };
>>     #endif

Re: ✗ Xe.CI.BAT: failure for drm/xe: Add structured SIGID error logging infrastructure (rev3)

[Michal Wajdeczko]

On 7/30/2026 6:17 PM, Patchwork wrote:
> *Patch Details*
> *Series:*	drm/xe: Add structured SIGID error logging infrastructure (rev3)
> *URL:*	https://patchwork.freedesktop.org/series/171022/ <https://patchwork.freedesktop.org/series/171022/>
> *State:*	failure
> *Details:*	https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/index.html <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/index.html>
> 
> 
>   CI Bug Log - changes from xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd_BAT -> xe-pw-171022v3_BAT
> 
> 
>     Summary
> 
> *FAILURE*
> 
> Serious unknown changes coming with xe-pw-171022v3_BAT absolutely need to be
> verified manually.
> 
> If you think the reported changes have nothing to do with the changes
> introduced in xe-pw-171022v3_BAT, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
> to document this new failure mode, which will reduce false positives in CI.
> 
> 
>     Participating hosts (12 -> 12)
> 
> No changes in participating hosts
> 
> 
>     Possible new issues
> 
> Here are the unknown changes that may have been introduced in xe-pw-171022v3_BAT:
> 
> 
>       IGT changes
> 
> 
>         Possible regressions
> 
>   *
> 
>     igt@xe_exec_fault_mode@invalid-va:
> 
>       o bat-bmg-1: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-bmg-1/igt@xe_exec_fault_mode@invalid-va.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-bmg-1/igt@xe_exec_fault_mode@invalid-va.html> +1 other test dmesg-warn
>       o bat-lnl-2: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-lnl-2/igt@xe_exec_fault_mode@invalid-va.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-lnl-2/igt@xe_exec_fault_mode@invalid-va.html> +1 other test dmesg-warn
>       o bat-wcl-1: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-wcl-1/igt@xe_exec_fault_mode@invalid-va.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-wcl-1/igt@xe_exec_fault_mode@invalid-va.html> +1 other test dmesg-warn
>       o bat-ptl-1: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-ptl-1/igt@xe_exec_fault_mode@invalid-va.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-ptl-1/igt@xe_exec_fault_mode@invalid-va.html> +1 other test dmesg-warn
>       o bat-ptl-vm: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-ptl-vm/igt@xe_exec_fault_mode@invalid-va.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-ptl-vm/igt@xe_exec_fault_mode@invalid-va.html> +1 other test dmesg-warn
>       o bat-lnl-1: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-lnl-1/igt@xe_exec_fault_mode@invalid-va.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-lnl-1/igt@xe_exec_fault_mode@invalid-va.html> +1 other test dmesg-warn

a kind of expected new error signature with just introduced SIGID error:

<6> [153.466714] xe 0000:03:00.0: [drm] Tile0: GT0: 
	ASID: 538
	Faulted Address: 0x0000fffffffff000
	FaultType: 0
	AccessType: 1
	FaultLevel: 3
	EngineClass: 0 rcs
	EngineInstance: 0
<3> [153.466720] xe 0000:03:00.0: [drm] *ERROR* SIGID=107 (-EINVAL) Tile0: GT0: PAGEFAULT: Fault response: Unsuccessful
<6> [153.477174] xe 0000:03:00.0: [drm] Tile0: GT0: Engine memory CAT error [18]: class=rcs, logical_mask: 0x1, guc_id=2

previously all this was reported as info level:

<6> [157.848707] xe 0000:03:00.0: [drm] Tile0: GT0: 
	ASID: 538
	Faulted Address: 0x0000fffffffff000
	FaultType: 0
	AccessType: 1
	FaultLevel: 3
	EngineClass: 0 rcs
	EngineInstance: 0
<6> [157.848713] xe 0000:03:00.0: [drm] Tile0: GT0: Fault response: Unsuccessful -EINVAL
<6> [157.848773] xe 0000:03:00.0: [drm] Tile0: GT0: Engine memory CAT error [18]: class=rcs, logical_mask: 0x1, guc_id=2

>   *
> 
>     igt@xe_exec_system_allocator@fault:
> 
>       o bat-wcl-2: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-wcl-2/igt@xe_exec_system_allocator@fault.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-wcl-2/igt@xe_exec_system_allocator@fault.html> +1 other test dmesg-warn
>       o bat-bmg-vm: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-bmg-vm/igt@xe_exec_system_allocator@fault.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-bmg-vm/igt@xe_exec_system_allocator@fault.html> +1 other test dmesg-warn
>       o bat-ptl-2: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/bat-ptl-2/igt@xe_exec_system_allocator@fault.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/bat-ptl-2/igt@xe_exec_system_allocator@fault.html> +1 other test dmesg-warn

ditto


> 
> 
>     Build changes
> 
>   * Linux: xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd -> xe-pw-171022v3
> 
> IGT_9034: be1d1af352dbd4ca4557202a8ed0d6d60f95e0bf @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
> xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd: 5e24f68d311764bf343f9def49b752b509dfd5fd
> xe-pw-171022v3: 171022v3
> 

Re: ✗ Xe.CI.FULL: failure for drm/xe: Add structured SIGID error logging infrastructure (rev3)

[Michal Wajdeczko]

On 7/30/2026 8:31 PM, Patchwork wrote:
> *Patch Details*
> *Series:*	drm/xe: Add structured SIGID error logging infrastructure (rev3)
> *URL:*	https://patchwork.freedesktop.org/series/171022/ <https://patchwork.freedesktop.org/series/171022/>
> *State:*	failure
> *Details:*	https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/index.html <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/index.html>
> 
> 
>   CI Bug Log - changes from xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd_FULL -> xe-pw-171022v3_FULL
> 
> 
>     Summary
> 
> *FAILURE*
> 
> Serious unknown changes coming with xe-pw-171022v3_FULL absolutely need to be
> verified manually.
> 
> If you think the reported changes have nothing to do with the changes
> introduced in xe-pw-171022v3_FULL, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
> to document this new failure mode, which will reduce false positives in CI.
> 
> 
>     Participating hosts (2 -> 2)
> 
> No changes in participating hosts
> 
> 
>     Possible new issues
> 
> Here are the unknown changes that may have been introduced in xe-pw-171022v3_FULL:
> 
> 
>       IGT changes
> 
> 
>         Possible regressions
> 
>   *
> 
>     igt@xe_exec_system_allocator@fault:
> 
>       o shard-bmg: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-1/igt@xe_exec_system_allocator@fault.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-9/igt@xe_exec_system_allocator@fault.html> +6 other tests dmesg-warn

expected:

<3> [111.971125] xe 0000:03:00.0: [drm] *ERROR* SIGID=107 (-ENOENT) Tile0: GT0: PAGEFAULT: Fault response: Unsuccessful

>   *
> 
>     igt@xe_waitfence@exec_queue-reset-wait:
> 
>       o shard-lnl: PASS <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-lnl-7/igt@xe_waitfence@exec_queue-reset-wait.html> -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-lnl-5/igt@xe_waitfence@exec_queue-reset-wait.html> +9 other tests dmesg-warn

expected:

<3> [363.718950] xe 0000:00:02.0: [drm] *ERROR* SIGID=107 (-EINVAL) Tile0: GT0: PAGEFAULT: Fault response: Unsuccessful


> 
> 
>         Warnings
> 
>   *
> 
>     igt@xe_exec_fault_mode@invalid-va:
> 
>       o shard-bmg: SKIP <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-7/igt@xe_exec_fault_mode@invalid-va.html> (Intel XE#8714 <https://gitlab.freedesktop.org/drm/xe/kernel/issues/8714>) -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-6/igt@xe_exec_fault_mode@invalid-va.html> +2 other tests dmesg-warn

expected:

<3> [410.514511] xe 0000:03:00.0: [drm] *ERROR* SIGID=107 (-EINVAL) Tile0: GT0: PAGEFAULT: Fault response: Unsuccessful


>   *
> 
>     igt@xe_survivability@runtime-survivability:
> 
>       o shard-bmg: DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-3/igt@xe_survivability@runtime-survivability.html> (Intel XE#6627 <https://gitlab.freedesktop.org/drm/xe/kernel/issues/6627> / Intel XE#7419 <https://gitlab.freedesktop.org/drm/xe/kernel/issues/7419>) -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-1/igt@xe_survivability@runtime-survivability.html>

expected:

<3> [206.567349] xe 0000:03:00.0: [drm] *ERROR* SIGID=103 FATAL SURVIVABILITY: Runtime Mode enabled!
<3> [206.576361] xe 0000:03:00.0: [drm] *ERROR* SIGID=102 FATAL (-EIO) WEDGED: Device declared wedged!
<3> [206.585411] xe 0000:03:00.0: [drm] *ERROR* IOCTLs and executions are now blocked!
For recovery procedure, refer to https://docs.kernel.org/gpu/drm-uapi.html#device-wedging
Please file a _new_ bug report at https://gitlab.freedesktop.org/drm/xe/kernel/issues/new
<3> [206.595229] xe 0000:03:00.0: [drm] *ERROR* SIGID=106 FATAL (-ENOTRECOVERABLE) Tile0: GT0: GT: reset failed
<3> [206.632188] xe 0000:03:00.0: [drm] *ERROR* SIGID=103 FATAL SURVIVABILITY: Firmware flash required!

>   *
> 
>     igt@xe_wedged@wedged-at-any-timeout:
> 
>       o shard-bmg: DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-5508-5e24f68d311764bf343f9def49b752b509dfd5fd/shard-bmg-2/igt@xe_wedged@wedged-at-any-timeout.html> (Intel XE#5545 <https://gitlab.freedesktop.org/drm/xe/kernel/issues/5545>) -> DMESG-WARN <https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-171022v3/shard-bmg-2/igt@xe_wedged@wedged-at-any-timeout.html>

expected:

<3> [612.887157] xe 0000:03:00.0: [drm] *ERROR* SIGID=107 (-EINVAL) Tile0: GT0: PAGEFAULT: Fault response: Unsuccessful
<3> [612.897972] xe 0000:03:00.0: [drm] *ERROR* SIGID=102 FATAL (-EIO) WEDGED: Device declared wedged!
<3> [612.906894] xe 0000:03:00.0: [drm] *ERROR* IOCTLs and executions are now blocked!
For recovery procedure, refer to https://docs.kernel.org/gpu/drm-uapi.html#device-wedging
Please file a _new_ bug report at https://gitlab.freedesktop.org/drm/xe/kernel/issues/new

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Rodrigo Vivi]

On Tue, Aug 04, 2026 at 08:30:47PM +0530, Tauro, Riana wrote:
> Hi Mallesh/Michal
> 
> On 30-07-2026 20:50, Michal Wajdeczko wrote:
> > From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > 
> > Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
> > strings that have no stable shape. That is readable for a human, but it
> > gives fleet tooling nothing durable to match on: the wording changes
> > between releases, lines can be rate-limited or dropped under an error
> > storm, and there is no consistent way to ask "which recognised fault
> > just happened?".
> > 
> > Introduce a signature identifier (SIGID): a small, stable integer that
> > names one recognised Xe fault situation and serves as the primary handle
> > for triage. A SIGID maps, through published end-user documentation, to a
> > description and a recommended action; the driver only has to emit the
> > right SIGID next to the usual human-readable text.
> > 
> > Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > Assisted-by: Copilot:Opus-4.8
> > Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> > Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > ---
> > Cc: Yoni Levitt <yoni.levitt@intel.com>
> > Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> > Cc: Raag Jadav <raag.jadav@intel.com>
> > Cc: Riana Tauro <riana.tauro@intel.com>
> > ---
> > v2: CORRECTED is still an error (Michal)
> >      prepare to decorate dmesg with comp/loc (Michal)
> > ---
> >   Documentation/gpu/xe/index.rst        |   1 +
> >   Documentation/gpu/xe/xe_sigid.rst     |  14 ++
> >   drivers/gpu/drm/xe/Makefile           |   1 +
> >   drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183 ++++++++++++++++++++++++++
> >   drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
> >   drivers/gpu/drm/xe/xe_log.h           |  20 +++
> >   6 files changed, 354 insertions(+)
> >   create mode 100644 Documentation/gpu/xe/xe_sigid.rst
> >   create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> >   create mode 100644 drivers/gpu/drm/xe/xe_log.c
> >   create mode 100644 drivers/gpu/drm/xe/xe_log.h
> > 
> > diff --git a/Documentation/gpu/xe/index.rst b/Documentation/gpu/xe/index.rst
> > index 665c0e93601c..0247a255f7e6 100644
> > --- a/Documentation/gpu/xe/index.rst
> > +++ b/Documentation/gpu/xe/index.rst
> > @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for drm/xe is provided by
> >      xe-drm-usage-stats.rst
> >      xe_configfs
> >      xe_gt_stats
> > +   xe_sigid
> > diff --git a/Documentation/gpu/xe/xe_sigid.rst b/Documentation/gpu/xe/xe_sigid.rst
> > new file mode 100644
> > index 000000000000..45d84a62f185
> > --- /dev/null
> > +++ b/Documentation/gpu/xe/xe_sigid.rst
> > @@ -0,0 +1,14 @@
> > +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> > +
> > +========
> > +Xe SIGID
> > +========
> > +
> > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > +   :doc: Xe Error Signatures (SIGID)
> > +
> > +Signature Identifiers
> > +=====================
> > +
> > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > +   :internal:
> > diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
> > index 67ada1d6c2fb..7ac3954737f9 100644
> > --- a/drivers/gpu/drm/xe/Makefile
> > +++ b/drivers/gpu/drm/xe/Makefile
> > @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
> >   	xe_hw_fence.o \
> >   	xe_irq.o \
> >   	xe_late_bind_fw.o \
> > +	xe_log.o \
> >   	xe_lrc.o \
> >   	xe_mem_pool.o \
> >   	xe_migrate.o \
> > diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > new file mode 100644
> > index 000000000000..99717fdf74a6
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > @@ -0,0 +1,183 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#ifndef _ABI_XE_SIGID_ABI_H_
> > +#define _ABI_XE_SIGID_ABI_H_
> > +
> > +/**
> > + * DOC: Xe Error Signatures (SIGID)
> > + *
> > + * What SIGID stands for
> > + * ---------------------
> > + *
> > + * SIGID is short for *Signature Identifier*. A SIGID is a small, stable integer
> > + * that names one *recognised Xe fault situation* -- nothing more. It is the
> > + * primary handle used for triage: a SIGID maps to a human description and a
> The SIG ID maps to a report site as mentioned in "How to pick a sigid" not a
> human description.

Indeed, perhaps with simple:
s/maps to a human description/maps to a report site/

we get some consistency?! 
> 
> > + * recommended first action. A coarse first-order action is documented in-tree
> > + * per SIGID (see "First-order action" below) so the id is actionable on its
> > + * own; published end-user documentation refines it with finer, cross-product
> > + * detail. The driver's only job is to emit the right SIGID next to the usual
> > + * human-readable text.
> > + *
> > + * Why this exists
> > + * ---------------
> > + *
> > + * Today the driver reports faults with ad-hoc ``drm_err()`` / ``xe_gt_err()``
> > + * strings that have no stable shape. That is fine for a human reading dmesg,
> > + * but it gives fleet tooling nothing durable to match on: the wording changes
> > + * between releases, lines can be rate-limited or dropped under an error storm,
> > + * and there is no consistent way to ask "which recognised fault just happened?"
> > + * A SIGID answers exactly that one question, identically across driver and
> > + * firmware versions, and (eventually) across other Intel devices in a node.
> > + *
> > + * What a SIGID is (and is not)
> > + * ----------------------------
> > + *
> > + * A SIGID names *which situation* is being reported. It deliberately does not
> This should also be consistent with "report site" instead of situation.

Agree.
s/situation/report site/

> > + * encode the detailed reason or the outcome. Those are carried alongside it::
> > + *
> > + *   SIGID    -> which recognised situation is being reported
> > + *   severity -> how serious this instance is (see below -- not fixed per SIGID)
> > + *   errno    -> the failing operation's error, shown with %pe
> > + *   message  -> free-form human-readable context
> > + *
> > + * Severity is independent of the SIGID. The same situation can be reported at
> > + * different severities depending on the instance and the recovery taken, so a
> > + * SIGID is never tied to one severity; the reporting site chooses it by calling
> > + * the matching xe_log_*() helper (see xe_log.h).
> > + *
> 
> It'd be more intuitive for readers if section "When to use SIGID logging" is
> moved before how to pick one.

It makes sense to me.

> > + * How to pick a SIGID (the uniqueness rule)
> > + * -----------------------------------------
> > + *
> > + * Pick per *report site*, not per incident. Each site emits the single most
> > + * specific recognised situation *for that site* -- so the question is never
> > + * "classify this whole failure", it is "what does this site detect?", which has
> > + * one answer. A single underlying failure therefore legitimately produces a
> > + * *chain* of reports from different layers, each with its own SIGID -- e.g. a
> > + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by the firmware
> > + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path, and an
> > + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain lets triage
> > + * follow a fault from origin to final effect; it is not a duplicate.
> > + *
> > + * If a site does not match any defined situation, keep using the ordinary
> > + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a SIGID: a wrong
> > + * or over-broad classification is harder to retire than a missing one. When a
> > + * new situation is genuinely worth triaging, add it to the list below.
> > + *
> > + * Scope: software-emitted signatures only
> > + * ---------------------------------------
> > + *
> > + * This header enumerates only the situations that the *driver itself* detects
> > + * and reports from software: probe abort, wedged, survivability, driver-
> > + * detected firmware failures, engine TDR, memory faults and IO/bus faults.
> > + * These are the only values the driver assigns.
> > + *
> > + * Signatures that *originate* in firmware or hardware are a different thing:
> > + * they are produced and identified by the firmware or the hardware itself
> > + * (e.g. via their own records or error counters), and the driver merely logs
> > + * them as they are given to us. They are deliberately *not* enumerated here --
> > + * minting a driver-side id for a firmware/hardware-reported error would only
> > + * duplicate an identifier the reporting layer already owns. The two
> > + * driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
> > + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the driver*
> > + * observed a firmware problem, not a signature reported by the firmware.
> > + *
> > + * Numbering
> > + * ---------
> 
> This section also needs to be on the top. It can be missed if it is at the
> bottom of the document.

Also agree.

> 
> > + *
> > + * SIGIDs are a single flat list numbered sequentially within the assigned range,
> > + * in the order the situations were introduced. Values are stable: once assigned
> > + * they are only ever appended, never renumbered or reused.
> > + *
> > + * A retired situation is deprecated in place, never re-purposed.
> > + *
> > + * First-order action (resolution buckets)
> > + * ---------------------------------------
> > + *
> > + * So that a SIGID is actionable on its own, each one is tagged with a coarse
> > + * *resolution bucket*: the first thing an operator should do on seeing it. The
> > + * bucket is a stable, driver-owned hint; external documentation may refine it,
> > + * but the in-tree value always stands on its own. Every new SIGID must pick a
> > + * bucket, which forces the question "what should someone do about this?" to be
> > + * answered up front. The buckets are::
> > + *
> > + *   COLLECT  -- capture logs and open a bug report
> > + *   RETRY    -- transient or already recovered; watch for recurrence
> > + *   UPDATE   -- a firmware update / flash is required
> > + *   RECOVER  -- an explicit recovery step is needed (rebind, bus reset)
> 
> 
> Do we actually need resolution buckets defined here? RECOVER or UPDATE seem
> a bit vague since states like
>  WEDGED/SURVIVABILITY have different ways to recover depending on context.
> Wouldn't detailed resolution steps in another
> document be better than in logs?

Fair enough. I would prefer we have some recommendation for a consistent
end to end story without depending on external docs and all.
However I do agree that the vagueness in some cases here can defeat the
purpose and mostly the conflict with the wedge.

Aravind was already complaining about these buckets. So, perhaps let's just
remove. But also for consistency we need to change the rest of the text above
and below:

- drop "maps to … a recommended first action … 
- Delete the whole First-order action (resolution buckets) sectio
- Strip the [TAG] from all nine enum entries.
- Drop the dmesg note "the bucket … is not printed on the dmesg line.

Michal, what are your thoughts?

Thanks,
Rodrigo.

> 
> > + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
> > + *
> > + * The bucket is documentation only -- it is recorded per SIGID in the enum
> > + * kernel-doc below and is not printed on the (deliberately lean) dmesg line.
> > + *
> > + * When to use SIGID logging
> > + * -------------------------
> > + *
> > + * The xe_log_*() helpers are for these recognised fault situations only --
> > + * important, operator-relevant faults and events. They are not a replacement
> > + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off diagnostics;
> > + * using them for ordinary logging would dilute the fault stream. Not every
> > + * ``xe_err()`` needs to become a SIGID report -- only those that correspond to
> > + * a published situation.
> > + *
> > + * dmesg vs. the machine record
> > + * ----------------------------
> > + *
> > + * The dmesg line stays close to a normal xe error message so it remains
> > + * readable for admins; the only stable, machine-matchable token on it is
> > + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI: the surrounding
> > + * text may change freely, and lines may be dropped. The durable record for
> > + * tooling is the CPER record carrying the same SIGID (generation is a planned
> > + * follow-up).
> > + */
> > +
> > +/*
> > + * Top level Intel Error Signature Identifiers.
> > + */
> > +#define INTEL_SIGID_INVALID			0
> > +#define INTEL_SIGID_GPU_START			100
> 
> why does the sigid start from 100?
> 
> > +#define INTEL_SIGID_GPU_END			999
> > +
> > +#define INTEL_SIGID_GPU_XE_START		100
> > +#define INTEL_SIGID_GPU_XE_END			299
> > +
> > +#define INTEL_SIGID_GPU_XE_SOFTWARE_START	100
> > +#define INTEL_SIGID_GPU_XE_SOFTWARE_END		199
> > +#define INTEL_SIGID_GPU_XE_HARDWARE_START	200
> > +#define INTEL_SIGID_GPU_XE_HARDWARE_END		299
> > +
> > +/**
> > + * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
> > + * @XE_SIGID_SW: Software component failure. [COLLECT]
> > + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
> > + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer usable. [RECOVER]
> > + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode. [UPDATE]
> > + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure, GuC/HuC/GSC. [RETRY]
> > + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure, PCODE/sysctrl. [RETRY]
> 
> Pcode or sysctrl errors cannot be retried. Pcode init failures cause
> survivability mode.
> RAS sysctrl errors require a secondary bus reset. We could have other
> firmwares in future with different
> recovery.
> That is why it would be better to drop resolution buckets in logs.
> 
> @aravind thoughts?
> 
> Thanks
> Riana
> 
> > + * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery (reset). [RETRY]
> > + * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault. [COLLECT]
> > + * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault. [RECOVER]
> > + *
> > + * The situations the driver detects and reports in software. Values are
> > + * numbered sequentially, are only ever appended, and are never renumbered or
> > + * reused. The tag in brackets is the default resolution bucket (see the `Xe
> > + * Error Signatures (SIGID)`_ section).
> > + *
> > + * Firmware- and hardware-originated signatures are not listed here; they are
> > + * logged as reported by those layers.
> > + */
> > +enum xe_sigid {
> > +	XE_SIGID_SW			= INTEL_SIGID_GPU_XE_SOFTWARE_START,
> > +	XE_SIGID_PROBE			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 1,
> > +	XE_SIGID_WEDGED			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 2,
> > +	XE_SIGID_SURVIVABILITY		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 3,
> > +	XE_SIGID_RUNTIME_FW		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 4,
> > +	XE_SIGID_DEVICE_FW		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 5,
> > +	XE_SIGID_GT_TDR			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
> > +	XE_SIGID_MEM_FAULT		= INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
> > +	XE_SIGID_IO_BUS			= INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
> > +};
> > +
> > +#endif
> > diff --git a/drivers/gpu/drm/xe/xe_log.c b/drivers/gpu/drm/xe/xe_log.c
> > new file mode 100644
> > index 000000000000..70a41bdf1a01
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_log.c
> > @@ -0,0 +1,135 @@
> > +// SPDX-License-Identifier: MIT
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#include "xe_log.h"
> > +#include "xe_printk.h"
> > +
> > +static void log_emit_cper(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
> > +			  u32 component, u32 location, const void *data, size_t len,
> > +			  struct va_format *vaf)
> > +{
> > +	/* TODO */
> > +}
> > +
> > +static bool is_hw_sigid(enum xe_sigid sigid)
> > +{
> > +	return (int)sigid >= INTEL_SIGID_GPU_XE_HARDWARE_START;
> > +}
> > +
> > +static bool is_sev_error(int cper_sev)
> > +{
> > +	return cper_sev != CPER_SEV_INFORMATIONAL;
> > +}
> > +
> > +static const char *log_hwe_prefix(int cper_sev, enum xe_sigid sigid)
> > +{
> > +	return is_sev_error(cper_sev) && is_hw_sigid(sigid) ? HW_ERR : "";
> > +}
> > +
> > +static const char *log_sev_prefix(int cper_sev)
> > +{
> > +	switch (cper_sev) {
> > +	case CPER_SEV_FATAL:
> > +		return "FATAL ";
> > +	case CPER_SEV_RECOVERABLE:
> > +		return "";
> > +	case CPER_SEV_CORRECTED:
> > +		return "CORRECTED ";
> > +	default:
> > +		return "";
> > +	}
> > +}
> > +
> > +#define __LOG_DRM_PRINTK_FMT(fmt, args...)	"[drm] " fmt, ##args
> > +#define __LOG_DRM_PRINTK_ERR_FMT(fmt, args...)	__LOG_DRM_PRINTK_FMT("*ERROR* " fmt, args)
> > +
> > +static void log_dmesg_vprintk(struct pci_dev *pdev, int cper_sev, struct va_format *vaf)
> > +{
> > +	if (cper_sev == CPER_SEV_INFORMATIONAL)
> > +		pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
> > +	else
> > +		pci_err(pdev, __LOG_DRM_PRINTK_ERR_FMT("%pV", vaf));
> > +}
> > +
> > +static void log_dmesg_printf(struct pci_dev *pdev, int cper_sev, const char *fmt, ...)
> > +{
> > +	struct va_format vaf;
> > +	va_list args;
> > +
> > +	va_start(args, fmt);
> > +	vaf.fmt = fmt;
> > +	vaf.va = &args;
> > +
> > +	log_dmesg_vprintk(pdev, cper_sev, &vaf);
> > +
> > +	va_end(args);
> > +}
> > +
> > +static void log_emit_dmesg(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
> > +			   u32 component, u32 location, const void *data, size_t len,
> > +			   struct va_format *vaf)
> > +{
> > +	const char *hwe_prefix = log_hwe_prefix(cper_sev, sigid);
> > +	const char *sev_prefix = log_sev_prefix(cper_sev);
> > +
> > +	/* TODO: add component/location details */
> > +
> > +	if (IS_ERR(data))
> > +		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%pe) %s%pV",
> > +				 sigid, sev_prefix, data, hwe_prefix, vaf);
> > +	else if (data && len)
> > +		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%*phN) %s%pV",
> > +				 sigid, sev_prefix, (int)len, data, hwe_prefix, vaf);
> > +	else
> > +		log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s%s%pV",
> > +				 sigid, sev_prefix, hwe_prefix, vaf);
> > +}
> > +
> > +/**
> > + * xe_log_emit() - Emit a structured SIGID log entry
> > + * @pdev: the &pci_dev device
> > + * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE, ...)
> > + * @sigid: signature identifier, see &enum xe_sigid
> > + * @component: component identifer
> > + * @location: location details of the @component
> > + * @data: pointer to the additional details, or ERR_PTR, or NULL if not applicable
> > + * @len: length of the @data in bytes, or 0 if not applicable
> > + * @fmt: printf-style format string
> > + * @...: format arguments
> > + *
> > + * Emits a dmesg line that includes a single stable, machine-matchable token
> > + * ``SIGID=<n>`` followed by the optional severity token (like ``FATAL``) and,
> > + * when @data pointer is set, either the error printed with %pe or a packed hex
> > + * dump of the @data binary blob. The dmesg line will also include printf-style
> > + * text message.
> > + *
> > + * Note that the full dmesg line, with the free text message, is only a debugging
> > + * aid, not an interface! Only the ``SIGID=<n>`` token is stable there.
> > + * The durable machine record is the CPER carrying the same SIGID.
> > + *
> > + * Note: generation of the CPER record is a planned follow-up.
> > + *
> > + * Examples::
> > + *
> > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=104 FATAL (-EPROTO) Invalid GuC reply
> > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=106 (-ETIMEDOUT) Engine 'rcs0' hung
> > + *   <6> xe 0000:03:00.0: [drm] *ERROR* SIGID=103 In survivability mode
> > + */
> > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
> > +		 u32 component, u32 location, const void *data, size_t len,
> > +		 const char *fmt, ...)
> > +{
> > +	struct va_format vaf;
> > +	va_list args;
> > +
> > +	va_start(args, fmt);
> > +	vaf.fmt = fmt;
> > +	vaf.va = &args;
> > +
> > +	log_emit_dmesg(pdev, cper_sev, sigid, component, location, data, len, &vaf);
> > +	log_emit_cper(pdev, cper_sev, sigid, component, location, data, len, &vaf);
> > +
> > +	va_end(args);
> > +}
> > diff --git a/drivers/gpu/drm/xe/xe_log.h b/drivers/gpu/drm/xe/xe_log.h
> > new file mode 100644
> > index 000000000000..d475e816ee0b
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_log.h
> > @@ -0,0 +1,20 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#ifndef _XE_LOG_H_
> > +#define _XE_LOG_H_
> > +
> > +#include <linux/cper.h>
> > +
> > +#include "abi/xe_sigid_abi.h"
> > +
> > +struct pci_dev;
> > +
> > +__printf(8, 9)
> > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid sigid,
> > +		 u32 component, u32 location, const void *data, size_t len,
> > +		 const char *fmt, ...);
> > +
> > +#endif

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Summers, Stuart]

On Thu, 2026-07-30 at 17:20 +0200, Michal Wajdeczko wrote:
> From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> 
> Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
> strings that have no stable shape. That is readable for a human, but
> it
> gives fleet tooling nothing durable to match on: the wording changes
> between releases, lines can be rate-limited or dropped under an error
> storm, and there is no consistent way to ask "which recognised fault
> just happened?".
> 
> Introduce a signature identifier (SIGID): a small, stable integer
> that
> names one recognised Xe fault situation and serves as the primary
> handle
> for triage. A SIGID maps, through published end-user documentation,
> to a
> description and a recommended action; the driver only has to emit the
> right SIGID next to the usual human-readable text.

I'm a little worried we're introducing some ABI with this that isn't
really maintainable in the long term: we might decide to change the
flow or change the way an error is reported or the situation that
triggers this error from firmware or hardware might change for some
reason. Does this lock us into a solution for all of this? I still need
to go through the full patch series...

The dmesg entries are generally for human debuggability. I get the
desire to make these easier to parse for an AI tool or generated
script, but we also don't want to prevent debug related changes for
error handling and reporting.

Thanks,
Stuart

> 
> Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> Assisted-by: Copilot:Opus-4.8
> Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> ---
> Cc: Yoni Levitt <yoni.levitt@intel.com>
> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> Cc: Raag Jadav <raag.jadav@intel.com>
> Cc: Riana Tauro <riana.tauro@intel.com>
> ---
> v2: CORRECTED is still an error (Michal)
>     prepare to decorate dmesg with comp/loc (Michal)
> ---
>  Documentation/gpu/xe/index.rst        |   1 +
>  Documentation/gpu/xe/xe_sigid.rst     |  14 ++
>  drivers/gpu/drm/xe/Makefile           |   1 +
>  drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183
> ++++++++++++++++++++++++++
>  drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
>  drivers/gpu/drm/xe/xe_log.h           |  20 +++
>  6 files changed, 354 insertions(+)
>  create mode 100644 Documentation/gpu/xe/xe_sigid.rst
>  create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>  create mode 100644 drivers/gpu/drm/xe/xe_log.c
>  create mode 100644 drivers/gpu/drm/xe/xe_log.h
> 
> diff --git a/Documentation/gpu/xe/index.rst
> b/Documentation/gpu/xe/index.rst
> index 665c0e93601c..0247a255f7e6 100644
> --- a/Documentation/gpu/xe/index.rst
> +++ b/Documentation/gpu/xe/index.rst
> @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for drm/xe
> is provided by
>     xe-drm-usage-stats.rst
>     xe_configfs
>     xe_gt_stats
> +   xe_sigid
> diff --git a/Documentation/gpu/xe/xe_sigid.rst
> b/Documentation/gpu/xe/xe_sigid.rst
> new file mode 100644
> index 000000000000..45d84a62f185
> --- /dev/null
> +++ b/Documentation/gpu/xe/xe_sigid.rst
> @@ -0,0 +1,14 @@
> +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> +
> +========
> +Xe SIGID
> +========
> +
> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> +   :doc: Xe Error Signatures (SIGID)
> +
> +Signature Identifiers
> +=====================
> +
> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> +   :internal:
> diff --git a/drivers/gpu/drm/xe/Makefile
> b/drivers/gpu/drm/xe/Makefile
> index 67ada1d6c2fb..7ac3954737f9 100644
> --- a/drivers/gpu/drm/xe/Makefile
> +++ b/drivers/gpu/drm/xe/Makefile
> @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
>         xe_hw_fence.o \
>         xe_irq.o \
>         xe_late_bind_fw.o \
> +       xe_log.o \
>         xe_lrc.o \
>         xe_mem_pool.o \
>         xe_migrate.o \
> diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> new file mode 100644
> index 000000000000..99717fdf74a6
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> @@ -0,0 +1,183 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +#ifndef _ABI_XE_SIGID_ABI_H_
> +#define _ABI_XE_SIGID_ABI_H_
> +
> +/**
> + * DOC: Xe Error Signatures (SIGID)
> + *
> + * What SIGID stands for
> + * ---------------------
> + *
> + * SIGID is short for *Signature Identifier*. A SIGID is a small,
> stable integer
> + * that names one *recognised Xe fault situation* -- nothing more.
> It is the
> + * primary handle used for triage: a SIGID maps to a human
> description and a
> + * recommended first action. A coarse first-order action is
> documented in-tree
> + * per SIGID (see "First-order action" below) so the id is
> actionable on its
> + * own; published end-user documentation refines it with finer,
> cross-product
> + * detail. The driver's only job is to emit the right SIGID next to
> the usual
> + * human-readable text.
> + *
> + * Why this exists
> + * ---------------
> + *
> + * Today the driver reports faults with ad-hoc ``drm_err()`` /
> ``xe_gt_err()``
> + * strings that have no stable shape. That is fine for a human
> reading dmesg,
> + * but it gives fleet tooling nothing durable to match on: the
> wording changes
> + * between releases, lines can be rate-limited or dropped under an
> error storm,
> + * and there is no consistent way to ask "which recognised fault
> just happened?"
> + * A SIGID answers exactly that one question, identically across
> driver and
> + * firmware versions, and (eventually) across other Intel devices in
> a node.
> + *
> + * What a SIGID is (and is not)
> + * ----------------------------
> + *
> + * A SIGID names *which situation* is being reported. It
> deliberately does not
> + * encode the detailed reason or the outcome. Those are carried
> alongside it::
> + *
> + *   SIGID    -> which recognised situation is being reported
> + *   severity -> how serious this instance is (see below -- not
> fixed per SIGID)
> + *   errno    -> the failing operation's error, shown with %pe
> + *   message  -> free-form human-readable context
> + *
> + * Severity is independent of the SIGID. The same situation can be
> reported at
> + * different severities depending on the instance and the recovery
> taken, so a
> + * SIGID is never tied to one severity; the reporting site chooses
> it by calling
> + * the matching xe_log_*() helper (see xe_log.h).
> + *
> + * How to pick a SIGID (the uniqueness rule)
> + * -----------------------------------------
> + *
> + * Pick per *report site*, not per incident. Each site emits the
> single most
> + * specific recognised situation *for that site* -- so the question
> is never
> + * "classify this whole failure", it is "what does this site
> detect?", which has
> + * one answer. A single underlying failure therefore legitimately
> produces a
> + * *chain* of reports from different layers, each with its own SIGID
> -- e.g. a
> + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by
> the firmware
> + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path,
> and an
> + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain
> lets triage
> + * follow a fault from origin to final effect; it is not a
> duplicate.
> + *
> + * If a site does not match any defined situation, keep using the
> ordinary
> + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a
> SIGID: a wrong
> + * or over-broad classification is harder to retire than a missing
> one. When a
> + * new situation is genuinely worth triaging, add it to the list
> below.
> + *
> + * Scope: software-emitted signatures only
> + * ---------------------------------------
> + *
> + * This header enumerates only the situations that the *driver
> itself* detects
> + * and reports from software: probe abort, wedged, survivability,
> driver-
> + * detected firmware failures, engine TDR, memory faults and IO/bus
> faults.
> + * These are the only values the driver assigns.
> + *
> + * Signatures that *originate* in firmware or hardware are a
> different thing:
> + * they are produced and identified by the firmware or the hardware
> itself
> + * (e.g. via their own records or error counters), and the driver
> merely logs
> + * them as they are given to us. They are deliberately *not*
> enumerated here --
> + * minting a driver-side id for a firmware/hardware-reported error
> would only
> + * duplicate an identifier the reporting layer already owns. The two
> + * driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
> + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the
> driver*
> + * observed a firmware problem, not a signature reported by the
> firmware.
> + *
> + * Numbering
> + * ---------
> + *
> + * SIGIDs are a single flat list numbered sequentially within the
> assigned range,
> + * in the order the situations were introduced. Values are stable:
> once assigned
> + * they are only ever appended, never renumbered or reused.
> + *
> + * A retired situation is deprecated in place, never re-purposed.
> + *
> + * First-order action (resolution buckets)
> + * ---------------------------------------
> + *
> + * So that a SIGID is actionable on its own, each one is tagged with
> a coarse
> + * *resolution bucket*: the first thing an operator should do on
> seeing it. The
> + * bucket is a stable, driver-owned hint; external documentation may
> refine it,
> + * but the in-tree value always stands on its own. Every new SIGID
> must pick a
> + * bucket, which forces the question "what should someone do about
> this?" to be
> + * answered up front. The buckets are::
> + *
> + *   COLLECT  -- capture logs and open a bug report
> + *   RETRY    -- transient or already recovered; watch for
> recurrence
> + *   UPDATE   -- a firmware update / flash is required
> + *   RECOVER  -- an explicit recovery step is needed (rebind, bus
> reset)
> + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
> + *
> + * The bucket is documentation only -- it is recorded per SIGID in
> the enum
> + * kernel-doc below and is not printed on the (deliberately lean)
> dmesg line.
> + *
> + * When to use SIGID logging
> + * -------------------------
> + *
> + * The xe_log_*() helpers are for these recognised fault situations
> only --
> + * important, operator-relevant faults and events. They are not a
> replacement
> + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off
> diagnostics;
> + * using them for ordinary logging would dilute the fault stream.
> Not every
> + * ``xe_err()`` needs to become a SIGID report -- only those that
> correspond to
> + * a published situation.
> + *
> + * dmesg vs. the machine record
> + * ----------------------------
> + *
> + * The dmesg line stays close to a normal xe error message so it
> remains
> + * readable for admins; the only stable, machine-matchable token on
> it is
> + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI: the
> surrounding
> + * text may change freely, and lines may be dropped. The durable
> record for
> + * tooling is the CPER record carrying the same SIGID (generation is
> a planned
> + * follow-up).
> + */
> +
> +/*
> + * Top level Intel Error Signature Identifiers.
> + */
> +#define INTEL_SIGID_INVALID                    0
> +#define INTEL_SIGID_GPU_START                  100
> +#define INTEL_SIGID_GPU_END                    999
> +
> +#define INTEL_SIGID_GPU_XE_START               100
> +#define INTEL_SIGID_GPU_XE_END                 299
> +
> +#define INTEL_SIGID_GPU_XE_SOFTWARE_START      100
> +#define INTEL_SIGID_GPU_XE_SOFTWARE_END                199
> +#define INTEL_SIGID_GPU_XE_HARDWARE_START      200
> +#define INTEL_SIGID_GPU_XE_HARDWARE_END                299
> +
> +/**
> + * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
> + * @XE_SIGID_SW: Software component failure. [COLLECT]
> + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
> + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer
> usable. [RECOVER]
> + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode.
> [UPDATE]
> + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure,
> GuC/HuC/GSC. [RETRY]
> + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure,
> PCODE/sysctrl. [RETRY]
> + * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery
> (reset). [RETRY]
> + * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault. [COLLECT]
> + * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault.
> [RECOVER]
> + *
> + * The situations the driver detects and reports in software. Values
> are
> + * numbered sequentially, are only ever appended, and are never
> renumbered or
> + * reused. The tag in brackets is the default resolution bucket (see
> the `Xe
> + * Error Signatures (SIGID)`_ section).
> + *
> + * Firmware- and hardware-originated signatures are not listed here;
> they are
> + * logged as reported by those layers.
> + */
> +enum xe_sigid {
> +       XE_SIGID_SW                     =
> INTEL_SIGID_GPU_XE_SOFTWARE_START,
> +       XE_SIGID_PROBE                  =
> INTEL_SIGID_GPU_XE_SOFTWARE_START + 1,
> +       XE_SIGID_WEDGED                 =
> INTEL_SIGID_GPU_XE_SOFTWARE_START + 2,
> +       XE_SIGID_SURVIVABILITY          =
> INTEL_SIGID_GPU_XE_SOFTWARE_START + 3,
> +       XE_SIGID_RUNTIME_FW             =
> INTEL_SIGID_GPU_XE_SOFTWARE_START + 4,
> +       XE_SIGID_DEVICE_FW              =
> INTEL_SIGID_GPU_XE_SOFTWARE_START + 5,
> +       XE_SIGID_GT_TDR                 =
> INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
> +       XE_SIGID_MEM_FAULT              =
> INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
> +       XE_SIGID_IO_BUS                 =
> INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
> +};
> +
> +#endif
> diff --git a/drivers/gpu/drm/xe/xe_log.c
> b/drivers/gpu/drm/xe/xe_log.c
> new file mode 100644
> index 000000000000..70a41bdf1a01
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/xe_log.c
> @@ -0,0 +1,135 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +#include "xe_log.h"
> +#include "xe_printk.h"
> +
> +static void log_emit_cper(struct pci_dev *pdev, int cper_sev, enum
> xe_sigid sigid,
> +                         u32 component, u32 location, const void
> *data, size_t len,
> +                         struct va_format *vaf)
> +{
> +       /* TODO */
> +}
> +
> +static bool is_hw_sigid(enum xe_sigid sigid)
> +{
> +       return (int)sigid >= INTEL_SIGID_GPU_XE_HARDWARE_START;
> +}
> +
> +static bool is_sev_error(int cper_sev)
> +{
> +       return cper_sev != CPER_SEV_INFORMATIONAL;
> +}
> +
> +static const char *log_hwe_prefix(int cper_sev, enum xe_sigid sigid)
> +{
> +       return is_sev_error(cper_sev) && is_hw_sigid(sigid) ? HW_ERR
> : "";
> +}
> +
> +static const char *log_sev_prefix(int cper_sev)
> +{
> +       switch (cper_sev) {
> +       case CPER_SEV_FATAL:
> +               return "FATAL ";
> +       case CPER_SEV_RECOVERABLE:
> +               return "";
> +       case CPER_SEV_CORRECTED:
> +               return "CORRECTED ";
> +       default:
> +               return "";
> +       }
> +}
> +
> +#define __LOG_DRM_PRINTK_FMT(fmt, args...)     "[drm] " fmt, ##args
> +#define __LOG_DRM_PRINTK_ERR_FMT(fmt,
> args...) __LOG_DRM_PRINTK_FMT("*ERROR* " fmt, args)
> +
> +static void log_dmesg_vprintk(struct pci_dev *pdev, int cper_sev,
> struct va_format *vaf)
> +{
> +       if (cper_sev == CPER_SEV_INFORMATIONAL)
> +               pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
> +       else
> +               pci_err(pdev, __LOG_DRM_PRINTK_ERR_FMT("%pV", vaf));
> +}
> +
> +static void log_dmesg_printf(struct pci_dev *pdev, int cper_sev,
> const char *fmt, ...)
> +{
> +       struct va_format vaf;
> +       va_list args;
> +
> +       va_start(args, fmt);
> +       vaf.fmt = fmt;
> +       vaf.va = &args;
> +
> +       log_dmesg_vprintk(pdev, cper_sev, &vaf);
> +
> +       va_end(args);
> +}
> +
> +static void log_emit_dmesg(struct pci_dev *pdev, int cper_sev, enum
> xe_sigid sigid,
> +                          u32 component, u32 location, const void
> *data, size_t len,
> +                          struct va_format *vaf)
> +{
> +       const char *hwe_prefix = log_hwe_prefix(cper_sev, sigid);
> +       const char *sev_prefix = log_sev_prefix(cper_sev);
> +
> +       /* TODO: add component/location details */
> +
> +       if (IS_ERR(data))
> +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%pe)
> %s%pV",
> +                                sigid, sev_prefix, data, hwe_prefix,
> vaf);
> +       else if (data && len)
> +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%*phN)
> %s%pV",
> +                                sigid, sev_prefix, (int)len, data,
> hwe_prefix, vaf);
> +       else
> +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s%s%pV",
> +                                sigid, sev_prefix, hwe_prefix, vaf);
> +}
> +
> +/**
> + * xe_log_emit() - Emit a structured SIGID log entry
> + * @pdev: the &pci_dev device
> + * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE,
> ...)
> + * @sigid: signature identifier, see &enum xe_sigid
> + * @component: component identifer
> + * @location: location details of the @component
> + * @data: pointer to the additional details, or ERR_PTR, or NULL if
> not applicable
> + * @len: length of the @data in bytes, or 0 if not applicable
> + * @fmt: printf-style format string
> + * @...: format arguments
> + *
> + * Emits a dmesg line that includes a single stable, machine-
> matchable token
> + * ``SIGID=<n>`` followed by the optional severity token (like
> ``FATAL``) and,
> + * when @data pointer is set, either the error printed with %pe or a
> packed hex
> + * dump of the @data binary blob. The dmesg line will also include
> printf-style
> + * text message.
> + *
> + * Note that the full dmesg line, with the free text message, is
> only a debugging
> + * aid, not an interface! Only the ``SIGID=<n>`` token is stable
> there.
> + * The durable machine record is the CPER carrying the same SIGID.
> + *
> + * Note: generation of the CPER record is a planned follow-up.
> + *
> + * Examples::
> + *
> + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=104 FATAL (-EPROTO)
> Invalid GuC reply
> + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=106 (-ETIMEDOUT)
> Engine 'rcs0' hung
> + *   <6> xe 0000:03:00.0: [drm] *ERROR* SIGID=103 In survivability
> mode
> + */
> +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid
> sigid,
> +                u32 component, u32 location, const void *data,
> size_t len,
> +                const char *fmt, ...)
> +{
> +       struct va_format vaf;
> +       va_list args;
> +
> +       va_start(args, fmt);
> +       vaf.fmt = fmt;
> +       vaf.va = &args;
> +
> +       log_emit_dmesg(pdev, cper_sev, sigid, component, location,
> data, len, &vaf);
> +       log_emit_cper(pdev, cper_sev, sigid, component, location,
> data, len, &vaf);
> +
> +       va_end(args);
> +}
> diff --git a/drivers/gpu/drm/xe/xe_log.h
> b/drivers/gpu/drm/xe/xe_log.h
> new file mode 100644
> index 000000000000..d475e816ee0b
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/xe_log.h
> @@ -0,0 +1,20 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +#ifndef _XE_LOG_H_
> +#define _XE_LOG_H_
> +
> +#include <linux/cper.h>
> +
> +#include "abi/xe_sigid_abi.h"
> +
> +struct pci_dev;
> +
> +__printf(8, 9)
> +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid
> sigid,
> +                u32 component, u32 location, const void *data,
> size_t len,
> +                const char *fmt, ...);
> +
> +#endif

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Summers, Stuart]

On Tue, 2026-08-04 at 21:21 +0000, Summers, Stuart wrote:
> On Thu, 2026-07-30 at 17:20 +0200, Michal Wajdeczko wrote:
> > From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > 
> > Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
> > strings that have no stable shape. That is readable for a human,
> > but
> > it
> > gives fleet tooling nothing durable to match on: the wording
> > changes
> > between releases, lines can be rate-limited or dropped under an
> > error
> > storm, and there is no consistent way to ask "which recognised
> > fault
> > just happened?".
> > 
> > Introduce a signature identifier (SIGID): a small, stable integer
> > that
> > names one recognised Xe fault situation and serves as the primary
> > handle
> > for triage. A SIGID maps, through published end-user documentation,
> > to a
> > description and a recommended action; the driver only has to emit
> > the
> > right SIGID next to the usual human-readable text.
> 
> I'm a little worried we're introducing some ABI with this that isn't
> really maintainable in the long term: we might decide to change the
> flow or change the way an error is reported or the situation that
> triggers this error from firmware or hardware might change for some
> reason. Does this lock us into a solution for all of this? I still
> need
> to go through the full patch series...
> 
> The dmesg entries are generally for human debuggability. I get the
> desire to make these easier to parse for an AI tool or generated
> script, but we also don't want to prevent debug related changes for
> error handling and reporting.

Also, should we be implementing something like this more generically
across DRM or even outside of DRM and then having device-specific error
conditions within a particular range?

Thanks,
Stuart

> 
> Thanks,
> Stuart
> 
> > 
> > Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > Assisted-by: Copilot:Opus-4.8
> > Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> > Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > ---
> > Cc: Yoni Levitt <yoni.levitt@intel.com>
> > Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> > Cc: Raag Jadav <raag.jadav@intel.com>
> > Cc: Riana Tauro <riana.tauro@intel.com>
> > ---
> > v2: CORRECTED is still an error (Michal)
> >     prepare to decorate dmesg with comp/loc (Michal)
> > ---
> >  Documentation/gpu/xe/index.rst        |   1 +
> >  Documentation/gpu/xe/xe_sigid.rst     |  14 ++
> >  drivers/gpu/drm/xe/Makefile           |   1 +
> >  drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183
> > ++++++++++++++++++++++++++
> >  drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
> >  drivers/gpu/drm/xe/xe_log.h           |  20 +++
> >  6 files changed, 354 insertions(+)
> >  create mode 100644 Documentation/gpu/xe/xe_sigid.rst
> >  create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> >  create mode 100644 drivers/gpu/drm/xe/xe_log.c
> >  create mode 100644 drivers/gpu/drm/xe/xe_log.h
> > 
> > diff --git a/Documentation/gpu/xe/index.rst
> > b/Documentation/gpu/xe/index.rst
> > index 665c0e93601c..0247a255f7e6 100644
> > --- a/Documentation/gpu/xe/index.rst
> > +++ b/Documentation/gpu/xe/index.rst
> > @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for
> > drm/xe
> > is provided by
> >     xe-drm-usage-stats.rst
> >     xe_configfs
> >     xe_gt_stats
> > +   xe_sigid
> > diff --git a/Documentation/gpu/xe/xe_sigid.rst
> > b/Documentation/gpu/xe/xe_sigid.rst
> > new file mode 100644
> > index 000000000000..45d84a62f185
> > --- /dev/null
> > +++ b/Documentation/gpu/xe/xe_sigid.rst
> > @@ -0,0 +1,14 @@
> > +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> > +
> > +========
> > +Xe SIGID
> > +========
> > +
> > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > +   :doc: Xe Error Signatures (SIGID)
> > +
> > +Signature Identifiers
> > +=====================
> > +
> > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > +   :internal:
> > diff --git a/drivers/gpu/drm/xe/Makefile
> > b/drivers/gpu/drm/xe/Makefile
> > index 67ada1d6c2fb..7ac3954737f9 100644
> > --- a/drivers/gpu/drm/xe/Makefile
> > +++ b/drivers/gpu/drm/xe/Makefile
> > @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
> >         xe_hw_fence.o \
> >         xe_irq.o \
> >         xe_late_bind_fw.o \
> > +       xe_log.o \
> >         xe_lrc.o \
> >         xe_mem_pool.o \
> >         xe_migrate.o \
> > diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > new file mode 100644
> > index 000000000000..99717fdf74a6
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > @@ -0,0 +1,183 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#ifndef _ABI_XE_SIGID_ABI_H_
> > +#define _ABI_XE_SIGID_ABI_H_
> > +
> > +/**
> > + * DOC: Xe Error Signatures (SIGID)
> > + *
> > + * What SIGID stands for
> > + * ---------------------
> > + *
> > + * SIGID is short for *Signature Identifier*. A SIGID is a small,
> > stable integer
> > + * that names one *recognised Xe fault situation* -- nothing more.
> > It is the
> > + * primary handle used for triage: a SIGID maps to a human
> > description and a
> > + * recommended first action. A coarse first-order action is
> > documented in-tree
> > + * per SIGID (see "First-order action" below) so the id is
> > actionable on its
> > + * own; published end-user documentation refines it with finer,
> > cross-product
> > + * detail. The driver's only job is to emit the right SIGID next
> > to
> > the usual
> > + * human-readable text.
> > + *
> > + * Why this exists
> > + * ---------------
> > + *
> > + * Today the driver reports faults with ad-hoc ``drm_err()`` /
> > ``xe_gt_err()``
> > + * strings that have no stable shape. That is fine for a human
> > reading dmesg,
> > + * but it gives fleet tooling nothing durable to match on: the
> > wording changes
> > + * between releases, lines can be rate-limited or dropped under an
> > error storm,
> > + * and there is no consistent way to ask "which recognised fault
> > just happened?"
> > + * A SIGID answers exactly that one question, identically across
> > driver and
> > + * firmware versions, and (eventually) across other Intel devices
> > in
> > a node.
> > + *
> > + * What a SIGID is (and is not)
> > + * ----------------------------
> > + *
> > + * A SIGID names *which situation* is being reported. It
> > deliberately does not
> > + * encode the detailed reason or the outcome. Those are carried
> > alongside it::
> > + *
> > + *   SIGID    -> which recognised situation is being reported
> > + *   severity -> how serious this instance is (see below -- not
> > fixed per SIGID)
> > + *   errno    -> the failing operation's error, shown with %pe
> > + *   message  -> free-form human-readable context
> > + *
> > + * Severity is independent of the SIGID. The same situation can be
> > reported at
> > + * different severities depending on the instance and the recovery
> > taken, so a
> > + * SIGID is never tied to one severity; the reporting site chooses
> > it by calling
> > + * the matching xe_log_*() helper (see xe_log.h).
> > + *
> > + * How to pick a SIGID (the uniqueness rule)
> > + * -----------------------------------------
> > + *
> > + * Pick per *report site*, not per incident. Each site emits the
> > single most
> > + * specific recognised situation *for that site* -- so the
> > question
> > is never
> > + * "classify this whole failure", it is "what does this site
> > detect?", which has
> > + * one answer. A single underlying failure therefore legitimately
> > produces a
> > + * *chain* of reports from different layers, each with its own
> > SIGID
> > -- e.g. a
> > + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW
> > by
> > the firmware
> > + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset
> > path,
> > and an
> > + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain
> > lets triage
> > + * follow a fault from origin to final effect; it is not a
> > duplicate.
> > + *
> > + * If a site does not match any defined situation, keep using the
> > ordinary
> > + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a
> > SIGID: a wrong
> > + * or over-broad classification is harder to retire than a missing
> > one. When a
> > + * new situation is genuinely worth triaging, add it to the list
> > below.
> > + *
> > + * Scope: software-emitted signatures only
> > + * ---------------------------------------
> > + *
> > + * This header enumerates only the situations that the *driver
> > itself* detects
> > + * and reports from software: probe abort, wedged, survivability,
> > driver-
> > + * detected firmware failures, engine TDR, memory faults and
> > IO/bus
> > faults.
> > + * These are the only values the driver assigns.
> > + *
> > + * Signatures that *originate* in firmware or hardware are a
> > different thing:
> > + * they are produced and identified by the firmware or the
> > hardware
> > itself
> > + * (e.g. via their own records or error counters), and the driver
> > merely logs
> > + * them as they are given to us. They are deliberately *not*
> > enumerated here --
> > + * minting a driver-side id for a firmware/hardware-reported error
> > would only
> > + * duplicate an identifier the reporting layer already owns. The
> > two
> > + * driver-detected firmware situations below
> > (%XE_SIGID_RUNTIME_FW,
> > + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that
> > *the
> > driver*
> > + * observed a firmware problem, not a signature reported by the
> > firmware.
> > + *
> > + * Numbering
> > + * ---------
> > + *
> > + * SIGIDs are a single flat list numbered sequentially within the
> > assigned range,
> > + * in the order the situations were introduced. Values are stable:
> > once assigned
> > + * they are only ever appended, never renumbered or reused.
> > + *
> > + * A retired situation is deprecated in place, never re-purposed.
> > + *
> > + * First-order action (resolution buckets)
> > + * ---------------------------------------
> > + *
> > + * So that a SIGID is actionable on its own, each one is tagged
> > with
> > a coarse
> > + * *resolution bucket*: the first thing an operator should do on
> > seeing it. The
> > + * bucket is a stable, driver-owned hint; external documentation
> > may
> > refine it,
> > + * but the in-tree value always stands on its own. Every new SIGID
> > must pick a
> > + * bucket, which forces the question "what should someone do about
> > this?" to be
> > + * answered up front. The buckets are::
> > + *
> > + *   COLLECT  -- capture logs and open a bug report
> > + *   RETRY    -- transient or already recovered; watch for
> > recurrence
> > + *   UPDATE   -- a firmware update / flash is required
> > + *   RECOVER  -- an explicit recovery step is needed (rebind, bus
> > reset)
> > + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
> > + *
> > + * The bucket is documentation only -- it is recorded per SIGID in
> > the enum
> > + * kernel-doc below and is not printed on the (deliberately lean)
> > dmesg line.
> > + *
> > + * When to use SIGID logging
> > + * -------------------------
> > + *
> > + * The xe_log_*() helpers are for these recognised fault
> > situations
> > only --
> > + * important, operator-relevant faults and events. They are not a
> > replacement
> > + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off
> > diagnostics;
> > + * using them for ordinary logging would dilute the fault stream.
> > Not every
> > + * ``xe_err()`` needs to become a SIGID report -- only those that
> > correspond to
> > + * a published situation.
> > + *
> > + * dmesg vs. the machine record
> > + * ----------------------------
> > + *
> > + * The dmesg line stays close to a normal xe error message so it
> > remains
> > + * readable for admins; the only stable, machine-matchable token
> > on
> > it is
> > + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI:
> > the
> > surrounding
> > + * text may change freely, and lines may be dropped. The durable
> > record for
> > + * tooling is the CPER record carrying the same SIGID (generation
> > is
> > a planned
> > + * follow-up).
> > + */
> > +
> > +/*
> > + * Top level Intel Error Signature Identifiers.
> > + */
> > +#define INTEL_SIGID_INVALID                    0
> > +#define INTEL_SIGID_GPU_START                  100
> > +#define INTEL_SIGID_GPU_END                    999
> > +
> > +#define INTEL_SIGID_GPU_XE_START               100
> > +#define INTEL_SIGID_GPU_XE_END                 299
> > +
> > +#define INTEL_SIGID_GPU_XE_SOFTWARE_START      100
> > +#define INTEL_SIGID_GPU_XE_SOFTWARE_END                199
> > +#define INTEL_SIGID_GPU_XE_HARDWARE_START      200
> > +#define INTEL_SIGID_GPU_XE_HARDWARE_END                299
> > +
> > +/**
> > + * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
> > + * @XE_SIGID_SW: Software component failure. [COLLECT]
> > + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
> > + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer
> > usable. [RECOVER]
> > + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode.
> > [UPDATE]
> > + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure,
> > GuC/HuC/GSC. [RETRY]
> > + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure,
> > PCODE/sysctrl. [RETRY]
> > + * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery
> > (reset). [RETRY]
> > + * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault.
> > [COLLECT]
> > + * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault.
> > [RECOVER]
> > + *
> > + * The situations the driver detects and reports in software.
> > Values
> > are
> > + * numbered sequentially, are only ever appended, and are never
> > renumbered or
> > + * reused. The tag in brackets is the default resolution bucket
> > (see
> > the `Xe
> > + * Error Signatures (SIGID)`_ section).
> > + *
> > + * Firmware- and hardware-originated signatures are not listed
> > here;
> > they are
> > + * logged as reported by those layers.
> > + */
> > +enum xe_sigid {
> > +       XE_SIGID_SW                     =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START,
> > +       XE_SIGID_PROBE                  =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 1,
> > +       XE_SIGID_WEDGED                 =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 2,
> > +       XE_SIGID_SURVIVABILITY          =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 3,
> > +       XE_SIGID_RUNTIME_FW             =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 4,
> > +       XE_SIGID_DEVICE_FW              =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 5,
> > +       XE_SIGID_GT_TDR                 =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
> > +       XE_SIGID_MEM_FAULT              =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
> > +       XE_SIGID_IO_BUS                 =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
> > +};
> > +
> > +#endif
> > diff --git a/drivers/gpu/drm/xe/xe_log.c
> > b/drivers/gpu/drm/xe/xe_log.c
> > new file mode 100644
> > index 000000000000..70a41bdf1a01
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_log.c
> > @@ -0,0 +1,135 @@
> > +// SPDX-License-Identifier: MIT
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#include "xe_log.h"
> > +#include "xe_printk.h"
> > +
> > +static void log_emit_cper(struct pci_dev *pdev, int cper_sev, enum
> > xe_sigid sigid,
> > +                         u32 component, u32 location, const void
> > *data, size_t len,
> > +                         struct va_format *vaf)
> > +{
> > +       /* TODO */
> > +}
> > +
> > +static bool is_hw_sigid(enum xe_sigid sigid)
> > +{
> > +       return (int)sigid >= INTEL_SIGID_GPU_XE_HARDWARE_START;
> > +}
> > +
> > +static bool is_sev_error(int cper_sev)
> > +{
> > +       return cper_sev != CPER_SEV_INFORMATIONAL;
> > +}
> > +
> > +static const char *log_hwe_prefix(int cper_sev, enum xe_sigid
> > sigid)
> > +{
> > +       return is_sev_error(cper_sev) && is_hw_sigid(sigid) ?
> > HW_ERR
> > : "";
> > +}
> > +
> > +static const char *log_sev_prefix(int cper_sev)
> > +{
> > +       switch (cper_sev) {
> > +       case CPER_SEV_FATAL:
> > +               return "FATAL ";
> > +       case CPER_SEV_RECOVERABLE:
> > +               return "";
> > +       case CPER_SEV_CORRECTED:
> > +               return "CORRECTED ";
> > +       default:
> > +               return "";
> > +       }
> > +}
> > +
> > +#define __LOG_DRM_PRINTK_FMT(fmt, args...)     "[drm] " fmt,
> > ##args
> > +#define __LOG_DRM_PRINTK_ERR_FMT(fmt,
> > args...) __LOG_DRM_PRINTK_FMT("*ERROR* " fmt, args)
> > +
> > +static void log_dmesg_vprintk(struct pci_dev *pdev, int cper_sev,
> > struct va_format *vaf)
> > +{
> > +       if (cper_sev == CPER_SEV_INFORMATIONAL)
> > +               pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
> > +       else
> > +               pci_err(pdev, __LOG_DRM_PRINTK_ERR_FMT("%pV",
> > vaf));
> > +}
> > +
> > +static void log_dmesg_printf(struct pci_dev *pdev, int cper_sev,
> > const char *fmt, ...)
> > +{
> > +       struct va_format vaf;
> > +       va_list args;
> > +
> > +       va_start(args, fmt);
> > +       vaf.fmt = fmt;
> > +       vaf.va = &args;
> > +
> > +       log_dmesg_vprintk(pdev, cper_sev, &vaf);
> > +
> > +       va_end(args);
> > +}
> > +
> > +static void log_emit_dmesg(struct pci_dev *pdev, int cper_sev,
> > enum
> > xe_sigid sigid,
> > +                          u32 component, u32 location, const void
> > *data, size_t len,
> > +                          struct va_format *vaf)
> > +{
> > +       const char *hwe_prefix = log_hwe_prefix(cper_sev, sigid);
> > +       const char *sev_prefix = log_sev_prefix(cper_sev);
> > +
> > +       /* TODO: add component/location details */
> > +
> > +       if (IS_ERR(data))
> > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%pe)
> > %s%pV",
> > +                                sigid, sev_prefix, data,
> > hwe_prefix,
> > vaf);
> > +       else if (data && len)
> > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u
> > %s(%*phN)
> > %s%pV",
> > +                                sigid, sev_prefix, (int)len, data,
> > hwe_prefix, vaf);
> > +       else
> > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u
> > %s%s%pV",
> > +                                sigid, sev_prefix, hwe_prefix,
> > vaf);
> > +}
> > +
> > +/**
> > + * xe_log_emit() - Emit a structured SIGID log entry
> > + * @pdev: the &pci_dev device
> > + * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE,
> > ...)
> > + * @sigid: signature identifier, see &enum xe_sigid
> > + * @component: component identifer
> > + * @location: location details of the @component
> > + * @data: pointer to the additional details, or ERR_PTR, or NULL
> > if
> > not applicable
> > + * @len: length of the @data in bytes, or 0 if not applicable
> > + * @fmt: printf-style format string
> > + * @...: format arguments
> > + *
> > + * Emits a dmesg line that includes a single stable, machine-
> > matchable token
> > + * ``SIGID=<n>`` followed by the optional severity token (like
> > ``FATAL``) and,
> > + * when @data pointer is set, either the error printed with %pe or
> > a
> > packed hex
> > + * dump of the @data binary blob. The dmesg line will also include
> > printf-style
> > + * text message.
> > + *
> > + * Note that the full dmesg line, with the free text message, is
> > only a debugging
> > + * aid, not an interface! Only the ``SIGID=<n>`` token is stable
> > there.
> > + * The durable machine record is the CPER carrying the same SIGID.
> > + *
> > + * Note: generation of the CPER record is a planned follow-up.
> > + *
> > + * Examples::
> > + *
> > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=104 FATAL (-EPROTO)
> > Invalid GuC reply
> > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=106 (-ETIMEDOUT)
> > Engine 'rcs0' hung
> > + *   <6> xe 0000:03:00.0: [drm] *ERROR* SIGID=103 In survivability
> > mode
> > + */
> > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid
> > sigid,
> > +                u32 component, u32 location, const void *data,
> > size_t len,
> > +                const char *fmt, ...)
> > +{
> > +       struct va_format vaf;
> > +       va_list args;
> > +
> > +       va_start(args, fmt);
> > +       vaf.fmt = fmt;
> > +       vaf.va = &args;
> > +
> > +       log_emit_dmesg(pdev, cper_sev, sigid, component, location,
> > data, len, &vaf);
> > +       log_emit_cper(pdev, cper_sev, sigid, component, location,
> > data, len, &vaf);
> > +
> > +       va_end(args);
> > +}
> > diff --git a/drivers/gpu/drm/xe/xe_log.h
> > b/drivers/gpu/drm/xe/xe_log.h
> > new file mode 100644
> > index 000000000000..d475e816ee0b
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_log.h
> > @@ -0,0 +1,20 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#ifndef _XE_LOG_H_
> > +#define _XE_LOG_H_
> > +
> > +#include <linux/cper.h>
> > +
> > +#include "abi/xe_sigid_abi.h"
> > +
> > +struct pci_dev;
> > +
> > +__printf(8, 9)
> > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid
> > sigid,
> > +                u32 component, u32 location, const void *data,
> > size_t len,
> > +                const char *fmt, ...);
> > +
> > +#endif
> 

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Rodrigo Vivi]

On Tue, Aug 04, 2026 at 05:21:05PM -0400, Summers, Stuart wrote:
> On Thu, 2026-07-30 at 17:20 +0200, Michal Wajdeczko wrote:
> > From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > 
> > Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
> > strings that have no stable shape. That is readable for a human, but
> > it
> > gives fleet tooling nothing durable to match on: the wording changes
> > between releases, lines can be rate-limited or dropped under an error
> > storm, and there is no consistent way to ask "which recognised fault
> > just happened?".
> > 
> > Introduce a signature identifier (SIGID): a small, stable integer
> > that
> > names one recognised Xe fault situation and serves as the primary
> > handle
> > for triage. A SIGID maps, through published end-user documentation,
> > to a
> > description and a recommended action; the driver only has to emit the
> > right SIGID next to the usual human-readable text.
> 
> I'm a little worried

I understand your feeling. We've been all through that:

https://lore.kernel.org/intel-xe/amqhoFzQaf1HsuFq@intel.com/

> we're introducing some ABI with this that isn't
> really maintainable in the long term:

I understand the fear and indeed the first proposals I got was
unmaintainable. My first record of pushing back on having something
like this was November last year.

But I respectfully disagree here. This latest version is imho
organized and concise.

> we might decide to change the
> flow or change the way an error is reported or the situation that
> triggers this error from firmware or hardware might change for some
> reason.

You are right, dmesg is not ABI and it will never be. these logs
are aimed for developers and developers are free to change them as
needed. This was a big counter-requirement I gave to the original
idea.

We are not moving all the logs to this format we are not promising
dmesg stability.

The numbering stability however needs to be somewhat stable for
the CPER log in tracefs, that's the ABI. But then that meaning
shouldn't change if the code has to change. A new number should
be needed if the component/location/severity or recommended
recovery needs to be different.

But like I told Raag as well, no developer needs to invent any
number, if they don't know just use regular log messages.
We are not going to move all the logs towards this thing.
Also, the location of the issue is what triggers the ID...
it is very simple by nature. And we need to keep it simple.

> Does this lock us into a solution for all of this? I still need
> to go through the full patch series...

Yes, please take a look to the series. All reviews are welcomed.

> 
> The dmesg entries are generally for human debuggability. I get the
> desire to make these easier to parse for an AI tool or generated
> script, but we also don't want to prevent debug related changes for
> error handling and reporting.

We are not promising this. The stable ABI is only the CPER on tracefs.

We need to always keep this in mind as stated in
Documentation/core-api/printk-index.rst:

"""
The kernel messages are evolving together with the code. As a result,
particular kernel messages are not KABI and never will be!
"""

Thanks,
Rodrigo.

> 
> Thanks,
> Stuart
> 
> > 
> > Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > Assisted-by: Copilot:Opus-4.8
> > Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> > Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > ---
> > Cc: Yoni Levitt <yoni.levitt@intel.com>
> > Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> > Cc: Raag Jadav <raag.jadav@intel.com>
> > Cc: Riana Tauro <riana.tauro@intel.com>
> > ---
> > v2: CORRECTED is still an error (Michal)
> >     prepare to decorate dmesg with comp/loc (Michal)
> > ---
> >  Documentation/gpu/xe/index.rst        |   1 +
> >  Documentation/gpu/xe/xe_sigid.rst     |  14 ++
> >  drivers/gpu/drm/xe/Makefile           |   1 +
> >  drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183
> > ++++++++++++++++++++++++++
> >  drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
> >  drivers/gpu/drm/xe/xe_log.h           |  20 +++
> >  6 files changed, 354 insertions(+)
> >  create mode 100644 Documentation/gpu/xe/xe_sigid.rst
> >  create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> >  create mode 100644 drivers/gpu/drm/xe/xe_log.c
> >  create mode 100644 drivers/gpu/drm/xe/xe_log.h
> > 
> > diff --git a/Documentation/gpu/xe/index.rst
> > b/Documentation/gpu/xe/index.rst
> > index 665c0e93601c..0247a255f7e6 100644
> > --- a/Documentation/gpu/xe/index.rst
> > +++ b/Documentation/gpu/xe/index.rst
> > @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for drm/xe
> > is provided by
> >     xe-drm-usage-stats.rst
> >     xe_configfs
> >     xe_gt_stats
> > +   xe_sigid
> > diff --git a/Documentation/gpu/xe/xe_sigid.rst
> > b/Documentation/gpu/xe/xe_sigid.rst
> > new file mode 100644
> > index 000000000000..45d84a62f185
> > --- /dev/null
> > +++ b/Documentation/gpu/xe/xe_sigid.rst
> > @@ -0,0 +1,14 @@
> > +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> > +
> > +========
> > +Xe SIGID
> > +========
> > +
> > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > +   :doc: Xe Error Signatures (SIGID)
> > +
> > +Signature Identifiers
> > +=====================
> > +
> > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > +   :internal:
> > diff --git a/drivers/gpu/drm/xe/Makefile
> > b/drivers/gpu/drm/xe/Makefile
> > index 67ada1d6c2fb..7ac3954737f9 100644
> > --- a/drivers/gpu/drm/xe/Makefile
> > +++ b/drivers/gpu/drm/xe/Makefile
> > @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
> >         xe_hw_fence.o \
> >         xe_irq.o \
> >         xe_late_bind_fw.o \
> > +       xe_log.o \
> >         xe_lrc.o \
> >         xe_mem_pool.o \
> >         xe_migrate.o \
> > diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > new file mode 100644
> > index 000000000000..99717fdf74a6
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > @@ -0,0 +1,183 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#ifndef _ABI_XE_SIGID_ABI_H_
> > +#define _ABI_XE_SIGID_ABI_H_
> > +
> > +/**
> > + * DOC: Xe Error Signatures (SIGID)
> > + *
> > + * What SIGID stands for
> > + * ---------------------
> > + *
> > + * SIGID is short for *Signature Identifier*. A SIGID is a small,
> > stable integer
> > + * that names one *recognised Xe fault situation* -- nothing more.
> > It is the
> > + * primary handle used for triage: a SIGID maps to a human
> > description and a
> > + * recommended first action. A coarse first-order action is
> > documented in-tree
> > + * per SIGID (see "First-order action" below) so the id is
> > actionable on its
> > + * own; published end-user documentation refines it with finer,
> > cross-product
> > + * detail. The driver's only job is to emit the right SIGID next to
> > the usual
> > + * human-readable text.
> > + *
> > + * Why this exists
> > + * ---------------
> > + *
> > + * Today the driver reports faults with ad-hoc ``drm_err()`` /
> > ``xe_gt_err()``
> > + * strings that have no stable shape. That is fine for a human
> > reading dmesg,
> > + * but it gives fleet tooling nothing durable to match on: the
> > wording changes
> > + * between releases, lines can be rate-limited or dropped under an
> > error storm,
> > + * and there is no consistent way to ask "which recognised fault
> > just happened?"
> > + * A SIGID answers exactly that one question, identically across
> > driver and
> > + * firmware versions, and (eventually) across other Intel devices in
> > a node.
> > + *
> > + * What a SIGID is (and is not)
> > + * ----------------------------
> > + *
> > + * A SIGID names *which situation* is being reported. It
> > deliberately does not
> > + * encode the detailed reason or the outcome. Those are carried
> > alongside it::
> > + *
> > + *   SIGID    -> which recognised situation is being reported
> > + *   severity -> how serious this instance is (see below -- not
> > fixed per SIGID)
> > + *   errno    -> the failing operation's error, shown with %pe
> > + *   message  -> free-form human-readable context
> > + *
> > + * Severity is independent of the SIGID. The same situation can be
> > reported at
> > + * different severities depending on the instance and the recovery
> > taken, so a
> > + * SIGID is never tied to one severity; the reporting site chooses
> > it by calling
> > + * the matching xe_log_*() helper (see xe_log.h).
> > + *
> > + * How to pick a SIGID (the uniqueness rule)
> > + * -----------------------------------------
> > + *
> > + * Pick per *report site*, not per incident. Each site emits the
> > single most
> > + * specific recognised situation *for that site* -- so the question
> > is never
> > + * "classify this whole failure", it is "what does this site
> > detect?", which has
> > + * one answer. A single underlying failure therefore legitimately
> > produces a
> > + * *chain* of reports from different layers, each with its own SIGID
> > -- e.g. a
> > + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by
> > the firmware
> > + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path,
> > and an
> > + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain
> > lets triage
> > + * follow a fault from origin to final effect; it is not a
> > duplicate.
> > + *
> > + * If a site does not match any defined situation, keep using the
> > ordinary
> > + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a
> > SIGID: a wrong
> > + * or over-broad classification is harder to retire than a missing
> > one. When a
> > + * new situation is genuinely worth triaging, add it to the list
> > below.
> > + *
> > + * Scope: software-emitted signatures only
> > + * ---------------------------------------
> > + *
> > + * This header enumerates only the situations that the *driver
> > itself* detects
> > + * and reports from software: probe abort, wedged, survivability,
> > driver-
> > + * detected firmware failures, engine TDR, memory faults and IO/bus
> > faults.
> > + * These are the only values the driver assigns.
> > + *
> > + * Signatures that *originate* in firmware or hardware are a
> > different thing:
> > + * they are produced and identified by the firmware or the hardware
> > itself
> > + * (e.g. via their own records or error counters), and the driver
> > merely logs
> > + * them as they are given to us. They are deliberately *not*
> > enumerated here --
> > + * minting a driver-side id for a firmware/hardware-reported error
> > would only
> > + * duplicate an identifier the reporting layer already owns. The two
> > + * driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
> > + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the
> > driver*
> > + * observed a firmware problem, not a signature reported by the
> > firmware.
> > + *
> > + * Numbering
> > + * ---------
> > + *
> > + * SIGIDs are a single flat list numbered sequentially within the
> > assigned range,
> > + * in the order the situations were introduced. Values are stable:
> > once assigned
> > + * they are only ever appended, never renumbered or reused.
> > + *
> > + * A retired situation is deprecated in place, never re-purposed.
> > + *
> > + * First-order action (resolution buckets)
> > + * ---------------------------------------
> > + *
> > + * So that a SIGID is actionable on its own, each one is tagged with
> > a coarse
> > + * *resolution bucket*: the first thing an operator should do on
> > seeing it. The
> > + * bucket is a stable, driver-owned hint; external documentation may
> > refine it,
> > + * but the in-tree value always stands on its own. Every new SIGID
> > must pick a
> > + * bucket, which forces the question "what should someone do about
> > this?" to be
> > + * answered up front. The buckets are::
> > + *
> > + *   COLLECT  -- capture logs and open a bug report
> > + *   RETRY    -- transient or already recovered; watch for
> > recurrence
> > + *   UPDATE   -- a firmware update / flash is required
> > + *   RECOVER  -- an explicit recovery step is needed (rebind, bus
> > reset)
> > + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
> > + *
> > + * The bucket is documentation only -- it is recorded per SIGID in
> > the enum
> > + * kernel-doc below and is not printed on the (deliberately lean)
> > dmesg line.
> > + *
> > + * When to use SIGID logging
> > + * -------------------------
> > + *
> > + * The xe_log_*() helpers are for these recognised fault situations
> > only --
> > + * important, operator-relevant faults and events. They are not a
> > replacement
> > + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off
> > diagnostics;
> > + * using them for ordinary logging would dilute the fault stream.
> > Not every
> > + * ``xe_err()`` needs to become a SIGID report -- only those that
> > correspond to
> > + * a published situation.
> > + *
> > + * dmesg vs. the machine record
> > + * ----------------------------
> > + *
> > + * The dmesg line stays close to a normal xe error message so it
> > remains
> > + * readable for admins; the only stable, machine-matchable token on
> > it is
> > + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI: the
> > surrounding
> > + * text may change freely, and lines may be dropped. The durable
> > record for
> > + * tooling is the CPER record carrying the same SIGID (generation is
> > a planned
> > + * follow-up).
> > + */
> > +
> > +/*
> > + * Top level Intel Error Signature Identifiers.
> > + */
> > +#define INTEL_SIGID_INVALID                    0
> > +#define INTEL_SIGID_GPU_START                  100
> > +#define INTEL_SIGID_GPU_END                    999
> > +
> > +#define INTEL_SIGID_GPU_XE_START               100
> > +#define INTEL_SIGID_GPU_XE_END                 299
> > +
> > +#define INTEL_SIGID_GPU_XE_SOFTWARE_START      100
> > +#define INTEL_SIGID_GPU_XE_SOFTWARE_END                199
> > +#define INTEL_SIGID_GPU_XE_HARDWARE_START      200
> > +#define INTEL_SIGID_GPU_XE_HARDWARE_END                299
> > +
> > +/**
> > + * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
> > + * @XE_SIGID_SW: Software component failure. [COLLECT]
> > + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
> > + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer
> > usable. [RECOVER]
> > + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode.
> > [UPDATE]
> > + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure,
> > GuC/HuC/GSC. [RETRY]
> > + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure,
> > PCODE/sysctrl. [RETRY]
> > + * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery
> > (reset). [RETRY]
> > + * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault. [COLLECT]
> > + * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault.
> > [RECOVER]
> > + *
> > + * The situations the driver detects and reports in software. Values
> > are
> > + * numbered sequentially, are only ever appended, and are never
> > renumbered or
> > + * reused. The tag in brackets is the default resolution bucket (see
> > the `Xe
> > + * Error Signatures (SIGID)`_ section).
> > + *
> > + * Firmware- and hardware-originated signatures are not listed here;
> > they are
> > + * logged as reported by those layers.
> > + */
> > +enum xe_sigid {
> > +       XE_SIGID_SW                     =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START,
> > +       XE_SIGID_PROBE                  =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 1,
> > +       XE_SIGID_WEDGED                 =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 2,
> > +       XE_SIGID_SURVIVABILITY          =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 3,
> > +       XE_SIGID_RUNTIME_FW             =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 4,
> > +       XE_SIGID_DEVICE_FW              =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 5,
> > +       XE_SIGID_GT_TDR                 =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
> > +       XE_SIGID_MEM_FAULT              =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
> > +       XE_SIGID_IO_BUS                 =
> > INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
> > +};
> > +
> > +#endif
> > diff --git a/drivers/gpu/drm/xe/xe_log.c
> > b/drivers/gpu/drm/xe/xe_log.c
> > new file mode 100644
> > index 000000000000..70a41bdf1a01
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_log.c
> > @@ -0,0 +1,135 @@
> > +// SPDX-License-Identifier: MIT
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#include "xe_log.h"
> > +#include "xe_printk.h"
> > +
> > +static void log_emit_cper(struct pci_dev *pdev, int cper_sev, enum
> > xe_sigid sigid,
> > +                         u32 component, u32 location, const void
> > *data, size_t len,
> > +                         struct va_format *vaf)
> > +{
> > +       /* TODO */
> > +}
> > +
> > +static bool is_hw_sigid(enum xe_sigid sigid)
> > +{
> > +       return (int)sigid >= INTEL_SIGID_GPU_XE_HARDWARE_START;
> > +}
> > +
> > +static bool is_sev_error(int cper_sev)
> > +{
> > +       return cper_sev != CPER_SEV_INFORMATIONAL;
> > +}
> > +
> > +static const char *log_hwe_prefix(int cper_sev, enum xe_sigid sigid)
> > +{
> > +       return is_sev_error(cper_sev) && is_hw_sigid(sigid) ? HW_ERR
> > : "";
> > +}
> > +
> > +static const char *log_sev_prefix(int cper_sev)
> > +{
> > +       switch (cper_sev) {
> > +       case CPER_SEV_FATAL:
> > +               return "FATAL ";
> > +       case CPER_SEV_RECOVERABLE:
> > +               return "";
> > +       case CPER_SEV_CORRECTED:
> > +               return "CORRECTED ";
> > +       default:
> > +               return "";
> > +       }
> > +}
> > +
> > +#define __LOG_DRM_PRINTK_FMT(fmt, args...)     "[drm] " fmt, ##args
> > +#define __LOG_DRM_PRINTK_ERR_FMT(fmt,
> > args...) __LOG_DRM_PRINTK_FMT("*ERROR* " fmt, args)
> > +
> > +static void log_dmesg_vprintk(struct pci_dev *pdev, int cper_sev,
> > struct va_format *vaf)
> > +{
> > +       if (cper_sev == CPER_SEV_INFORMATIONAL)
> > +               pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
> > +       else
> > +               pci_err(pdev, __LOG_DRM_PRINTK_ERR_FMT("%pV", vaf));
> > +}
> > +
> > +static void log_dmesg_printf(struct pci_dev *pdev, int cper_sev,
> > const char *fmt, ...)
> > +{
> > +       struct va_format vaf;
> > +       va_list args;
> > +
> > +       va_start(args, fmt);
> > +       vaf.fmt = fmt;
> > +       vaf.va = &args;
> > +
> > +       log_dmesg_vprintk(pdev, cper_sev, &vaf);
> > +
> > +       va_end(args);
> > +}
> > +
> > +static void log_emit_dmesg(struct pci_dev *pdev, int cper_sev, enum
> > xe_sigid sigid,
> > +                          u32 component, u32 location, const void
> > *data, size_t len,
> > +                          struct va_format *vaf)
> > +{
> > +       const char *hwe_prefix = log_hwe_prefix(cper_sev, sigid);
> > +       const char *sev_prefix = log_sev_prefix(cper_sev);
> > +
> > +       /* TODO: add component/location details */
> > +
> > +       if (IS_ERR(data))
> > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%pe)
> > %s%pV",
> > +                                sigid, sev_prefix, data, hwe_prefix,
> > vaf);
> > +       else if (data && len)
> > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%*phN)
> > %s%pV",
> > +                                sigid, sev_prefix, (int)len, data,
> > hwe_prefix, vaf);
> > +       else
> > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s%s%pV",
> > +                                sigid, sev_prefix, hwe_prefix, vaf);
> > +}
> > +
> > +/**
> > + * xe_log_emit() - Emit a structured SIGID log entry
> > + * @pdev: the &pci_dev device
> > + * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE,
> > ...)
> > + * @sigid: signature identifier, see &enum xe_sigid
> > + * @component: component identifer
> > + * @location: location details of the @component
> > + * @data: pointer to the additional details, or ERR_PTR, or NULL if
> > not applicable
> > + * @len: length of the @data in bytes, or 0 if not applicable
> > + * @fmt: printf-style format string
> > + * @...: format arguments
> > + *
> > + * Emits a dmesg line that includes a single stable, machine-
> > matchable token
> > + * ``SIGID=<n>`` followed by the optional severity token (like
> > ``FATAL``) and,
> > + * when @data pointer is set, either the error printed with %pe or a
> > packed hex
> > + * dump of the @data binary blob. The dmesg line will also include
> > printf-style
> > + * text message.
> > + *
> > + * Note that the full dmesg line, with the free text message, is
> > only a debugging
> > + * aid, not an interface! Only the ``SIGID=<n>`` token is stable
> > there.
> > + * The durable machine record is the CPER carrying the same SIGID.
> > + *
> > + * Note: generation of the CPER record is a planned follow-up.
> > + *
> > + * Examples::
> > + *
> > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=104 FATAL (-EPROTO)
> > Invalid GuC reply
> > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=106 (-ETIMEDOUT)
> > Engine 'rcs0' hung
> > + *   <6> xe 0000:03:00.0: [drm] *ERROR* SIGID=103 In survivability
> > mode
> > + */
> > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid
> > sigid,
> > +                u32 component, u32 location, const void *data,
> > size_t len,
> > +                const char *fmt, ...)
> > +{
> > +       struct va_format vaf;
> > +       va_list args;
> > +
> > +       va_start(args, fmt);
> > +       vaf.fmt = fmt;
> > +       vaf.va = &args;
> > +
> > +       log_emit_dmesg(pdev, cper_sev, sigid, component, location,
> > data, len, &vaf);
> > +       log_emit_cper(pdev, cper_sev, sigid, component, location,
> > data, len, &vaf);
> > +
> > +       va_end(args);
> > +}
> > diff --git a/drivers/gpu/drm/xe/xe_log.h
> > b/drivers/gpu/drm/xe/xe_log.h
> > new file mode 100644
> > index 000000000000..d475e816ee0b
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_log.h
> > @@ -0,0 +1,20 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2026 Intel Corporation
> > + */
> > +
> > +#ifndef _XE_LOG_H_
> > +#define _XE_LOG_H_
> > +
> > +#include <linux/cper.h>
> > +
> > +#include "abi/xe_sigid_abi.h"
> > +
> > +struct pci_dev;
> > +
> > +__printf(8, 9)
> > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid
> > sigid,
> > +                u32 component, u32 location, const void *data,
> > size_t len,
> > +                const char *fmt, ...);
> > +
> > +#endif
> 

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Rodrigo Vivi]

On Tue, Aug 04, 2026 at 05:22:29PM -0400, Summers, Stuart wrote:
> On Tue, 2026-08-04 at 21:21 +0000, Summers, Stuart wrote:
> > On Thu, 2026-07-30 at 17:20 +0200, Michal Wajdeczko wrote:
> > > From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > > 
> > > Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
> > > strings that have no stable shape. That is readable for a human,
> > > but
> > > it
> > > gives fleet tooling nothing durable to match on: the wording
> > > changes
> > > between releases, lines can be rate-limited or dropped under an
> > > error
> > > storm, and there is no consistent way to ask "which recognised
> > > fault
> > > just happened?".
> > > 
> > > Introduce a signature identifier (SIGID): a small, stable integer
> > > that
> > > names one recognised Xe fault situation and serves as the primary
> > > handle
> > > for triage. A SIGID maps, through published end-user documentation,
> > > to a
> > > description and a recommended action; the driver only has to emit
> > > the
> > > right SIGID next to the usual human-readable text.
> > 
> > I'm a little worried we're introducing some ABI with this that isn't
> > really maintainable in the long term: we might decide to change the
> > flow or change the way an error is reported or the situation that
> > triggers this error from firmware or hardware might change for some
> > reason. Does this lock us into a solution for all of this? I still
> > need
> > to go through the full patch series...
> > 
> > The dmesg entries are generally for human debuggability. I get the
> > desire to make these easier to parse for an AI tool or generated
> > script, but we also don't want to prevent debug related changes for
> > error handling and reporting.
> 
> Also, should we be implementing something like this more generically
> across DRM or even outside of DRM and then having device-specific error
> conditions within a particular range?

I doubt that this will be useful outside of our Intel GPU.
Also, other subsystem and drivers have different needs for this
problem and no good broad idea.

Take a look to the cases Jani pointed out:
https://lore.kernel.org/intel-xe/amqhoFzQaf1HsuFq@intel.com/

> 
> Thanks,
> Stuart
> 
> > 
> > Thanks,
> > Stuart
> > 
> > > 
> > > Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > > Assisted-by: Copilot:Opus-4.8
> > > Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> > > Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > > Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > > ---
> > > Cc: Yoni Levitt <yoni.levitt@intel.com>
> > > Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> > > Cc: Raag Jadav <raag.jadav@intel.com>
> > > Cc: Riana Tauro <riana.tauro@intel.com>
> > > ---
> > > v2: CORRECTED is still an error (Michal)
> > >     prepare to decorate dmesg with comp/loc (Michal)
> > > ---
> > >  Documentation/gpu/xe/index.rst        |   1 +
> > >  Documentation/gpu/xe/xe_sigid.rst     |  14 ++
> > >  drivers/gpu/drm/xe/Makefile           |   1 +
> > >  drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183
> > > ++++++++++++++++++++++++++
> > >  drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
> > >  drivers/gpu/drm/xe/xe_log.h           |  20 +++
> > >  6 files changed, 354 insertions(+)
> > >  create mode 100644 Documentation/gpu/xe/xe_sigid.rst
> > >  create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > >  create mode 100644 drivers/gpu/drm/xe/xe_log.c
> > >  create mode 100644 drivers/gpu/drm/xe/xe_log.h
> > > 
> > > diff --git a/Documentation/gpu/xe/index.rst
> > > b/Documentation/gpu/xe/index.rst
> > > index 665c0e93601c..0247a255f7e6 100644
> > > --- a/Documentation/gpu/xe/index.rst
> > > +++ b/Documentation/gpu/xe/index.rst
> > > @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for
> > > drm/xe
> > > is provided by
> > >     xe-drm-usage-stats.rst
> > >     xe_configfs
> > >     xe_gt_stats
> > > +   xe_sigid
> > > diff --git a/Documentation/gpu/xe/xe_sigid.rst
> > > b/Documentation/gpu/xe/xe_sigid.rst
> > > new file mode 100644
> > > index 000000000000..45d84a62f185
> > > --- /dev/null
> > > +++ b/Documentation/gpu/xe/xe_sigid.rst
> > > @@ -0,0 +1,14 @@
> > > +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> > > +
> > > +========
> > > +Xe SIGID
> > > +========
> > > +
> > > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > +   :doc: Xe Error Signatures (SIGID)
> > > +
> > > +Signature Identifiers
> > > +=====================
> > > +
> > > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > +   :internal:
> > > diff --git a/drivers/gpu/drm/xe/Makefile
> > > b/drivers/gpu/drm/xe/Makefile
> > > index 67ada1d6c2fb..7ac3954737f9 100644
> > > --- a/drivers/gpu/drm/xe/Makefile
> > > +++ b/drivers/gpu/drm/xe/Makefile
> > > @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
> > >         xe_hw_fence.o \
> > >         xe_irq.o \
> > >         xe_late_bind_fw.o \
> > > +       xe_log.o \
> > >         xe_lrc.o \
> > >         xe_mem_pool.o \
> > >         xe_migrate.o \
> > > diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > new file mode 100644
> > > index 000000000000..99717fdf74a6
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > @@ -0,0 +1,183 @@
> > > +/* SPDX-License-Identifier: MIT */
> > > +/*
> > > + * Copyright © 2026 Intel Corporation
> > > + */
> > > +
> > > +#ifndef _ABI_XE_SIGID_ABI_H_
> > > +#define _ABI_XE_SIGID_ABI_H_
> > > +
> > > +/**
> > > + * DOC: Xe Error Signatures (SIGID)
> > > + *
> > > + * What SIGID stands for
> > > + * ---------------------
> > > + *
> > > + * SIGID is short for *Signature Identifier*. A SIGID is a small,
> > > stable integer
> > > + * that names one *recognised Xe fault situation* -- nothing more.
> > > It is the
> > > + * primary handle used for triage: a SIGID maps to a human
> > > description and a
> > > + * recommended first action. A coarse first-order action is
> > > documented in-tree
> > > + * per SIGID (see "First-order action" below) so the id is
> > > actionable on its
> > > + * own; published end-user documentation refines it with finer,
> > > cross-product
> > > + * detail. The driver's only job is to emit the right SIGID next
> > > to
> > > the usual
> > > + * human-readable text.
> > > + *
> > > + * Why this exists
> > > + * ---------------
> > > + *
> > > + * Today the driver reports faults with ad-hoc ``drm_err()`` /
> > > ``xe_gt_err()``
> > > + * strings that have no stable shape. That is fine for a human
> > > reading dmesg,
> > > + * but it gives fleet tooling nothing durable to match on: the
> > > wording changes
> > > + * between releases, lines can be rate-limited or dropped under an
> > > error storm,
> > > + * and there is no consistent way to ask "which recognised fault
> > > just happened?"
> > > + * A SIGID answers exactly that one question, identically across
> > > driver and
> > > + * firmware versions, and (eventually) across other Intel devices
> > > in
> > > a node.
> > > + *
> > > + * What a SIGID is (and is not)
> > > + * ----------------------------
> > > + *
> > > + * A SIGID names *which situation* is being reported. It
> > > deliberately does not
> > > + * encode the detailed reason or the outcome. Those are carried
> > > alongside it::
> > > + *
> > > + *   SIGID    -> which recognised situation is being reported
> > > + *   severity -> how serious this instance is (see below -- not
> > > fixed per SIGID)
> > > + *   errno    -> the failing operation's error, shown with %pe
> > > + *   message  -> free-form human-readable context
> > > + *
> > > + * Severity is independent of the SIGID. The same situation can be
> > > reported at
> > > + * different severities depending on the instance and the recovery
> > > taken, so a
> > > + * SIGID is never tied to one severity; the reporting site chooses
> > > it by calling
> > > + * the matching xe_log_*() helper (see xe_log.h).
> > > + *
> > > + * How to pick a SIGID (the uniqueness rule)
> > > + * -----------------------------------------
> > > + *
> > > + * Pick per *report site*, not per incident. Each site emits the
> > > single most
> > > + * specific recognised situation *for that site* -- so the
> > > question
> > > is never
> > > + * "classify this whole failure", it is "what does this site
> > > detect?", which has
> > > + * one answer. A single underlying failure therefore legitimately
> > > produces a
> > > + * *chain* of reports from different layers, each with its own
> > > SIGID
> > > -- e.g. a
> > > + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW
> > > by
> > > the firmware
> > > + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset
> > > path,
> > > and an
> > > + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain
> > > lets triage
> > > + * follow a fault from origin to final effect; it is not a
> > > duplicate.
> > > + *
> > > + * If a site does not match any defined situation, keep using the
> > > ordinary
> > > + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a
> > > SIGID: a wrong
> > > + * or over-broad classification is harder to retire than a missing
> > > one. When a
> > > + * new situation is genuinely worth triaging, add it to the list
> > > below.
> > > + *
> > > + * Scope: software-emitted signatures only
> > > + * ---------------------------------------
> > > + *
> > > + * This header enumerates only the situations that the *driver
> > > itself* detects
> > > + * and reports from software: probe abort, wedged, survivability,
> > > driver-
> > > + * detected firmware failures, engine TDR, memory faults and
> > > IO/bus
> > > faults.
> > > + * These are the only values the driver assigns.
> > > + *
> > > + * Signatures that *originate* in firmware or hardware are a
> > > different thing:
> > > + * they are produced and identified by the firmware or the
> > > hardware
> > > itself
> > > + * (e.g. via their own records or error counters), and the driver
> > > merely logs
> > > + * them as they are given to us. They are deliberately *not*
> > > enumerated here --
> > > + * minting a driver-side id for a firmware/hardware-reported error
> > > would only
> > > + * duplicate an identifier the reporting layer already owns. The
> > > two
> > > + * driver-detected firmware situations below
> > > (%XE_SIGID_RUNTIME_FW,
> > > + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that
> > > *the
> > > driver*
> > > + * observed a firmware problem, not a signature reported by the
> > > firmware.
> > > + *
> > > + * Numbering
> > > + * ---------
> > > + *
> > > + * SIGIDs are a single flat list numbered sequentially within the
> > > assigned range,
> > > + * in the order the situations were introduced. Values are stable:
> > > once assigned
> > > + * they are only ever appended, never renumbered or reused.
> > > + *
> > > + * A retired situation is deprecated in place, never re-purposed.
> > > + *
> > > + * First-order action (resolution buckets)
> > > + * ---------------------------------------
> > > + *
> > > + * So that a SIGID is actionable on its own, each one is tagged
> > > with
> > > a coarse
> > > + * *resolution bucket*: the first thing an operator should do on
> > > seeing it. The
> > > + * bucket is a stable, driver-owned hint; external documentation
> > > may
> > > refine it,
> > > + * but the in-tree value always stands on its own. Every new SIGID
> > > must pick a
> > > + * bucket, which forces the question "what should someone do about
> > > this?" to be
> > > + * answered up front. The buckets are::
> > > + *
> > > + *   COLLECT  -- capture logs and open a bug report
> > > + *   RETRY    -- transient or already recovered; watch for
> > > recurrence
> > > + *   UPDATE   -- a firmware update / flash is required
> > > + *   RECOVER  -- an explicit recovery step is needed (rebind, bus
> > > reset)
> > > + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
> > > + *
> > > + * The bucket is documentation only -- it is recorded per SIGID in
> > > the enum
> > > + * kernel-doc below and is not printed on the (deliberately lean)
> > > dmesg line.
> > > + *
> > > + * When to use SIGID logging
> > > + * -------------------------
> > > + *
> > > + * The xe_log_*() helpers are for these recognised fault
> > > situations
> > > only --
> > > + * important, operator-relevant faults and events. They are not a
> > > replacement
> > > + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off
> > > diagnostics;
> > > + * using them for ordinary logging would dilute the fault stream.
> > > Not every
> > > + * ``xe_err()`` needs to become a SIGID report -- only those that
> > > correspond to
> > > + * a published situation.
> > > + *
> > > + * dmesg vs. the machine record
> > > + * ----------------------------
> > > + *
> > > + * The dmesg line stays close to a normal xe error message so it
> > > remains
> > > + * readable for admins; the only stable, machine-matchable token
> > > on
> > > it is
> > > + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI:
> > > the
> > > surrounding
> > > + * text may change freely, and lines may be dropped. The durable
> > > record for
> > > + * tooling is the CPER record carrying the same SIGID (generation
> > > is
> > > a planned
> > > + * follow-up).
> > > + */
> > > +
> > > +/*
> > > + * Top level Intel Error Signature Identifiers.
> > > + */
> > > +#define INTEL_SIGID_INVALID                    0
> > > +#define INTEL_SIGID_GPU_START                  100
> > > +#define INTEL_SIGID_GPU_END                    999
> > > +
> > > +#define INTEL_SIGID_GPU_XE_START               100
> > > +#define INTEL_SIGID_GPU_XE_END                 299
> > > +
> > > +#define INTEL_SIGID_GPU_XE_SOFTWARE_START      100
> > > +#define INTEL_SIGID_GPU_XE_SOFTWARE_END                199
> > > +#define INTEL_SIGID_GPU_XE_HARDWARE_START      200
> > > +#define INTEL_SIGID_GPU_XE_HARDWARE_END                299
> > > +
> > > +/**
> > > + * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
> > > + * @XE_SIGID_SW: Software component failure. [COLLECT]
> > > + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
> > > + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer
> > > usable. [RECOVER]
> > > + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode.
> > > [UPDATE]
> > > + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure,
> > > GuC/HuC/GSC. [RETRY]
> > > + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure,
> > > PCODE/sysctrl. [RETRY]
> > > + * @XE_SIGID_GT_TDR: Engine hang / timeout detection and recovery
> > > (reset). [RETRY]
> > > + * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault.
> > > [COLLECT]
> > > + * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault.
> > > [RECOVER]
> > > + *
> > > + * The situations the driver detects and reports in software.
> > > Values
> > > are
> > > + * numbered sequentially, are only ever appended, and are never
> > > renumbered or
> > > + * reused. The tag in brackets is the default resolution bucket
> > > (see
> > > the `Xe
> > > + * Error Signatures (SIGID)`_ section).
> > > + *
> > > + * Firmware- and hardware-originated signatures are not listed
> > > here;
> > > they are
> > > + * logged as reported by those layers.
> > > + */
> > > +enum xe_sigid {
> > > +       XE_SIGID_SW                     =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START,
> > > +       XE_SIGID_PROBE                  =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 1,
> > > +       XE_SIGID_WEDGED                 =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 2,
> > > +       XE_SIGID_SURVIVABILITY          =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 3,
> > > +       XE_SIGID_RUNTIME_FW             =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 4,
> > > +       XE_SIGID_DEVICE_FW              =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 5,
> > > +       XE_SIGID_GT_TDR                 =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
> > > +       XE_SIGID_MEM_FAULT              =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
> > > +       XE_SIGID_IO_BUS                 =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
> > > +};
> > > +
> > > +#endif
> > > diff --git a/drivers/gpu/drm/xe/xe_log.c
> > > b/drivers/gpu/drm/xe/xe_log.c
> > > new file mode 100644
> > > index 000000000000..70a41bdf1a01
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/xe/xe_log.c
> > > @@ -0,0 +1,135 @@
> > > +// SPDX-License-Identifier: MIT
> > > +/*
> > > + * Copyright © 2026 Intel Corporation
> > > + */
> > > +
> > > +#include "xe_log.h"
> > > +#include "xe_printk.h"
> > > +
> > > +static void log_emit_cper(struct pci_dev *pdev, int cper_sev, enum
> > > xe_sigid sigid,
> > > +                         u32 component, u32 location, const void
> > > *data, size_t len,
> > > +                         struct va_format *vaf)
> > > +{
> > > +       /* TODO */
> > > +}
> > > +
> > > +static bool is_hw_sigid(enum xe_sigid sigid)
> > > +{
> > > +       return (int)sigid >= INTEL_SIGID_GPU_XE_HARDWARE_START;
> > > +}
> > > +
> > > +static bool is_sev_error(int cper_sev)
> > > +{
> > > +       return cper_sev != CPER_SEV_INFORMATIONAL;
> > > +}
> > > +
> > > +static const char *log_hwe_prefix(int cper_sev, enum xe_sigid
> > > sigid)
> > > +{
> > > +       return is_sev_error(cper_sev) && is_hw_sigid(sigid) ?
> > > HW_ERR
> > > : "";
> > > +}
> > > +
> > > +static const char *log_sev_prefix(int cper_sev)
> > > +{
> > > +       switch (cper_sev) {
> > > +       case CPER_SEV_FATAL:
> > > +               return "FATAL ";
> > > +       case CPER_SEV_RECOVERABLE:
> > > +               return "";
> > > +       case CPER_SEV_CORRECTED:
> > > +               return "CORRECTED ";
> > > +       default:
> > > +               return "";
> > > +       }
> > > +}
> > > +
> > > +#define __LOG_DRM_PRINTK_FMT(fmt, args...)     "[drm] " fmt,
> > > ##args
> > > +#define __LOG_DRM_PRINTK_ERR_FMT(fmt,
> > > args...) __LOG_DRM_PRINTK_FMT("*ERROR* " fmt, args)
> > > +
> > > +static void log_dmesg_vprintk(struct pci_dev *pdev, int cper_sev,
> > > struct va_format *vaf)
> > > +{
> > > +       if (cper_sev == CPER_SEV_INFORMATIONAL)
> > > +               pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
> > > +       else
> > > +               pci_err(pdev, __LOG_DRM_PRINTK_ERR_FMT("%pV",
> > > vaf));
> > > +}
> > > +
> > > +static void log_dmesg_printf(struct pci_dev *pdev, int cper_sev,
> > > const char *fmt, ...)
> > > +{
> > > +       struct va_format vaf;
> > > +       va_list args;
> > > +
> > > +       va_start(args, fmt);
> > > +       vaf.fmt = fmt;
> > > +       vaf.va = &args;
> > > +
> > > +       log_dmesg_vprintk(pdev, cper_sev, &vaf);
> > > +
> > > +       va_end(args);
> > > +}
> > > +
> > > +static void log_emit_dmesg(struct pci_dev *pdev, int cper_sev,
> > > enum
> > > xe_sigid sigid,
> > > +                          u32 component, u32 location, const void
> > > *data, size_t len,
> > > +                          struct va_format *vaf)
> > > +{
> > > +       const char *hwe_prefix = log_hwe_prefix(cper_sev, sigid);
> > > +       const char *sev_prefix = log_sev_prefix(cper_sev);
> > > +
> > > +       /* TODO: add component/location details */
> > > +
> > > +       if (IS_ERR(data))
> > > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u %s(%pe)
> > > %s%pV",
> > > +                                sigid, sev_prefix, data,
> > > hwe_prefix,
> > > vaf);
> > > +       else if (data && len)
> > > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u
> > > %s(%*phN)
> > > %s%pV",
> > > +                                sigid, sev_prefix, (int)len, data,
> > > hwe_prefix, vaf);
> > > +       else
> > > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u
> > > %s%s%pV",
> > > +                                sigid, sev_prefix, hwe_prefix,
> > > vaf);
> > > +}
> > > +
> > > +/**
> > > + * xe_log_emit() - Emit a structured SIGID log entry
> > > + * @pdev: the &pci_dev device
> > > + * @cper_sev: CPER severity (CPER_SEV_FATAL, CPER_SEV_RECOVERABLE,
> > > ...)
> > > + * @sigid: signature identifier, see &enum xe_sigid
> > > + * @component: component identifer
> > > + * @location: location details of the @component
> > > + * @data: pointer to the additional details, or ERR_PTR, or NULL
> > > if
> > > not applicable
> > > + * @len: length of the @data in bytes, or 0 if not applicable
> > > + * @fmt: printf-style format string
> > > + * @...: format arguments
> > > + *
> > > + * Emits a dmesg line that includes a single stable, machine-
> > > matchable token
> > > + * ``SIGID=<n>`` followed by the optional severity token (like
> > > ``FATAL``) and,
> > > + * when @data pointer is set, either the error printed with %pe or
> > > a
> > > packed hex
> > > + * dump of the @data binary blob. The dmesg line will also include
> > > printf-style
> > > + * text message.
> > > + *
> > > + * Note that the full dmesg line, with the free text message, is
> > > only a debugging
> > > + * aid, not an interface! Only the ``SIGID=<n>`` token is stable
> > > there.
> > > + * The durable machine record is the CPER carrying the same SIGID.
> > > + *
> > > + * Note: generation of the CPER record is a planned follow-up.
> > > + *
> > > + * Examples::
> > > + *
> > > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=104 FATAL (-EPROTO)
> > > Invalid GuC reply
> > > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=106 (-ETIMEDOUT)
> > > Engine 'rcs0' hung
> > > + *   <6> xe 0000:03:00.0: [drm] *ERROR* SIGID=103 In survivability
> > > mode
> > > + */
> > > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid
> > > sigid,
> > > +                u32 component, u32 location, const void *data,
> > > size_t len,
> > > +                const char *fmt, ...)
> > > +{
> > > +       struct va_format vaf;
> > > +       va_list args;
> > > +
> > > +       va_start(args, fmt);
> > > +       vaf.fmt = fmt;
> > > +       vaf.va = &args;
> > > +
> > > +       log_emit_dmesg(pdev, cper_sev, sigid, component, location,
> > > data, len, &vaf);
> > > +       log_emit_cper(pdev, cper_sev, sigid, component, location,
> > > data, len, &vaf);
> > > +
> > > +       va_end(args);
> > > +}
> > > diff --git a/drivers/gpu/drm/xe/xe_log.h
> > > b/drivers/gpu/drm/xe/xe_log.h
> > > new file mode 100644
> > > index 000000000000..d475e816ee0b
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/xe/xe_log.h
> > > @@ -0,0 +1,20 @@
> > > +/* SPDX-License-Identifier: MIT */
> > > +/*
> > > + * Copyright © 2026 Intel Corporation
> > > + */
> > > +
> > > +#ifndef _XE_LOG_H_
> > > +#define _XE_LOG_H_
> > > +
> > > +#include <linux/cper.h>
> > > +
> > > +#include "abi/xe_sigid_abi.h"
> > > +
> > > +struct pci_dev;
> > > +
> > > +__printf(8, 9)
> > > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum xe_sigid
> > > sigid,
> > > +                u32 component, u32 location, const void *data,
> > > size_t len,
> > > +                const char *fmt, ...);
> > > +
> > > +#endif
> > 
> 

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Michal Wajdeczko]

On 8/4/2026 8:52 PM, Rodrigo Vivi wrote:
> On Tue, Aug 04, 2026 at 08:30:47PM +0530, Tauro, Riana wrote:
>> Hi Mallesh/Michal
>>
>> On 30-07-2026 20:50, Michal Wajdeczko wrote:
>>> From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
>>>
>>> Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
>>> strings that have no stable shape. That is readable for a human, but it
>>> gives fleet tooling nothing durable to match on: the wording changes
>>> between releases, lines can be rate-limited or dropped under an error
>>> storm, and there is no consistent way to ask "which recognised fault
>>> just happened?".
>>>
>>> Introduce a signature identifier (SIGID): a small, stable integer that
>>> names one recognised Xe fault situation and serves as the primary handle
>>> for triage. A SIGID maps, through published end-user documentation, to a
>>> description and a recommended action; the driver only has to emit the
>>> right SIGID next to the usual human-readable text.
>>>
>>> Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
>>> Assisted-by: Copilot:Opus-4.8
>>> Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
>>> Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
>>> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
>>> ---
>>> Cc: Yoni Levitt <yoni.levitt@intel.com>
>>> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
>>> Cc: Raag Jadav <raag.jadav@intel.com>
>>> Cc: Riana Tauro <riana.tauro@intel.com>
>>> ---
>>> v2: CORRECTED is still an error (Michal)
>>>      prepare to decorate dmesg with comp/loc (Michal)
>>> ---
>>>   Documentation/gpu/xe/index.rst        |   1 +
>>>   Documentation/gpu/xe/xe_sigid.rst     |  14 ++
>>>   drivers/gpu/drm/xe/Makefile           |   1 +
>>>   drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183 ++++++++++++++++++++++++++
>>>   drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
>>>   drivers/gpu/drm/xe/xe_log.h           |  20 +++
>>>   6 files changed, 354 insertions(+)
>>>   create mode 100644 Documentation/gpu/xe/xe_sigid.rst
>>>   create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>>   create mode 100644 drivers/gpu/drm/xe/xe_log.c
>>>   create mode 100644 drivers/gpu/drm/xe/xe_log.h
>>>
>>> diff --git a/Documentation/gpu/xe/index.rst b/Documentation/gpu/xe/index.rst
>>> index 665c0e93601c..0247a255f7e6 100644
>>> --- a/Documentation/gpu/xe/index.rst
>>> +++ b/Documentation/gpu/xe/index.rst
>>> @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for drm/xe is provided by
>>>      xe-drm-usage-stats.rst
>>>      xe_configfs
>>>      xe_gt_stats
>>> +   xe_sigid
>>> diff --git a/Documentation/gpu/xe/xe_sigid.rst b/Documentation/gpu/xe/xe_sigid.rst
>>> new file mode 100644
>>> index 000000000000..45d84a62f185
>>> --- /dev/null
>>> +++ b/Documentation/gpu/xe/xe_sigid.rst
>>> @@ -0,0 +1,14 @@
>>> +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
>>> +
>>> +========
>>> +Xe SIGID
>>> +========
>>> +
>>> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>> +   :doc: Xe Error Signatures (SIGID)
>>> +
>>> +Signature Identifiers
>>> +=====================
>>> +
>>> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>> +   :internal:
>>> diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
>>> index 67ada1d6c2fb..7ac3954737f9 100644
>>> --- a/drivers/gpu/drm/xe/Makefile
>>> +++ b/drivers/gpu/drm/xe/Makefile
>>> @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
>>>   	xe_hw_fence.o \
>>>   	xe_irq.o \
>>>   	xe_late_bind_fw.o \
>>> +	xe_log.o \
>>>   	xe_lrc.o \
>>>   	xe_mem_pool.o \
>>>   	xe_migrate.o \
>>> diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>> new file mode 100644
>>> index 000000000000..99717fdf74a6
>>> --- /dev/null
>>> +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>> @@ -0,0 +1,183 @@
>>> +/* SPDX-License-Identifier: MIT */
>>> +/*
>>> + * Copyright © 2026 Intel Corporation
>>> + */
>>> +
>>> +#ifndef _ABI_XE_SIGID_ABI_H_
>>> +#define _ABI_XE_SIGID_ABI_H_
>>> +
>>> +/**
>>> + * DOC: Xe Error Signatures (SIGID)
>>> + *
>>> + * What SIGID stands for
>>> + * ---------------------
>>> + *
>>> + * SIGID is short for *Signature Identifier*. A SIGID is a small, stable integer
>>> + * that names one *recognised Xe fault situation* -- nothing more. It is the
>>> + * primary handle used for triage: a SIGID maps to a human description and a
>> The SIG ID maps to a report site as mentioned in "How to pick a sigid" not a
>> human description.
> 
> Indeed, perhaps with simple:
> s/maps to a human description/maps to a report site/
> 
> we get some consistency?! 
>>
>>> + * recommended first action. A coarse first-order action is documented in-tree
>>> + * per SIGID (see "First-order action" below) so the id is actionable on its
>>> + * own; published end-user documentation refines it with finer, cross-product
>>> + * detail. The driver's only job is to emit the right SIGID next to the usual
>>> + * human-readable text.
>>> + *
>>> + * Why this exists
>>> + * ---------------
>>> + *
>>> + * Today the driver reports faults with ad-hoc ``drm_err()`` / ``xe_gt_err()``
>>> + * strings that have no stable shape. That is fine for a human reading dmesg,
>>> + * but it gives fleet tooling nothing durable to match on: the wording changes
>>> + * between releases, lines can be rate-limited or dropped under an error storm,
>>> + * and there is no consistent way to ask "which recognised fault just happened?"
>>> + * A SIGID answers exactly that one question, identically across driver and
>>> + * firmware versions, and (eventually) across other Intel devices in a node.
>>> + *
>>> + * What a SIGID is (and is not)
>>> + * ----------------------------
>>> + *
>>> + * A SIGID names *which situation* is being reported. It deliberately does not
>> This should also be consistent with "report site" instead of situation.
> 
> Agree.
> s/situation/report site/
> 
>>> + * encode the detailed reason or the outcome. Those are carried alongside it::
>>> + *
>>> + *   SIGID    -> which recognised situation is being reported
>>> + *   severity -> how serious this instance is (see below -- not fixed per SIGID)
>>> + *   errno    -> the failing operation's error, shown with %pe
>>> + *   message  -> free-form human-readable context
>>> + *
>>> + * Severity is independent of the SIGID. The same situation can be reported at
>>> + * different severities depending on the instance and the recovery taken, so a
>>> + * SIGID is never tied to one severity; the reporting site chooses it by calling
>>> + * the matching xe_log_*() helper (see xe_log.h).
>>> + *
>>
>> It'd be more intuitive for readers if section "When to use SIGID logging" is
>> moved before how to pick one.
> 
> It makes sense to me.
> 
>>> + * How to pick a SIGID (the uniqueness rule)
>>> + * -----------------------------------------
>>> + *
>>> + * Pick per *report site*, not per incident. Each site emits the single most
>>> + * specific recognised situation *for that site* -- so the question is never
>>> + * "classify this whole failure", it is "what does this site detect?", which has
>>> + * one answer. A single underlying failure therefore legitimately produces a
>>> + * *chain* of reports from different layers, each with its own SIGID -- e.g. a
>>> + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by the firmware
>>> + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path, and an
>>> + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain lets triage
>>> + * follow a fault from origin to final effect; it is not a duplicate.
>>> + *
>>> + * If a site does not match any defined situation, keep using the ordinary
>>> + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a SIGID: a wrong
>>> + * or over-broad classification is harder to retire than a missing one. When a
>>> + * new situation is genuinely worth triaging, add it to the list below.
>>> + *
>>> + * Scope: software-emitted signatures only
>>> + * ---------------------------------------
>>> + *
>>> + * This header enumerates only the situations that the *driver itself* detects
>>> + * and reports from software: probe abort, wedged, survivability, driver-
>>> + * detected firmware failures, engine TDR, memory faults and IO/bus faults.
>>> + * These are the only values the driver assigns.
>>> + *
>>> + * Signatures that *originate* in firmware or hardware are a different thing:
>>> + * they are produced and identified by the firmware or the hardware itself
>>> + * (e.g. via their own records or error counters), and the driver merely logs
>>> + * them as they are given to us. They are deliberately *not* enumerated here --
>>> + * minting a driver-side id for a firmware/hardware-reported error would only
>>> + * duplicate an identifier the reporting layer already owns. The two
>>> + * driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
>>> + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the driver*
>>> + * observed a firmware problem, not a signature reported by the firmware.
>>> + *
>>> + * Numbering
>>> + * ---------
>>
>> This section also needs to be on the top. It can be missed if it is at the
>> bottom of the document.
> 
> Also agree.
> 
>>
>>> + *
>>> + * SIGIDs are a single flat list numbered sequentially within the assigned range,
>>> + * in the order the situations were introduced. Values are stable: once assigned
>>> + * they are only ever appended, never renumbered or reused.
>>> + *
>>> + * A retired situation is deprecated in place, never re-purposed.
>>> + *
>>> + * First-order action (resolution buckets)
>>> + * ---------------------------------------
>>> + *
>>> + * So that a SIGID is actionable on its own, each one is tagged with a coarse
>>> + * *resolution bucket*: the first thing an operator should do on seeing it. The
>>> + * bucket is a stable, driver-owned hint; external documentation may refine it,
>>> + * but the in-tree value always stands on its own. Every new SIGID must pick a
>>> + * bucket, which forces the question "what should someone do about this?" to be
>>> + * answered up front. The buckets are::
>>> + *
>>> + *   COLLECT  -- capture logs and open a bug report
>>> + *   RETRY    -- transient or already recovered; watch for recurrence
>>> + *   UPDATE   -- a firmware update / flash is required
>>> + *   RECOVER  -- an explicit recovery step is needed (rebind, bus reset)
>>
>>
>> Do we actually need resolution buckets defined here? RECOVER or UPDATE seem
>> a bit vague since states like
>>  WEDGED/SURVIVABILITY have different ways to recover depending on context.
>> Wouldn't detailed resolution steps in another
>> document be better than in logs?
> 
> Fair enough. I would prefer we have some recommendation for a consistent
> end to end story without depending on external docs and all.
> However I do agree that the vagueness in some cases here can defeat the
> purpose and mostly the conflict with the wedge.
> 
> Aravind was already complaining about these buckets. So, perhaps let's just
> remove. But also for consistency we need to change the rest of the text above
> and below:
> 
> - drop "maps to … a recommended first action … 
> - Delete the whole First-order action (resolution buckets) sectio
> - Strip the [TAG] from all nine enum entries.
> - Drop the dmesg note "the bucket … is not printed on the dmesg line.
> 
> Michal, what are your thoughts?

here is updated DOC section, please check if I get it right

/**
 * DOC: Xe Error Signatures (SIGID)
 *
 * What SIGID stands for
 * ---------------------
 *
 * SIGID is short for *Signature Identifier*. It is a small, stable integer
 * that names one of *recognised fault site* -- nothing more. It is the
 * primary handle used for triage and maps directly to specific report site.
 *
 * Numbering
 * ---------
 *
 * SIGIDs are a single flat list numbered sequentially within the assigned range,
 * in the order the fault sites were introduced. Values are stable: once assigned
 * they are only ever appended, never renumbered or reused. A retired fault site
 * SIGID value is deprecated in place, never re-purposed.
 *
 * Why this exists
 * ---------------
 *
 * Today the driver reports faults with ad-hoc ``xe_err()`` / ``xe_gt_err()``
 * strings that have no stable shape. That is fine for a human reading dmesg,
 * but it gives fleet tooling nothing durable to match on: the wording changes
 * between releases, lines can be rate-limited or dropped under an error storm,
 * and there is no consistent way to ask "which recognised fault just happened?"
 *
 * A SIGID answers exactly that one question, identically across driver and
 * firmware versions, and (eventually) across other Intel devices in a node.
 *
 * What a SIGID is not
 * -------------------
 *
 * SIGID deliberately does not encode the detailed reason or the outcome. Those
 * are carried alongside it::
 *
 *   SIGID    -> which recognised fault site is being reported
 *   severity -> how serious this instance is
 *   errno    -> the failing operation's error, if available, shown with %pe
 *   message  -> free-form human-readable context
 *
 * Severity is independent of the SIGID. The same SIGID can be reported at
 * different severities depending on the instance and the recovery taken.
 *
 * When to use SIGID logging
 * -------------------------
 *
 * The xe_log_*() helpers are for these recognised fault sites only --
 * important, operator-relevant faults and events. The driver's only job is to
 * emit the right SIGID next to the usual human-readable text.

 * They are not a replacement for ``xe_info()`` / ``xe_dbg()`` / tracing, nor
 * for one-off diagnostics; using them for ordinary logging would dilute the
 * fault stream. Not every ``xe_err()`` needs to become a SIGID report -- only
 * those that correspond to a published fault sites.
 *
 * SIGID log output (dmesg vs. the machine record)
 * -----------------------------------------------
 *
 * The dmesg line stays close to a normal xe error message so it remains
 * readable for admins; the only stable, machine-matchable token on it is
 * ``SIGID=<n>`` (``dmesg | grep SIGID=``).
 *
 * The full dmesg line is not an ABI: the surrounding text may change freely,
 * and lines may be dropped. The durable record for tooling is the CPER record
 * carrying the same SIGID (generation is a planned follow-up).
 *
 * How to pick a SIGID (the uniqueness rule)
 * -----------------------------------------
 *
 * Pick per *report site*, not per incident. Each site emits the single most
 * specific recognised SIGID *for that site* -- so the question is never
 * "classify this whole failure", it is "what does this site detect?", which has
 * one answer. A single underlying failure therefore legitimately produces a
 * *chain* of reports from different layers, each with its own SIGID -- e.g. a
 * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by the firmware
 * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path, and an
 * aborted bind as %XE_SIGID_PROBE by the probe path. That chain lets triage
 * follow a fault from origin to final effect; it is not a duplicate.
 *
 * If a site does not match any defined SIGID, keep using the ordinary
 * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a SIGID: a wrong
 * or over-broad classification is harder to retire than a missing one. When a
 * new report site is genuinely worth triaging, add it to the list below.
 *
 * Scope: software vs hardware emitted signatures
 * ----------------------------------------------
 *
 * Some SIGID represents fault sites that the *driver itself* detects and
 * reports from the software POV: probe abort, wedged, survivability, driver-
 * detected firmware failures, engine TDR, memory faults and IO/bus faults.
 * These are the only values the driver assigns on its own.
 *
 * Signatures that *originate* in firmware or hardware are a different thing:
 * they are produced and identified by the firmware or the hardware itself
 * (e.g. via their own records or error counters), and the driver merely logs
 * them as they are given to us. They are deliberately enumerated separately.
 *
 * The two driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
 * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the driver*
 * observed a firmware problem, not a signature reported by the firmware.
 */


> 
> Thanks,
> Rodrigo.
> 
>>
>>> + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
>>> + *
>>> + * The bucket is documentation only -- it is recorded per SIGID in the enum
>>> + * kernel-doc below and is not printed on the (deliberately lean) dmesg line.
>>> + *
>>> + * When to use SIGID logging
>>> + * -------------------------
>>> + *
>>> + * The xe_log_*() helpers are for these recognised fault situations only --
>>> + * important, operator-relevant faults and events. They are not a replacement
>>> + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off diagnostics;
>>> + * using them for ordinary logging would dilute the fault stream. Not every
>>> + * ``xe_err()`` needs to become a SIGID report -- only those that correspond to
>>> + * a published situation.
>>> + *
>>> + * dmesg vs. the machine record
>>> + * ----------------------------
>>> + *
>>> + * The dmesg line stays close to a normal xe error message so it remains
>>> + * readable for admins; the only stable, machine-matchable token on it is
>>> + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI: the surrounding
>>> + * text may change freely, and lines may be dropped. The durable record for
>>> + * tooling is the CPER record carrying the same SIGID (generation is a planned
>>> + * follow-up).
>>> + */
>>> +
>>> +/*
>>> + * Top level Intel Error Signature Identifiers.
>>> + */
>>> +#define INTEL_SIGID_INVALID			0
>>> +#define INTEL_SIGID_GPU_START			100
>>
>> why does the sigid start from 100?

there was an offline agreement with Yoni to start GPU SIGIDs from 100
with the limit up to 999 for any future GPU SIGIDs we may want to have

>>
>>> +#define INTEL_SIGID_GPU_END			999
>>> +
>>> +#define INTEL_SIGID_GPU_XE_START		100
>>> +#define INTEL_SIGID_GPU_XE_END			299

and for the XE we should use range 100..299
>>> +
>>> +#define INTEL_SIGID_GPU_XE_SOFTWARE_START	100
>>> +#define INTEL_SIGID_GPU_XE_SOFTWARE_END		199

with the explicit split for SW/HW originated 'fault sites'

>>> +#define INTEL_SIGID_GPU_XE_HARDWARE_START	200
>>> +#define INTEL_SIGID_GPU_XE_HARDWARE_END		299
>>> +
>>> +/**
>>> + * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
>>> + * @XE_SIGID_SW: Software component failure. [COLLECT]
>>> + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
>>> + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer usable. [RECOVER]
>>> + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode. [UPDATE]
>>> + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure, GuC/HuC/GSC. [RETRY]
>>> + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure, PCODE/sysctrl. [RETRY]
>>
>> Pcode or sysctrl errors cannot be retried. Pcode init failures cause
>> survivability mode.
>> RAS sysctrl errors require a secondary bus reset. We could have other
>> firmwares in future with different
>> recovery.
>> That is why it would be better to drop resolution buckets in logs.
>>
>> @aravind thoughts?
>>
>> Thanks
>> Riana
>>

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Rodrigo Vivi]

On Wed, Aug 05, 2026 at 07:23:10PM +0200, Michal Wajdeczko wrote:
> 
> 
> On 8/4/2026 8:52 PM, Rodrigo Vivi wrote:
> > On Tue, Aug 04, 2026 at 08:30:47PM +0530, Tauro, Riana wrote:
> >> Hi Mallesh/Michal
> >>
> >> On 30-07-2026 20:50, Michal Wajdeczko wrote:
> >>> From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> >>>
> >>> Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
> >>> strings that have no stable shape. That is readable for a human, but it
> >>> gives fleet tooling nothing durable to match on: the wording changes
> >>> between releases, lines can be rate-limited or dropped under an error
> >>> storm, and there is no consistent way to ask "which recognised fault
> >>> just happened?".
> >>>
> >>> Introduce a signature identifier (SIGID): a small, stable integer that
> >>> names one recognised Xe fault situation and serves as the primary handle
> >>> for triage. A SIGID maps, through published end-user documentation, to a
> >>> description and a recommended action; the driver only has to emit the
> >>> right SIGID next to the usual human-readable text.
> >>>
> >>> Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> >>> Assisted-by: Copilot:Opus-4.8
> >>> Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> >>> Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> >>> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> >>> ---
> >>> Cc: Yoni Levitt <yoni.levitt@intel.com>
> >>> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> >>> Cc: Raag Jadav <raag.jadav@intel.com>
> >>> Cc: Riana Tauro <riana.tauro@intel.com>
> >>> ---
> >>> v2: CORRECTED is still an error (Michal)
> >>>      prepare to decorate dmesg with comp/loc (Michal)
> >>> ---
> >>>   Documentation/gpu/xe/index.rst        |   1 +
> >>>   Documentation/gpu/xe/xe_sigid.rst     |  14 ++
> >>>   drivers/gpu/drm/xe/Makefile           |   1 +
> >>>   drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183 ++++++++++++++++++++++++++
> >>>   drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
> >>>   drivers/gpu/drm/xe/xe_log.h           |  20 +++
> >>>   6 files changed, 354 insertions(+)
> >>>   create mode 100644 Documentation/gpu/xe/xe_sigid.rst
> >>>   create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> >>>   create mode 100644 drivers/gpu/drm/xe/xe_log.c
> >>>   create mode 100644 drivers/gpu/drm/xe/xe_log.h
> >>>
> >>> diff --git a/Documentation/gpu/xe/index.rst b/Documentation/gpu/xe/index.rst
> >>> index 665c0e93601c..0247a255f7e6 100644
> >>> --- a/Documentation/gpu/xe/index.rst
> >>> +++ b/Documentation/gpu/xe/index.rst
> >>> @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for drm/xe is provided by
> >>>      xe-drm-usage-stats.rst
> >>>      xe_configfs
> >>>      xe_gt_stats
> >>> +   xe_sigid
> >>> diff --git a/Documentation/gpu/xe/xe_sigid.rst b/Documentation/gpu/xe/xe_sigid.rst
> >>> new file mode 100644
> >>> index 000000000000..45d84a62f185
> >>> --- /dev/null
> >>> +++ b/Documentation/gpu/xe/xe_sigid.rst
> >>> @@ -0,0 +1,14 @@
> >>> +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> >>> +
> >>> +========
> >>> +Xe SIGID
> >>> +========
> >>> +
> >>> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> >>> +   :doc: Xe Error Signatures (SIGID)
> >>> +
> >>> +Signature Identifiers
> >>> +=====================
> >>> +
> >>> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> >>> +   :internal:
> >>> diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
> >>> index 67ada1d6c2fb..7ac3954737f9 100644
> >>> --- a/drivers/gpu/drm/xe/Makefile
> >>> +++ b/drivers/gpu/drm/xe/Makefile
> >>> @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
> >>>   	xe_hw_fence.o \
> >>>   	xe_irq.o \
> >>>   	xe_late_bind_fw.o \
> >>> +	xe_log.o \
> >>>   	xe_lrc.o \
> >>>   	xe_mem_pool.o \
> >>>   	xe_migrate.o \
> >>> diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> >>> new file mode 100644
> >>> index 000000000000..99717fdf74a6
> >>> --- /dev/null
> >>> +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> >>> @@ -0,0 +1,183 @@
> >>> +/* SPDX-License-Identifier: MIT */
> >>> +/*
> >>> + * Copyright © 2026 Intel Corporation
> >>> + */
> >>> +
> >>> +#ifndef _ABI_XE_SIGID_ABI_H_
> >>> +#define _ABI_XE_SIGID_ABI_H_
> >>> +
> >>> +/**
> >>> + * DOC: Xe Error Signatures (SIGID)
> >>> + *
> >>> + * What SIGID stands for
> >>> + * ---------------------
> >>> + *
> >>> + * SIGID is short for *Signature Identifier*. A SIGID is a small, stable integer
> >>> + * that names one *recognised Xe fault situation* -- nothing more. It is the
> >>> + * primary handle used for triage: a SIGID maps to a human description and a
> >> The SIG ID maps to a report site as mentioned in "How to pick a sigid" not a
> >> human description.
> > 
> > Indeed, perhaps with simple:
> > s/maps to a human description/maps to a report site/
> > 
> > we get some consistency?! 
> >>
> >>> + * recommended first action. A coarse first-order action is documented in-tree
> >>> + * per SIGID (see "First-order action" below) so the id is actionable on its
> >>> + * own; published end-user documentation refines it with finer, cross-product
> >>> + * detail. The driver's only job is to emit the right SIGID next to the usual
> >>> + * human-readable text.
> >>> + *
> >>> + * Why this exists
> >>> + * ---------------
> >>> + *
> >>> + * Today the driver reports faults with ad-hoc ``drm_err()`` / ``xe_gt_err()``
> >>> + * strings that have no stable shape. That is fine for a human reading dmesg,
> >>> + * but it gives fleet tooling nothing durable to match on: the wording changes
> >>> + * between releases, lines can be rate-limited or dropped under an error storm,
> >>> + * and there is no consistent way to ask "which recognised fault just happened?"
> >>> + * A SIGID answers exactly that one question, identically across driver and
> >>> + * firmware versions, and (eventually) across other Intel devices in a node.
> >>> + *
> >>> + * What a SIGID is (and is not)
> >>> + * ----------------------------
> >>> + *
> >>> + * A SIGID names *which situation* is being reported. It deliberately does not
> >> This should also be consistent with "report site" instead of situation.
> > 
> > Agree.
> > s/situation/report site/
> > 
> >>> + * encode the detailed reason or the outcome. Those are carried alongside it::
> >>> + *
> >>> + *   SIGID    -> which recognised situation is being reported
> >>> + *   severity -> how serious this instance is (see below -- not fixed per SIGID)
> >>> + *   errno    -> the failing operation's error, shown with %pe
> >>> + *   message  -> free-form human-readable context
> >>> + *
> >>> + * Severity is independent of the SIGID. The same situation can be reported at
> >>> + * different severities depending on the instance and the recovery taken, so a
> >>> + * SIGID is never tied to one severity; the reporting site chooses it by calling
> >>> + * the matching xe_log_*() helper (see xe_log.h).
> >>> + *
> >>
> >> It'd be more intuitive for readers if section "When to use SIGID logging" is
> >> moved before how to pick one.
> > 
> > It makes sense to me.
> > 
> >>> + * How to pick a SIGID (the uniqueness rule)
> >>> + * -----------------------------------------
> >>> + *
> >>> + * Pick per *report site*, not per incident. Each site emits the single most
> >>> + * specific recognised situation *for that site* -- so the question is never
> >>> + * "classify this whole failure", it is "what does this site detect?", which has
> >>> + * one answer. A single underlying failure therefore legitimately produces a
> >>> + * *chain* of reports from different layers, each with its own SIGID -- e.g. a
> >>> + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by the firmware
> >>> + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path, and an
> >>> + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain lets triage
> >>> + * follow a fault from origin to final effect; it is not a duplicate.
> >>> + *
> >>> + * If a site does not match any defined situation, keep using the ordinary
> >>> + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a SIGID: a wrong
> >>> + * or over-broad classification is harder to retire than a missing one. When a
> >>> + * new situation is genuinely worth triaging, add it to the list below.
> >>> + *
> >>> + * Scope: software-emitted signatures only
> >>> + * ---------------------------------------
> >>> + *
> >>> + * This header enumerates only the situations that the *driver itself* detects
> >>> + * and reports from software: probe abort, wedged, survivability, driver-
> >>> + * detected firmware failures, engine TDR, memory faults and IO/bus faults.
> >>> + * These are the only values the driver assigns.
> >>> + *
> >>> + * Signatures that *originate* in firmware or hardware are a different thing:
> >>> + * they are produced and identified by the firmware or the hardware itself
> >>> + * (e.g. via their own records or error counters), and the driver merely logs
> >>> + * them as they are given to us. They are deliberately *not* enumerated here --
> >>> + * minting a driver-side id for a firmware/hardware-reported error would only
> >>> + * duplicate an identifier the reporting layer already owns. The two
> >>> + * driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
> >>> + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the driver*
> >>> + * observed a firmware problem, not a signature reported by the firmware.
> >>> + *
> >>> + * Numbering
> >>> + * ---------
> >>
> >> This section also needs to be on the top. It can be missed if it is at the
> >> bottom of the document.
> > 
> > Also agree.
> > 
> >>
> >>> + *
> >>> + * SIGIDs are a single flat list numbered sequentially within the assigned range,
> >>> + * in the order the situations were introduced. Values are stable: once assigned
> >>> + * they are only ever appended, never renumbered or reused.
> >>> + *
> >>> + * A retired situation is deprecated in place, never re-purposed.
> >>> + *
> >>> + * First-order action (resolution buckets)
> >>> + * ---------------------------------------
> >>> + *
> >>> + * So that a SIGID is actionable on its own, each one is tagged with a coarse
> >>> + * *resolution bucket*: the first thing an operator should do on seeing it. The
> >>> + * bucket is a stable, driver-owned hint; external documentation may refine it,
> >>> + * but the in-tree value always stands on its own. Every new SIGID must pick a
> >>> + * bucket, which forces the question "what should someone do about this?" to be
> >>> + * answered up front. The buckets are::
> >>> + *
> >>> + *   COLLECT  -- capture logs and open a bug report
> >>> + *   RETRY    -- transient or already recovered; watch for recurrence
> >>> + *   UPDATE   -- a firmware update / flash is required
> >>> + *   RECOVER  -- an explicit recovery step is needed (rebind, bus reset)
> >>
> >>
> >> Do we actually need resolution buckets defined here? RECOVER or UPDATE seem
> >> a bit vague since states like
> >>  WEDGED/SURVIVABILITY have different ways to recover depending on context.
> >> Wouldn't detailed resolution steps in another
> >> document be better than in logs?
> > 
> > Fair enough. I would prefer we have some recommendation for a consistent
> > end to end story without depending on external docs and all.
> > However I do agree that the vagueness in some cases here can defeat the
> > purpose and mostly the conflict with the wedge.
> > 
> > Aravind was already complaining about these buckets. So, perhaps let's just
> > remove. But also for consistency we need to change the rest of the text above
> > and below:
> > 
> > - drop "maps to … a recommended first action … 
> > - Delete the whole First-order action (resolution buckets) sectio
> > - Strip the [TAG] from all nine enum entries.
> > - Drop the dmesg note "the bucket … is not printed on the dmesg line.
> > 
> > Michal, what are your thoughts?
> 
> here is updated DOC section, please check if I get it right
> 
> /**
>  * DOC: Xe Error Signatures (SIGID)
>  *
>  * What SIGID stands for
>  * ---------------------
>  *
>  * SIGID is short for *Signature Identifier*. It is a small, stable integer
>  * that names one of *recognised fault site* -- nothing more. It is the
>  * primary handle used for triage and maps directly to specific report site.
>  *
>  * Numbering
>  * ---------
>  *
>  * SIGIDs are a single flat list numbered sequentially within the assigned range,
>  * in the order the fault sites were introduced. Values are stable: once assigned
>  * they are only ever appended, never renumbered or reused. A retired fault site
>  * SIGID value is deprecated in place, never re-purposed.
>  *
>  * Why this exists
>  * ---------------
>  *
>  * Today the driver reports faults with ad-hoc ``xe_err()`` / ``xe_gt_err()``
>  * strings that have no stable shape. That is fine for a human reading dmesg,
>  * but it gives fleet tooling nothing durable to match on: the wording changes
>  * between releases, lines can be rate-limited or dropped under an error storm,
>  * and there is no consistent way to ask "which recognised fault just happened?"
>  *
>  * A SIGID answers exactly that one question, identically across driver and
>  * firmware versions, and (eventually) across other Intel devices in a node.
>  *
>  * What a SIGID is not
>  * -------------------
>  *
>  * SIGID deliberately does not encode the detailed reason or the outcome. Those
>  * are carried alongside it::
>  *
>  *   SIGID    -> which recognised fault site is being reported
>  *   severity -> how serious this instance is
>  *   errno    -> the failing operation's error, if available, shown with %pe
>  *   message  -> free-form human-readable context
>  *
>  * Severity is independent of the SIGID. The same SIGID can be reported at
>  * different severities depending on the instance and the recovery taken.
>  *
>  * When to use SIGID logging
>  * -------------------------
>  *
>  * The xe_log_*() helpers are for these recognised fault sites only --
>  * important, operator-relevant faults and events. The driver's only job is to
>  * emit the right SIGID next to the usual human-readable text.
> 
>  * They are not a replacement for ``xe_info()`` / ``xe_dbg()`` / tracing, nor
>  * for one-off diagnostics; using them for ordinary logging would dilute the
>  * fault stream. Not every ``xe_err()`` needs to become a SIGID report -- only
>  * those that correspond to a published fault sites.
>  *
>  * SIGID log output (dmesg vs. the machine record)
>  * -----------------------------------------------
>  *
>  * The dmesg line stays close to a normal xe error message so it remains
>  * readable for admins; the only stable, machine-matchable token on it is
>  * ``SIGID=<n>`` (``dmesg | grep SIGID=``).
>  *
>  * The full dmesg line is not an ABI: the surrounding text may change freely,
>  * and lines may be dropped. The durable record for tooling is the CPER record
>  * carrying the same SIGID (generation is a planned follow-up).
>  *
>  * How to pick a SIGID (the uniqueness rule)
>  * -----------------------------------------
>  *
>  * Pick per *report site*, not per incident. Each site emits the single most
>  * specific recognised SIGID *for that site* -- so the question is never
>  * "classify this whole failure", it is "what does this site detect?", which has
>  * one answer. A single underlying failure therefore legitimately produces a
>  * *chain* of reports from different layers, each with its own SIGID -- e.g. a
>  * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW by the firmware
>  * path, the failed recovery as %XE_SIGID_GT_TDR by the reset path, and an
>  * aborted bind as %XE_SIGID_PROBE by the probe path. That chain lets triage
>  * follow a fault from origin to final effect; it is not a duplicate.
>  *
>  * If a site does not match any defined SIGID, keep using the ordinary
>  * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a SIGID: a wrong
>  * or over-broad classification is harder to retire than a missing one. When a
>  * new report site is genuinely worth triaging, add it to the list below.
>  *
>  * Scope: software vs hardware emitted signatures
>  * ----------------------------------------------
>  *
>  * Some SIGID represents fault sites that the *driver itself* detects and
>  * reports from the software POV: probe abort, wedged, survivability, driver-
>  * detected firmware failures, engine TDR, memory faults and IO/bus faults.
>  * These are the only values the driver assigns on its own.
>  *
>  * Signatures that *originate* in firmware or hardware are a different thing:
>  * they are produced and identified by the firmware or the hardware itself
>  * (e.g. via their own records or error counters), and the driver merely logs
>  * them as they are given to us. They are deliberately enumerated separately.
>  *
>  * The two driver-detected firmware situations below (%XE_SIGID_RUNTIME_FW,
>  * %XE_SIGID_DEVICE_FW) are software signatures: they mark that *the driver*
>  * observed a firmware problem, not a signature reported by the firmware.
>  */

looks good to me. Indeed cleaner...

> 
> 
> > 
> > Thanks,
> > Rodrigo.
> > 
> >>
> >>> + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
> >>> + *
> >>> + * The bucket is documentation only -- it is recorded per SIGID in the enum
> >>> + * kernel-doc below and is not printed on the (deliberately lean) dmesg line.
> >>> + *
> >>> + * When to use SIGID logging
> >>> + * -------------------------
> >>> + *
> >>> + * The xe_log_*() helpers are for these recognised fault situations only --
> >>> + * important, operator-relevant faults and events. They are not a replacement
> >>> + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off diagnostics;
> >>> + * using them for ordinary logging would dilute the fault stream. Not every
> >>> + * ``xe_err()`` needs to become a SIGID report -- only those that correspond to
> >>> + * a published situation.
> >>> + *
> >>> + * dmesg vs. the machine record
> >>> + * ----------------------------
> >>> + *
> >>> + * The dmesg line stays close to a normal xe error message so it remains
> >>> + * readable for admins; the only stable, machine-matchable token on it is
> >>> + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI: the surrounding
> >>> + * text may change freely, and lines may be dropped. The durable record for
> >>> + * tooling is the CPER record carrying the same SIGID (generation is a planned
> >>> + * follow-up).
> >>> + */
> >>> +
> >>> +/*
> >>> + * Top level Intel Error Signature Identifiers.
> >>> + */
> >>> +#define INTEL_SIGID_INVALID			0
> >>> +#define INTEL_SIGID_GPU_START			100
> >>
> >> why does the sigid start from 100?
> 
> there was an offline agreement with Yoni to start GPU SIGIDs from 100
> with the limit up to 999 for any future GPU SIGIDs we may want to have
> 
> >>
> >>> +#define INTEL_SIGID_GPU_END			999
> >>> +
> >>> +#define INTEL_SIGID_GPU_XE_START		100
> >>> +#define INTEL_SIGID_GPU_XE_END			299
> 
> and for the XE we should use range 100..299
> >>> +
> >>> +#define INTEL_SIGID_GPU_XE_SOFTWARE_START	100
> >>> +#define INTEL_SIGID_GPU_XE_SOFTWARE_END		199
> 
> with the explicit split for SW/HW originated 'fault sites'
> 
> >>> +#define INTEL_SIGID_GPU_XE_HARDWARE_START	200
> >>> +#define INTEL_SIGID_GPU_XE_HARDWARE_END		299
> >>> +
> >>> +/**
> >>> + * enum xe_sigid - Stable Xe Error Signature Identifiers (SIGID).
> >>> + * @XE_SIGID_SW: Software component failure. [COLLECT]
> >>> + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
> >>> + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer usable. [RECOVER]
> >>> + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode. [UPDATE]
> >>> + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware failure, GuC/HuC/GSC. [RETRY]
> >>> + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure, PCODE/sysctrl. [RETRY]
> >>
> >> Pcode or sysctrl errors cannot be retried. Pcode init failures cause
> >> survivability mode.
> >> RAS sysctrl errors require a secondary bus reset. We could have other
> >> firmwares in future with different
> >> recovery.
> >> That is why it would be better to drop resolution buckets in logs.
> >>
> >> @aravind thoughts?
> >>
> >> Thanks
> >> Riana
> >>

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Summers, Stuart]

On Tue, 2026-08-04 at 21:36 -0400, Rodrigo Vivi wrote:
> On Tue, Aug 04, 2026 at 05:21:05PM -0400, Summers, Stuart wrote:
> > On Thu, 2026-07-30 at 17:20 +0200, Michal Wajdeczko wrote:
> > > From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > > 
> > > Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
> > > strings that have no stable shape. That is readable for a human,
> > > but
> > > it
> > > gives fleet tooling nothing durable to match on: the wording
> > > changes
> > > between releases, lines can be rate-limited or dropped under an
> > > error
> > > storm, and there is no consistent way to ask "which recognised
> > > fault
> > > just happened?".
> > > 
> > > Introduce a signature identifier (SIGID): a small, stable integer
> > > that
> > > names one recognised Xe fault situation and serves as the primary
> > > handle
> > > for triage. A SIGID maps, through published end-user
> > > documentation,
> > > to a
> > > description and a recommended action; the driver only has to emit
> > > the
> > > right SIGID next to the usual human-readable text.
> > 
> > I'm a little worried
> 
> I understand your feeling. We've been all through that:
> 
> https://lore.kernel.org/intel-xe/amqhoFzQaf1HsuFq@intel.com/
> 
> > we're introducing some ABI with this that isn't
> > really maintainable in the long term:
> 
> I understand the fear and indeed the first proposals I got was
> unmaintainable. My first record of pushing back on having something
> like this was November last year.
> 
> But I respectfully disagree here. This latest version is imho
> organized and concise.
> 
> > we might decide to change the
> > flow or change the way an error is reported or the situation that
> > triggers this error from firmware or hardware might change for some
> > reason.
> 
> You are right, dmesg is not ABI and it will never be. these logs
> are aimed for developers and developers are free to change them as
> needed. This was a big counter-requirement I gave to the original
> idea.
> 
> We are not moving all the logs to this format we are not promising
> dmesg stability.
> 
> The numbering stability however needs to be somewhat stable for
> the CPER log in tracefs, that's the ABI. But then that meaning
> shouldn't change if the code has to change. A new number should
> be needed if the component/location/severity or recommended
> recovery needs to be different.
> 
> But like I told Raag as well, no developer needs to invent any
> number, if they don't know just use regular log messages.
> We are not going to move all the logs towards this thing.
> Also, the location of the issue is what triggers the ID...
> it is very simple by nature. And we need to keep it simple.
> 
> > Does this lock us into a solution for all of this? I still need
> > to go through the full patch series...
> 
> Yes, please take a look to the series. All reviews are welcomed.
> 
> > 
> > The dmesg entries are generally for human debuggability. I get the
> > desire to make these easier to parse for an AI tool or generated
> > script, but we also don't want to prevent debug related changes for
> > error handling and reporting.
> 
> We are not promising this. The stable ABI is only the CPER on
> tracefs.
> 
> We need to always keep this in mind as stated in
> Documentation/core-api/printk-index.rst:
> 
> """
> The kernel messages are evolving together with the code. As a result,
> particular kernel messages are not KABI and never will be!
> """
> 
> Thanks,
> Rodrigo.
> 
> > 
> > Thanks,
> > Stuart
> > 
> > > 
> > > Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > > Assisted-by: Copilot:Opus-4.8
> > > Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> > > Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > > Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > > ---
> > > Cc: Yoni Levitt <yoni.levitt@intel.com>
> > > Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> > > Cc: Raag Jadav <raag.jadav@intel.com>
> > > Cc: Riana Tauro <riana.tauro@intel.com>
> > > ---
> > > v2: CORRECTED is still an error (Michal)
> > >     prepare to decorate dmesg with comp/loc (Michal)
> > > ---
> > >  Documentation/gpu/xe/index.rst        |   1 +
> > >  Documentation/gpu/xe/xe_sigid.rst     |  14 ++
> > >  drivers/gpu/drm/xe/Makefile           |   1 +
> > >  drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183
> > > ++++++++++++++++++++++++++
> > >  drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
> > >  drivers/gpu/drm/xe/xe_log.h           |  20 +++
> > >  6 files changed, 354 insertions(+)
> > >  create mode 100644 Documentation/gpu/xe/xe_sigid.rst
> > >  create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > >  create mode 100644 drivers/gpu/drm/xe/xe_log.c
> > >  create mode 100644 drivers/gpu/drm/xe/xe_log.h
> > > 
> > > diff --git a/Documentation/gpu/xe/index.rst
> > > b/Documentation/gpu/xe/index.rst
> > > index 665c0e93601c..0247a255f7e6 100644
> > > --- a/Documentation/gpu/xe/index.rst
> > > +++ b/Documentation/gpu/xe/index.rst
> > > @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for
> > > drm/xe
> > > is provided by
> > >     xe-drm-usage-stats.rst
> > >     xe_configfs
> > >     xe_gt_stats
> > > +   xe_sigid
> > > diff --git a/Documentation/gpu/xe/xe_sigid.rst
> > > b/Documentation/gpu/xe/xe_sigid.rst
> > > new file mode 100644
> > > index 000000000000..45d84a62f185
> > > --- /dev/null
> > > +++ b/Documentation/gpu/xe/xe_sigid.rst
> > > @@ -0,0 +1,14 @@
> > > +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> > > +
> > > +========
> > > +Xe SIGID
> > > +========
> > > +
> > > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > +   :doc: Xe Error Signatures (SIGID)
> > > +
> > > +Signature Identifiers
> > > +=====================
> > > +
> > > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > +   :internal:
> > > diff --git a/drivers/gpu/drm/xe/Makefile
> > > b/drivers/gpu/drm/xe/Makefile
> > > index 67ada1d6c2fb..7ac3954737f9 100644
> > > --- a/drivers/gpu/drm/xe/Makefile
> > > +++ b/drivers/gpu/drm/xe/Makefile
> > > @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
> > >         xe_hw_fence.o \
> > >         xe_irq.o \
> > >         xe_late_bind_fw.o \
> > > +       xe_log.o \
> > >         xe_lrc.o \
> > >         xe_mem_pool.o \
> > >         xe_migrate.o \
> > > diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > new file mode 100644
> > > index 000000000000..99717fdf74a6
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > @@ -0,0 +1,183 @@
> > > +/* SPDX-License-Identifier: MIT */
> > > +/*
> > > + * Copyright © 2026 Intel Corporation
> > > + */
> > > +
> > > +#ifndef _ABI_XE_SIGID_ABI_H_
> > > +#define _ABI_XE_SIGID_ABI_H_
> > > +
> > > +/**
> > > + * DOC: Xe Error Signatures (SIGID)
> > > + *
> > > + * What SIGID stands for
> > > + * ---------------------
> > > + *
> > > + * SIGID is short for *Signature Identifier*. A SIGID is a
> > > small,
> > > stable integer
> > > + * that names one *recognised Xe fault situation* -- nothing
> > > more.
> > > It is the
> > > + * primary handle used for triage: a SIGID maps to a human
> > > description and a
> > > + * recommended first action. A coarse first-order action is
> > > documented in-tree
> > > + * per SIGID (see "First-order action" below) so the id is
> > > actionable on its
> > > + * own; published end-user documentation refines it with finer,
> > > cross-product
> > > + * detail. The driver's only job is to emit the right SIGID next
> > > to
> > > the usual
> > > + * human-readable text.
> > > + *
> > > + * Why this exists
> > > + * ---------------
> > > + *
> > > + * Today the driver reports faults with ad-hoc ``drm_err()`` /
> > > ``xe_gt_err()``
> > > + * strings that have no stable shape. That is fine for a human
> > > reading dmesg,
> > > + * but it gives fleet tooling nothing durable to match on: the
> > > wording changes
> > > + * between releases, lines can be rate-limited or dropped under
> > > an
> > > error storm,
> > > + * and there is no consistent way to ask "which recognised fault
> > > just happened?"
> > > + * A SIGID answers exactly that one question, identically across
> > > driver and
> > > + * firmware versions, and (eventually) across other Intel
> > > devices in
> > > a node.
> > > + *
> > > + * What a SIGID is (and is not)
> > > + * ----------------------------
> > > + *
> > > + * A SIGID names *which situation* is being reported. It
> > > deliberately does not
> > > + * encode the detailed reason or the outcome. Those are carried
> > > alongside it::
> > > + *
> > > + *   SIGID    -> which recognised situation is being reported
> > > + *   severity -> how serious this instance is (see below -- not
> > > fixed per SIGID)
> > > + *   errno    -> the failing operation's error, shown with %pe
> > > + *   message  -> free-form human-readable context
> > > + *
> > > + * Severity is independent of the SIGID. The same situation can
> > > be
> > > reported at
> > > + * different severities depending on the instance and the
> > > recovery
> > > taken, so a
> > > + * SIGID is never tied to one severity; the reporting site
> > > chooses
> > > it by calling
> > > + * the matching xe_log_*() helper (see xe_log.h).
> > > + *
> > > + * How to pick a SIGID (the uniqueness rule)
> > > + * -----------------------------------------
> > > + *
> > > + * Pick per *report site*, not per incident. Each site emits the
> > > single most
> > > + * specific recognised situation *for that site* -- so the
> > > question
> > > is never
> > > + * "classify this whole failure", it is "what does this site
> > > detect?", which has
> > > + * one answer. A single underlying failure therefore
> > > legitimately
> > > produces a
> > > + * *chain* of reports from different layers, each with its own
> > > SIGID
> > > -- e.g. a
> > > + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW
> > > by
> > > the firmware
> > > + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset
> > > path,
> > > and an
> > > + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain
> > > lets triage
> > > + * follow a fault from origin to final effect; it is not a
> > > duplicate.
> > > + *
> > > + * If a site does not match any defined situation, keep using
> > > the
> > > ordinary
> > > + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a
> > > SIGID: a wrong
> > > + * or over-broad classification is harder to retire than a
> > > missing
> > > one. When a
> > > + * new situation is genuinely worth triaging, add it to the list
> > > below.
> > > + *
> > > + * Scope: software-emitted signatures only
> > > + * ---------------------------------------
> > > + *
> > > + * This header enumerates only the situations that the *driver
> > > itself* detects
> > > + * and reports from software: probe abort, wedged,
> > > survivability,
> > > driver-
> > > + * detected firmware failures, engine TDR, memory faults and
> > > IO/bus
> > > faults.
> > > + * These are the only values the driver assigns.
> > > + *
> > > + * Signatures that *originate* in firmware or hardware are a
> > > different thing:
> > > + * they are produced and identified by the firmware or the
> > > hardware
> > > itself
> > > + * (e.g. via their own records or error counters), and the
> > > driver
> > > merely logs
> > > + * them as they are given to us. They are deliberately *not*
> > > enumerated here --
> > > + * minting a driver-side id for a firmware/hardware-reported
> > > error
> > > would only
> > > + * duplicate an identifier the reporting layer already owns. The
> > > two
> > > + * driver-detected firmware situations below
> > > (%XE_SIGID_RUNTIME_FW,
> > > + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that
> > > *the
> > > driver*
> > > + * observed a firmware problem, not a signature reported by the
> > > firmware.
> > > + *
> > > + * Numbering
> > > + * ---------
> > > + *
> > > + * SIGIDs are a single flat list numbered sequentially within
> > > the
> > > assigned range,
> > > + * in the order the situations were introduced. Values are
> > > stable:
> > > once assigned
> > > + * they are only ever appended, never renumbered or reused.
> > > + *
> > > + * A retired situation is deprecated in place, never re-
> > > purposed.
> > > + *
> > > + * First-order action (resolution buckets)
> > > + * ---------------------------------------
> > > + *
> > > + * So that a SIGID is actionable on its own, each one is tagged
> > > with
> > > a coarse
> > > + * *resolution bucket*: the first thing an operator should do on
> > > seeing it. The
> > > + * bucket is a stable, driver-owned hint; external documentation
> > > may
> > > refine it,
> > > + * but the in-tree value always stands on its own. Every new
> > > SIGID
> > > must pick a
> > > + * bucket, which forces the question "what should someone do
> > > about
> > > this?" to be
> > > + * answered up front. The buckets are::
> > > + *
> > > + *   COLLECT  -- capture logs and open a bug report
> > > + *   RETRY    -- transient or already recovered; watch for
> > > recurrence
> > > + *   UPDATE   -- a firmware update / flash is required
> > > + *   RECOVER  -- an explicit recovery step is needed (rebind,
> > > bus
> > > reset)
> > > + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
> > > + *
> > > + * The bucket is documentation only -- it is recorded per SIGID
> > > in
> > > the enum
> > > + * kernel-doc below and is not printed on the (deliberately
> > > lean)
> > > dmesg line.
> > > + *
> > > + * When to use SIGID logging
> > > + * -------------------------
> > > + *
> > > + * The xe_log_*() helpers are for these recognised fault
> > > situations
> > > only --
> > > + * important, operator-relevant faults and events. They are not
> > > a
> > > replacement
> > > + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off
> > > diagnostics;
> > > + * using them for ordinary logging would dilute the fault
> > > stream.
> > > Not every
> > > + * ``xe_err()`` needs to become a SIGID report -- only those
> > > that
> > > correspond to
> > > + * a published situation.
> > > + *
> > > + * dmesg vs. the machine record
> > > + * ----------------------------
> > > + *
> > > + * The dmesg line stays close to a normal xe error message so it
> > > remains
> > > + * readable for admins; the only stable, machine-matchable token
> > > on
> > > it is
> > > + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI:
> > > the
> > > surrounding
> > > + * text may change freely, and lines may be dropped. The durable
> > > record for
> > > + * tooling is the CPER record carrying the same SIGID
> > > (generation is
> > > a planned
> > > + * follow-up).

Ok I realize I'm coming late to the party here - I just haven't had the
time to review this in detail. I really don't like having this ABI-
adjacent implementation. It feels like we will be on the hook for
maintaining things in the future that will limit our ability to
implement changes and debug. I get the notes that Rodrigo has above,
but this just feels like the wrong approach to me.

That said, I don't want to block the work here. I know we have some
users looking for this for their own debug.

You have "dmesg is not ABI" here which is a start. What happens if we
decide to drop one of these messages? Is it only the ID itself that we
want to be stable and monotonically incrementing? Or is the message
itself supposed to be stable? If we drop all references to a particular
ID is that ok? What if we have 10s of IDs or more that have no use in
the future and we move on to the next section? We don't care about
cleanup of this kind of thing? Or the line above about "dmesg is not
ABI" means we can really do whatever we want with it?

Thanks,
Stuart

> > > + */
> > > +
> > > +/*
> > > + * Top level Intel Error Signature Identifiers.
> > > + */
> > > +#define INTEL_SIGID_INVALID                    0
> > > +#define INTEL_SIGID_GPU_START                  100
> > > +#define INTEL_SIGID_GPU_END                    999
> > > +
> > > +#define INTEL_SIGID_GPU_XE_START               100
> > > +#define INTEL_SIGID_GPU_XE_END                 299
> > > +
> > > +#define INTEL_SIGID_GPU_XE_SOFTWARE_START      100
> > > +#define INTEL_SIGID_GPU_XE_SOFTWARE_END                199
> > > +#define INTEL_SIGID_GPU_XE_HARDWARE_START      200
> > > +#define INTEL_SIGID_GPU_XE_HARDWARE_END                299
> > > +
> > > +/**
> > > + * enum xe_sigid - Stable Xe Error Signature Identifiers
> > > (SIGID).
> > > + * @XE_SIGID_SW: Software component failure. [COLLECT]
> > > + * @XE_SIGID_PROBE: Device probe/bind was aborted. [COLLECT]
> > > + * @XE_SIGID_WEDGED: Device was declared wedged and is no longer
> > > usable. [RECOVER]
> > > + * @XE_SIGID_SURVIVABILITY: Device entered survivability mode.
> > > [UPDATE]
> > > + * @XE_SIGID_RUNTIME_FW: Driver-detected runtime firmware
> > > failure,
> > > GuC/HuC/GSC. [RETRY]
> > > + * @XE_SIGID_DEVICE_FW: Driver-detected device firmware failure,
> > > PCODE/sysctrl. [RETRY]
> > > + * @XE_SIGID_GT_TDR: Engine hang / timeout detection and
> > > recovery
> > > (reset). [RETRY]
> > > + * @XE_SIGID_MEM_FAULT: VM bind, page fault or GTT fault.
> > > [COLLECT]
> > > + * @XE_SIGID_IO_BUS: Runtime PCIe / IOMMU / MMIO access fault.
> > > [RECOVER]
> > > + *
> > > + * The situations the driver detects and reports in software.
> > > Values
> > > are
> > > + * numbered sequentially, are only ever appended, and are never
> > > renumbered or
> > > + * reused. The tag in brackets is the default resolution bucket
> > > (see
> > > the `Xe
> > > + * Error Signatures (SIGID)`_ section).
> > > + *
> > > + * Firmware- and hardware-originated signatures are not listed
> > > here;
> > > they are
> > > + * logged as reported by those layers.
> > > + */
> > > +enum xe_sigid {
> > > +       XE_SIGID_SW                     =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START,
> > > +       XE_SIGID_PROBE                  =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 1,
> > > +       XE_SIGID_WEDGED                 =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 2,
> > > +       XE_SIGID_SURVIVABILITY          =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 3,
> > > +       XE_SIGID_RUNTIME_FW             =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 4,
> > > +       XE_SIGID_DEVICE_FW              =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 5,
> > > +       XE_SIGID_GT_TDR                 =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 6,
> > > +       XE_SIGID_MEM_FAULT              =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 7,
> > > +       XE_SIGID_IO_BUS                 =
> > > INTEL_SIGID_GPU_XE_SOFTWARE_START + 8,
> > > +};
> > > +
> > > +#endif
> > > diff --git a/drivers/gpu/drm/xe/xe_log.c
> > > b/drivers/gpu/drm/xe/xe_log.c
> > > new file mode 100644
> > > index 000000000000..70a41bdf1a01
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/xe/xe_log.c
> > > @@ -0,0 +1,135 @@
> > > +// SPDX-License-Identifier: MIT
> > > +/*
> > > + * Copyright © 2026 Intel Corporation
> > > + */
> > > +
> > > +#include "xe_log.h"
> > > +#include "xe_printk.h"
> > > +
> > > +static void log_emit_cper(struct pci_dev *pdev, int cper_sev,
> > > enum
> > > xe_sigid sigid,
> > > +                         u32 component, u32 location, const void
> > > *data, size_t len,
> > > +                         struct va_format *vaf)
> > > +{
> > > +       /* TODO */
> > > +}
> > > +
> > > +static bool is_hw_sigid(enum xe_sigid sigid)
> > > +{
> > > +       return (int)sigid >= INTEL_SIGID_GPU_XE_HARDWARE_START;
> > > +}
> > > +
> > > +static bool is_sev_error(int cper_sev)
> > > +{
> > > +       return cper_sev != CPER_SEV_INFORMATIONAL;
> > > +}
> > > +
> > > +static const char *log_hwe_prefix(int cper_sev, enum xe_sigid
> > > sigid)
> > > +{
> > > +       return is_sev_error(cper_sev) && is_hw_sigid(sigid) ?
> > > HW_ERR
> > > : "";
> > > +}
> > > +
> > > +static const char *log_sev_prefix(int cper_sev)
> > > +{
> > > +       switch (cper_sev) {
> > > +       case CPER_SEV_FATAL:
> > > +               return "FATAL ";
> > > +       case CPER_SEV_RECOVERABLE:
> > > +               return "";
> > > +       case CPER_SEV_CORRECTED:
> > > +               return "CORRECTED ";
> > > +       default:
> > > +               return "";
> > > +       }
> > > +}
> > > +
> > > +#define __LOG_DRM_PRINTK_FMT(fmt, args...)     "[drm] " fmt,
> > > ##args
> > > +#define __LOG_DRM_PRINTK_ERR_FMT(fmt,
> > > args...) __LOG_DRM_PRINTK_FMT("*ERROR* " fmt, args)
> > > +
> > > +static void log_dmesg_vprintk(struct pci_dev *pdev, int
> > > cper_sev,
> > > struct va_format *vaf)
> > > +{
> > > +       if (cper_sev == CPER_SEV_INFORMATIONAL)
> > > +               pci_info(pdev, __LOG_DRM_PRINTK_FMT("%pV", vaf));
> > > +       else
> > > +               pci_err(pdev, __LOG_DRM_PRINTK_ERR_FMT("%pV",
> > > vaf));
> > > +}
> > > +
> > > +static void log_dmesg_printf(struct pci_dev *pdev, int cper_sev,
> > > const char *fmt, ...)
> > > +{
> > > +       struct va_format vaf;
> > > +       va_list args;
> > > +
> > > +       va_start(args, fmt);
> > > +       vaf.fmt = fmt;
> > > +       vaf.va = &args;
> > > +
> > > +       log_dmesg_vprintk(pdev, cper_sev, &vaf);
> > > +
> > > +       va_end(args);
> > > +}
> > > +
> > > +static void log_emit_dmesg(struct pci_dev *pdev, int cper_sev,
> > > enum
> > > xe_sigid sigid,
> > > +                          u32 component, u32 location, const
> > > void
> > > *data, size_t len,
> > > +                          struct va_format *vaf)
> > > +{
> > > +       const char *hwe_prefix = log_hwe_prefix(cper_sev, sigid);
> > > +       const char *sev_prefix = log_sev_prefix(cper_sev);
> > > +
> > > +       /* TODO: add component/location details */
> > > +
> > > +       if (IS_ERR(data))
> > > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u
> > > %s(%pe)
> > > %s%pV",
> > > +                                sigid, sev_prefix, data,
> > > hwe_prefix,
> > > vaf);
> > > +       else if (data && len)
> > > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u
> > > %s(%*phN)
> > > %s%pV",
> > > +                                sigid, sev_prefix, (int)len,
> > > data,
> > > hwe_prefix, vaf);
> > > +       else
> > > +               log_dmesg_printf(pdev, cper_sev, "SIGID=%u
> > > %s%s%pV",
> > > +                                sigid, sev_prefix, hwe_prefix,
> > > vaf);
> > > +}
> > > +
> > > +/**
> > > + * xe_log_emit() - Emit a structured SIGID log entry
> > > + * @pdev: the &pci_dev device
> > > + * @cper_sev: CPER severity (CPER_SEV_FATAL,
> > > CPER_SEV_RECOVERABLE,
> > > ...)
> > > + * @sigid: signature identifier, see &enum xe_sigid
> > > + * @component: component identifer
> > > + * @location: location details of the @component
> > > + * @data: pointer to the additional details, or ERR_PTR, or NULL
> > > if
> > > not applicable
> > > + * @len: length of the @data in bytes, or 0 if not applicable
> > > + * @fmt: printf-style format string
> > > + * @...: format arguments
> > > + *
> > > + * Emits a dmesg line that includes a single stable, machine-
> > > matchable token
> > > + * ``SIGID=<n>`` followed by the optional severity token (like
> > > ``FATAL``) and,
> > > + * when @data pointer is set, either the error printed with %pe
> > > or a
> > > packed hex
> > > + * dump of the @data binary blob. The dmesg line will also
> > > include
> > > printf-style
> > > + * text message.
> > > + *
> > > + * Note that the full dmesg line, with the free text message, is
> > > only a debugging
> > > + * aid, not an interface! Only the ``SIGID=<n>`` token is stable
> > > there.
> > > + * The durable machine record is the CPER carrying the same
> > > SIGID.
> > > + *
> > > + * Note: generation of the CPER record is a planned follow-up.
> > > + *
> > > + * Examples::
> > > + *
> > > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=104 FATAL (-
> > > EPROTO)
> > > Invalid GuC reply
> > > + *   <3> xe 0000:03:00.0: [drm] *ERROR* SIGID=106 (-ETIMEDOUT)
> > > Engine 'rcs0' hung
> > > + *   <6> xe 0000:03:00.0: [drm] *ERROR* SIGID=103 In
> > > survivability
> > > mode
> > > + */
> > > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum
> > > xe_sigid
> > > sigid,
> > > +                u32 component, u32 location, const void *data,
> > > size_t len,
> > > +                const char *fmt, ...)
> > > +{
> > > +       struct va_format vaf;
> > > +       va_list args;
> > > +
> > > +       va_start(args, fmt);
> > > +       vaf.fmt = fmt;
> > > +       vaf.va = &args;
> > > +
> > > +       log_emit_dmesg(pdev, cper_sev, sigid, component,
> > > location,
> > > data, len, &vaf);
> > > +       log_emit_cper(pdev, cper_sev, sigid, component, location,
> > > data, len, &vaf);
> > > +
> > > +       va_end(args);
> > > +}
> > > diff --git a/drivers/gpu/drm/xe/xe_log.h
> > > b/drivers/gpu/drm/xe/xe_log.h
> > > new file mode 100644
> > > index 000000000000..d475e816ee0b
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/xe/xe_log.h
> > > @@ -0,0 +1,20 @@
> > > +/* SPDX-License-Identifier: MIT */
> > > +/*
> > > + * Copyright © 2026 Intel Corporation
> > > + */
> > > +
> > > +#ifndef _XE_LOG_H_
> > > +#define _XE_LOG_H_
> > > +
> > > +#include <linux/cper.h>
> > > +
> > > +#include "abi/xe_sigid_abi.h"
> > > +
> > > +struct pci_dev;
> > > +
> > > +__printf(8, 9)
> > > +void xe_log_emit(struct pci_dev *pdev, int cper_sev, enum
> > > xe_sigid
> > > sigid,
> > > +                u32 component, u32 location, const void *data,
> > > size_t len,
> > > +                const char *fmt, ...);
> > > +
> > > +#endif
> > 

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Michal Wajdeczko]

On 8/6/2026 12:24 AM, Summers, Stuart wrote:
> On Tue, 2026-08-04 at 21:36 -0400, Rodrigo Vivi wrote:
>> On Tue, Aug 04, 2026 at 05:21:05PM -0400, Summers, Stuart wrote:
>>> On Thu, 2026-07-30 at 17:20 +0200, Michal Wajdeczko wrote:
>>>> From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
>>>>
>>>> Today the driver reports faults with ad-hoc drm_err()/xe_gt_err()
>>>> strings that have no stable shape. That is readable for a human,
>>>> but
>>>> it
>>>> gives fleet tooling nothing durable to match on: the wording
>>>> changes
>>>> between releases, lines can be rate-limited or dropped under an
>>>> error
>>>> storm, and there is no consistent way to ask "which recognised
>>>> fault
>>>> just happened?".
>>>>
>>>> Introduce a signature identifier (SIGID): a small, stable integer
>>>> that
>>>> names one recognised Xe fault situation and serves as the primary
>>>> handle
>>>> for triage. A SIGID maps, through published end-user
>>>> documentation,
>>>> to a
>>>> description and a recommended action; the driver only has to emit
>>>> the
>>>> right SIGID next to the usual human-readable text.
>>>
>>> I'm a little worried
>>
>> I understand your feeling. We've been all through that:
>>
>> https://lore.kernel.org/intel-xe/amqhoFzQaf1HsuFq@intel.com/
>>
>>> we're introducing some ABI with this that isn't
>>> really maintainable in the long term:
>>
>> I understand the fear and indeed the first proposals I got was
>> unmaintainable. My first record of pushing back on having something
>> like this was November last year.
>>
>> But I respectfully disagree here. This latest version is imho
>> organized and concise.
>>
>>> we might decide to change the
>>> flow or change the way an error is reported or the situation that
>>> triggers this error from firmware or hardware might change for some
>>> reason.
>>
>> You are right, dmesg is not ABI and it will never be. these logs
>> are aimed for developers and developers are free to change them as
>> needed. This was a big counter-requirement I gave to the original
>> idea.
>>
>> We are not moving all the logs to this format we are not promising
>> dmesg stability.
>>
>> The numbering stability however needs to be somewhat stable for
>> the CPER log in tracefs, that's the ABI. But then that meaning
>> shouldn't change if the code has to change. A new number should
>> be needed if the component/location/severity or recommended
>> recovery needs to be different.
>>
>> But like I told Raag as well, no developer needs to invent any
>> number, if they don't know just use regular log messages.
>> We are not going to move all the logs towards this thing.
>> Also, the location of the issue is what triggers the ID...
>> it is very simple by nature. And we need to keep it simple.
>>
>>> Does this lock us into a solution for all of this? I still need
>>> to go through the full patch series...
>>
>> Yes, please take a look to the series. All reviews are welcomed.
>>
>>>
>>> The dmesg entries are generally for human debuggability. I get the
>>> desire to make these easier to parse for an AI tool or generated
>>> script, but we also don't want to prevent debug related changes for
>>> error handling and reporting.
>>
>> We are not promising this. The stable ABI is only the CPER on
>> tracefs.
>>
>> We need to always keep this in mind as stated in
>> Documentation/core-api/printk-index.rst:
>>
>> """
>> The kernel messages are evolving together with the code. As a result,
>> particular kernel messages are not KABI and never will be!
>> """
>>
>> Thanks,
>> Rodrigo.
>>
>>>
>>> Thanks,
>>> Stuart
>>>
>>>>
>>>> Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
>>>> Assisted-by: Copilot:Opus-4.8
>>>> Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
>>>> Co-developed-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
>>>> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
>>>> ---
>>>> Cc: Yoni Levitt <yoni.levitt@intel.com>
>>>> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
>>>> Cc: Raag Jadav <raag.jadav@intel.com>
>>>> Cc: Riana Tauro <riana.tauro@intel.com>
>>>> ---
>>>> v2: CORRECTED is still an error (Michal)
>>>>     prepare to decorate dmesg with comp/loc (Michal)
>>>> ---
>>>>  Documentation/gpu/xe/index.rst        |   1 +
>>>>  Documentation/gpu/xe/xe_sigid.rst     |  14 ++
>>>>  drivers/gpu/drm/xe/Makefile           |   1 +
>>>>  drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183
>>>> ++++++++++++++++++++++++++
>>>>  drivers/gpu/drm/xe/xe_log.c           | 135 +++++++++++++++++++
>>>>  drivers/gpu/drm/xe/xe_log.h           |  20 +++
>>>>  6 files changed, 354 insertions(+)
>>>>  create mode 100644 Documentation/gpu/xe/xe_sigid.rst
>>>>  create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>>>  create mode 100644 drivers/gpu/drm/xe/xe_log.c
>>>>  create mode 100644 drivers/gpu/drm/xe/xe_log.h
>>>>
>>>> diff --git a/Documentation/gpu/xe/index.rst
>>>> b/Documentation/gpu/xe/index.rst
>>>> index 665c0e93601c..0247a255f7e6 100644
>>>> --- a/Documentation/gpu/xe/index.rst
>>>> +++ b/Documentation/gpu/xe/index.rst
>>>> @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for
>>>> drm/xe
>>>> is provided by
>>>>     xe-drm-usage-stats.rst
>>>>     xe_configfs
>>>>     xe_gt_stats
>>>> +   xe_sigid
>>>> diff --git a/Documentation/gpu/xe/xe_sigid.rst
>>>> b/Documentation/gpu/xe/xe_sigid.rst
>>>> new file mode 100644
>>>> index 000000000000..45d84a62f185
>>>> --- /dev/null
>>>> +++ b/Documentation/gpu/xe/xe_sigid.rst
>>>> @@ -0,0 +1,14 @@
>>>> +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
>>>> +
>>>> +========
>>>> +Xe SIGID
>>>> +========
>>>> +
>>>> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>>> +   :doc: Xe Error Signatures (SIGID)
>>>> +
>>>> +Signature Identifiers
>>>> +=====================
>>>> +
>>>> +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>>> +   :internal:
>>>> diff --git a/drivers/gpu/drm/xe/Makefile
>>>> b/drivers/gpu/drm/xe/Makefile
>>>> index 67ada1d6c2fb..7ac3954737f9 100644
>>>> --- a/drivers/gpu/drm/xe/Makefile
>>>> +++ b/drivers/gpu/drm/xe/Makefile
>>>> @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
>>>>         xe_hw_fence.o \
>>>>         xe_irq.o \
>>>>         xe_late_bind_fw.o \
>>>> +       xe_log.o \
>>>>         xe_lrc.o \
>>>>         xe_mem_pool.o \
>>>>         xe_migrate.o \
>>>> diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>>> b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>>> new file mode 100644
>>>> index 000000000000..99717fdf74a6
>>>> --- /dev/null
>>>> +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
>>>> @@ -0,0 +1,183 @@
>>>> +/* SPDX-License-Identifier: MIT */
>>>> +/*
>>>> + * Copyright © 2026 Intel Corporation
>>>> + */
>>>> +
>>>> +#ifndef _ABI_XE_SIGID_ABI_H_
>>>> +#define _ABI_XE_SIGID_ABI_H_
>>>> +
>>>> +/**
>>>> + * DOC: Xe Error Signatures (SIGID)
>>>> + *
>>>> + * What SIGID stands for
>>>> + * ---------------------
>>>> + *
>>>> + * SIGID is short for *Signature Identifier*. A SIGID is a
>>>> small,
>>>> stable integer
>>>> + * that names one *recognised Xe fault situation* -- nothing
>>>> more.
>>>> It is the
>>>> + * primary handle used for triage: a SIGID maps to a human
>>>> description and a
>>>> + * recommended first action. A coarse first-order action is
>>>> documented in-tree
>>>> + * per SIGID (see "First-order action" below) so the id is
>>>> actionable on its
>>>> + * own; published end-user documentation refines it with finer,
>>>> cross-product
>>>> + * detail. The driver's only job is to emit the right SIGID next
>>>> to
>>>> the usual
>>>> + * human-readable text.
>>>> + *
>>>> + * Why this exists
>>>> + * ---------------
>>>> + *
>>>> + * Today the driver reports faults with ad-hoc ``drm_err()`` /
>>>> ``xe_gt_err()``
>>>> + * strings that have no stable shape. That is fine for a human
>>>> reading dmesg,
>>>> + * but it gives fleet tooling nothing durable to match on: the
>>>> wording changes
>>>> + * between releases, lines can be rate-limited or dropped under
>>>> an
>>>> error storm,
>>>> + * and there is no consistent way to ask "which recognised fault
>>>> just happened?"
>>>> + * A SIGID answers exactly that one question, identically across
>>>> driver and
>>>> + * firmware versions, and (eventually) across other Intel
>>>> devices in
>>>> a node.
>>>> + *
>>>> + * What a SIGID is (and is not)
>>>> + * ----------------------------
>>>> + *
>>>> + * A SIGID names *which situation* is being reported. It
>>>> deliberately does not
>>>> + * encode the detailed reason or the outcome. Those are carried
>>>> alongside it::
>>>> + *
>>>> + *   SIGID    -> which recognised situation is being reported
>>>> + *   severity -> how serious this instance is (see below -- not
>>>> fixed per SIGID)
>>>> + *   errno    -> the failing operation's error, shown with %pe
>>>> + *   message  -> free-form human-readable context
>>>> + *
>>>> + * Severity is independent of the SIGID. The same situation can
>>>> be
>>>> reported at
>>>> + * different severities depending on the instance and the
>>>> recovery
>>>> taken, so a
>>>> + * SIGID is never tied to one severity; the reporting site
>>>> chooses
>>>> it by calling
>>>> + * the matching xe_log_*() helper (see xe_log.h).
>>>> + *
>>>> + * How to pick a SIGID (the uniqueness rule)
>>>> + * -----------------------------------------
>>>> + *
>>>> + * Pick per *report site*, not per incident. Each site emits the
>>>> single most
>>>> + * specific recognised situation *for that site* -- so the
>>>> question
>>>> is never
>>>> + * "classify this whole failure", it is "what does this site
>>>> detect?", which has
>>>> + * one answer. A single underlying failure therefore
>>>> legitimately
>>>> produces a
>>>> + * *chain* of reports from different layers, each with its own
>>>> SIGID
>>>> -- e.g. a
>>>> + * GuC communication failure is reported as %XE_SIGID_RUNTIME_FW
>>>> by
>>>> the firmware
>>>> + * path, the failed recovery as %XE_SIGID_GT_TDR by the reset
>>>> path,
>>>> and an
>>>> + * aborted bind as %XE_SIGID_PROBE by the probe path. That chain
>>>> lets triage
>>>> + * follow a fault from origin to final effect; it is not a
>>>> duplicate.
>>>> + *
>>>> + * If a site does not match any defined situation, keep using
>>>> the
>>>> ordinary
>>>> + * ``xe_err()`` / ``xe_gt_err()`` logging rather than forcing a
>>>> SIGID: a wrong
>>>> + * or over-broad classification is harder to retire than a
>>>> missing
>>>> one. When a
>>>> + * new situation is genuinely worth triaging, add it to the list
>>>> below.
>>>> + *
>>>> + * Scope: software-emitted signatures only
>>>> + * ---------------------------------------
>>>> + *
>>>> + * This header enumerates only the situations that the *driver
>>>> itself* detects
>>>> + * and reports from software: probe abort, wedged,
>>>> survivability,
>>>> driver-
>>>> + * detected firmware failures, engine TDR, memory faults and
>>>> IO/bus
>>>> faults.
>>>> + * These are the only values the driver assigns.
>>>> + *
>>>> + * Signatures that *originate* in firmware or hardware are a
>>>> different thing:
>>>> + * they are produced and identified by the firmware or the
>>>> hardware
>>>> itself
>>>> + * (e.g. via their own records or error counters), and the
>>>> driver
>>>> merely logs
>>>> + * them as they are given to us. They are deliberately *not*
>>>> enumerated here --
>>>> + * minting a driver-side id for a firmware/hardware-reported
>>>> error
>>>> would only
>>>> + * duplicate an identifier the reporting layer already owns. The
>>>> two
>>>> + * driver-detected firmware situations below
>>>> (%XE_SIGID_RUNTIME_FW,
>>>> + * %XE_SIGID_DEVICE_FW) are software signatures: they mark that
>>>> *the
>>>> driver*
>>>> + * observed a firmware problem, not a signature reported by the
>>>> firmware.
>>>> + *
>>>> + * Numbering
>>>> + * ---------
>>>> + *
>>>> + * SIGIDs are a single flat list numbered sequentially within
>>>> the
>>>> assigned range,
>>>> + * in the order the situations were introduced. Values are
>>>> stable:
>>>> once assigned
>>>> + * they are only ever appended, never renumbered or reused.
>>>> + *
>>>> + * A retired situation is deprecated in place, never re-
>>>> purposed.
>>>> + *
>>>> + * First-order action (resolution buckets)
>>>> + * ---------------------------------------
>>>> + *
>>>> + * So that a SIGID is actionable on its own, each one is tagged
>>>> with
>>>> a coarse
>>>> + * *resolution bucket*: the first thing an operator should do on
>>>> seeing it. The
>>>> + * bucket is a stable, driver-owned hint; external documentation
>>>> may
>>>> refine it,
>>>> + * but the in-tree value always stands on its own. Every new
>>>> SIGID
>>>> must pick a
>>>> + * bucket, which forces the question "what should someone do
>>>> about
>>>> this?" to be
>>>> + * answered up front. The buckets are::
>>>> + *
>>>> + *   COLLECT  -- capture logs and open a bug report
>>>> + *   RETRY    -- transient or already recovered; watch for
>>>> recurrence
>>>> + *   UPDATE   -- a firmware update / flash is required
>>>> + *   RECOVER  -- an explicit recovery step is needed (rebind,
>>>> bus
>>>> reset)
>>>> + *   IGNORE   -- ignore if the SIGID severity is INFORMATIONAL
>>>> + *
>>>> + * The bucket is documentation only -- it is recorded per SIGID
>>>> in
>>>> the enum
>>>> + * kernel-doc below and is not printed on the (deliberately
>>>> lean)
>>>> dmesg line.
>>>> + *
>>>> + * When to use SIGID logging
>>>> + * -------------------------
>>>> + *
>>>> + * The xe_log_*() helpers are for these recognised fault
>>>> situations
>>>> only --
>>>> + * important, operator-relevant faults and events. They are not
>>>> a
>>>> replacement
>>>> + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-off
>>>> diagnostics;
>>>> + * using them for ordinary logging would dilute the fault
>>>> stream.
>>>> Not every
>>>> + * ``xe_err()`` needs to become a SIGID report -- only those
>>>> that
>>>> correspond to
>>>> + * a published situation.
>>>> + *
>>>> + * dmesg vs. the machine record
>>>> + * ----------------------------
>>>> + *
>>>> + * The dmesg line stays close to a normal xe error message so it
>>>> remains
>>>> + * readable for admins; the only stable, machine-matchable token
>>>> on
>>>> it is
>>>> + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an ABI:
>>>> the
>>>> surrounding
>>>> + * text may change freely, and lines may be dropped. The durable
>>>> record for
>>>> + * tooling is the CPER record carrying the same SIGID
>>>> (generation is
>>>> a planned
>>>> + * follow-up).
> 
> Ok I realize I'm coming late to the party here - I just haven't had the

(no worries, I was late too)

> time to review this in detail. I really don't like having this ABI-
> adjacent implementation. It feels like we will be on the hook for
> maintaining things in the future that will limit our ability to
> implement changes and debug. I get the notes that Rodrigo has above,
> but this just feels like the wrong approach to me.
> 
> That said, I don't want to block the work here. I know we have some
> users looking for this for their own debug.
> 
> You have "dmesg is not ABI" here which is a start. What happens if we
> decide to drop one of these messages? 

we don't require any use of xe_log() to be permanent (see below)
it can changed or dropped or replaced back with xe_err() any time.

> Is it only the ID itself that we
> want to be stable and monotonically incrementing? 

correct, just use of the same SIGID in the log will always mean the same

> Or is the message
> itself supposed to be stable? 

message can be changed any time, like in regular xe_err()

it is just an additional hint for debug (together with SEVERITY
and reported errno)

>If we drop all references to a particular
> ID is that ok? 

yes, if the ID is no longer applicable
and this was already stated in DOC

>What if we have 10s of IDs or more that have no use in
> the future and we move on to the next section? We don't care about
> cleanup of this kind of thing? 

legacy SIGIDs stays forever, there will be no ID value reuse
(also see DOC) but due to the way they are defined, it is unlikely
that we will drop them

> Or the line above about "dmesg is not
> ABI" means we can really do whatever we want with it?

I assume the only new requirement for us would be that we
should not drop all xe_logs for any SIGID which is still
applicable (and was not replaced with other SIGID)

> 
> Thanks,
> Stuart
> 

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Summers, Stuart]

On Thu, 2026-08-06 at 13:31 +0200, Michal Wajdeczko wrote:
> 
> 
> On 8/6/2026 12:24 AM, Summers, Stuart wrote:
> > On Tue, 2026-08-04 at 21:36 -0400, Rodrigo Vivi wrote:
> > > On Tue, Aug 04, 2026 at 05:21:05PM -0400, Summers, Stuart wrote:
> > > > On Thu, 2026-07-30 at 17:20 +0200, Michal Wajdeczko wrote:
> > > > > From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > > > > 
> > > > > Today the driver reports faults with ad-hoc
> > > > > drm_err()/xe_gt_err()
> > > > > strings that have no stable shape. That is readable for a
> > > > > human,
> > > > > but
> > > > > it
> > > > > gives fleet tooling nothing durable to match on: the wording
> > > > > changes
> > > > > between releases, lines can be rate-limited or dropped under
> > > > > an
> > > > > error
> > > > > storm, and there is no consistent way to ask "which
> > > > > recognised
> > > > > fault
> > > > > just happened?".
> > > > > 
> > > > > Introduce a signature identifier (SIGID): a small, stable
> > > > > integer
> > > > > that
> > > > > names one recognised Xe fault situation and serves as the
> > > > > primary
> > > > > handle
> > > > > for triage. A SIGID maps, through published end-user
> > > > > documentation,
> > > > > to a
> > > > > description and a recommended action; the driver only has to
> > > > > emit
> > > > > the
> > > > > right SIGID next to the usual human-readable text.
> > > > 
> > > > I'm a little worried
> > > 
> > > I understand your feeling. We've been all through that:
> > > 
> > > https://lore.kernel.org/intel-xe/amqhoFzQaf1HsuFq@intel.com/
> > > 
> > > > we're introducing some ABI with this that isn't
> > > > really maintainable in the long term:
> > > 
> > > I understand the fear and indeed the first proposals I got was
> > > unmaintainable. My first record of pushing back on having
> > > something
> > > like this was November last year.
> > > 
> > > But I respectfully disagree here. This latest version is imho
> > > organized and concise.
> > > 
> > > > we might decide to change the
> > > > flow or change the way an error is reported or the situation
> > > > that
> > > > triggers this error from firmware or hardware might change for
> > > > some
> > > > reason.
> > > 
> > > You are right, dmesg is not ABI and it will never be. these logs
> > > are aimed for developers and developers are free to change them
> > > as
> > > needed. This was a big counter-requirement I gave to the original
> > > idea.
> > > 
> > > We are not moving all the logs to this format we are not
> > > promising
> > > dmesg stability.
> > > 
> > > The numbering stability however needs to be somewhat stable for
> > > the CPER log in tracefs, that's the ABI. But then that meaning
> > > shouldn't change if the code has to change. A new number should
> > > be needed if the component/location/severity or recommended
> > > recovery needs to be different.
> > > 
> > > But like I told Raag as well, no developer needs to invent any
> > > number, if they don't know just use regular log messages.
> > > We are not going to move all the logs towards this thing.
> > > Also, the location of the issue is what triggers the ID...
> > > it is very simple by nature. And we need to keep it simple.
> > > 
> > > > Does this lock us into a solution for all of this? I still need
> > > > to go through the full patch series...
> > > 
> > > Yes, please take a look to the series. All reviews are welcomed.
> > > 
> > > > 
> > > > The dmesg entries are generally for human debuggability. I get
> > > > the
> > > > desire to make these easier to parse for an AI tool or
> > > > generated
> > > > script, but we also don't want to prevent debug related changes
> > > > for
> > > > error handling and reporting.
> > > 
> > > We are not promising this. The stable ABI is only the CPER on
> > > tracefs.
> > > 
> > > We need to always keep this in mind as stated in
> > > Documentation/core-api/printk-index.rst:
> > > 
> > > """
> > > The kernel messages are evolving together with the code. As a
> > > result,
> > > particular kernel messages are not KABI and never will be!
> > > """
> > > 
> > > Thanks,
> > > Rodrigo.
> > > 
> > > > 
> > > > Thanks,
> > > > Stuart
> > > > 
> > > > > 
> > > > > Signed-off-by: Mallesh Koujalagi
> > > > > <mallesh.koujalagi@intel.com>
> > > > > Assisted-by: Copilot:Opus-4.8
> > > > > Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> > > > > Co-developed-by: Michal Wajdeczko
> > > > > <michal.wajdeczko@intel.com>
> > > > > Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > > > > ---
> > > > > Cc: Yoni Levitt <yoni.levitt@intel.com>
> > > > > Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> > > > > Cc: Raag Jadav <raag.jadav@intel.com>
> > > > > Cc: Riana Tauro <riana.tauro@intel.com>
> > > > > ---
> > > > > v2: CORRECTED is still an error (Michal)
> > > > >     prepare to decorate dmesg with comp/loc (Michal)
> > > > > ---
> > > > >  Documentation/gpu/xe/index.rst        |   1 +
> > > > >  Documentation/gpu/xe/xe_sigid.rst     |  14 ++
> > > > >  drivers/gpu/drm/xe/Makefile           |   1 +
> > > > >  drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183
> > > > > ++++++++++++++++++++++++++
> > > > >  drivers/gpu/drm/xe/xe_log.c           | 135
> > > > > +++++++++++++++++++
> > > > >  drivers/gpu/drm/xe/xe_log.h           |  20 +++
> > > > >  6 files changed, 354 insertions(+)
> > > > >  create mode 100644 Documentation/gpu/xe/xe_sigid.rst
> > > > >  create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > >  create mode 100644 drivers/gpu/drm/xe/xe_log.c
> > > > >  create mode 100644 drivers/gpu/drm/xe/xe_log.h
> > > > > 
> > > > > diff --git a/Documentation/gpu/xe/index.rst
> > > > > b/Documentation/gpu/xe/index.rst
> > > > > index 665c0e93601c..0247a255f7e6 100644
> > > > > --- a/Documentation/gpu/xe/index.rst
> > > > > +++ b/Documentation/gpu/xe/index.rst
> > > > > @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for
> > > > > drm/xe
> > > > > is provided by
> > > > >     xe-drm-usage-stats.rst
> > > > >     xe_configfs
> > > > >     xe_gt_stats
> > > > > +   xe_sigid
> > > > > diff --git a/Documentation/gpu/xe/xe_sigid.rst
> > > > > b/Documentation/gpu/xe/xe_sigid.rst
> > > > > new file mode 100644
> > > > > index 000000000000..45d84a62f185
> > > > > --- /dev/null
> > > > > +++ b/Documentation/gpu/xe/xe_sigid.rst
> > > > > @@ -0,0 +1,14 @@
> > > > > +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> > > > > +
> > > > > +========
> > > > > +Xe SIGID
> > > > > +========
> > > > > +
> > > > > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > +   :doc: Xe Error Signatures (SIGID)
> > > > > +
> > > > > +Signature Identifiers
> > > > > +=====================
> > > > > +
> > > > > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > +   :internal:
> > > > > diff --git a/drivers/gpu/drm/xe/Makefile
> > > > > b/drivers/gpu/drm/xe/Makefile
> > > > > index 67ada1d6c2fb..7ac3954737f9 100644
> > > > > --- a/drivers/gpu/drm/xe/Makefile
> > > > > +++ b/drivers/gpu/drm/xe/Makefile
> > > > > @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
> > > > >         xe_hw_fence.o \
> > > > >         xe_irq.o \
> > > > >         xe_late_bind_fw.o \
> > > > > +       xe_log.o \
> > > > >         xe_lrc.o \
> > > > >         xe_mem_pool.o \
> > > > >         xe_migrate.o \
> > > > > diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > new file mode 100644
> > > > > index 000000000000..99717fdf74a6
> > > > > --- /dev/null
> > > > > +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > @@ -0,0 +1,183 @@
> > > > > +/* SPDX-License-Identifier: MIT */
> > > > > +/*
> > > > > + * Copyright © 2026 Intel Corporation
> > > > > + */
> > > > > +
> > > > > +#ifndef _ABI_XE_SIGID_ABI_H_
> > > > > +#define _ABI_XE_SIGID_ABI_H_
> > > > > +
> > > > > +/**
> > > > > + * DOC: Xe Error Signatures (SIGID)
> > > > > + *
> > > > > + * What SIGID stands for
> > > > > + * ---------------------
> > > > > + *
> > > > > + * SIGID is short for *Signature Identifier*. A SIGID is a
> > > > > small,
> > > > > stable integer
> > > > > + * that names one *recognised Xe fault situation* -- nothing
> > > > > more.
> > > > > It is the
> > > > > + * primary handle used for triage: a SIGID maps to a human
> > > > > description and a
> > > > > + * recommended first action. A coarse first-order action is
> > > > > documented in-tree
> > > > > + * per SIGID (see "First-order action" below) so the id is
> > > > > actionable on its
> > > > > + * own; published end-user documentation refines it with
> > > > > finer,
> > > > > cross-product
> > > > > + * detail. The driver's only job is to emit the right SIGID
> > > > > next
> > > > > to
> > > > > the usual
> > > > > + * human-readable text.
> > > > > + *
> > > > > + * Why this exists
> > > > > + * ---------------
> > > > > + *
> > > > > + * Today the driver reports faults with ad-hoc ``drm_err()``
> > > > > /
> > > > > ``xe_gt_err()``
> > > > > + * strings that have no stable shape. That is fine for a
> > > > > human
> > > > > reading dmesg,
> > > > > + * but it gives fleet tooling nothing durable to match on:
> > > > > the
> > > > > wording changes
> > > > > + * between releases, lines can be rate-limited or dropped
> > > > > under
> > > > > an
> > > > > error storm,
> > > > > + * and there is no consistent way to ask "which recognised
> > > > > fault
> > > > > just happened?"
> > > > > + * A SIGID answers exactly that one question, identically
> > > > > across
> > > > > driver and
> > > > > + * firmware versions, and (eventually) across other Intel
> > > > > devices in
> > > > > a node.
> > > > > + *
> > > > > + * What a SIGID is (and is not)
> > > > > + * ----------------------------
> > > > > + *
> > > > > + * A SIGID names *which situation* is being reported. It
> > > > > deliberately does not
> > > > > + * encode the detailed reason or the outcome. Those are
> > > > > carried
> > > > > alongside it::
> > > > > + *
> > > > > + *   SIGID    -> which recognised situation is being
> > > > > reported
> > > > > + *   severity -> how serious this instance is (see below --
> > > > > not
> > > > > fixed per SIGID)
> > > > > + *   errno    -> the failing operation's error, shown with
> > > > > %pe
> > > > > + *   message  -> free-form human-readable context
> > > > > + *
> > > > > + * Severity is independent of the SIGID. The same situation
> > > > > can
> > > > > be
> > > > > reported at
> > > > > + * different severities depending on the instance and the
> > > > > recovery
> > > > > taken, so a
> > > > > + * SIGID is never tied to one severity; the reporting site
> > > > > chooses
> > > > > it by calling
> > > > > + * the matching xe_log_*() helper (see xe_log.h).
> > > > > + *
> > > > > + * How to pick a SIGID (the uniqueness rule)
> > > > > + * -----------------------------------------
> > > > > + *
> > > > > + * Pick per *report site*, not per incident. Each site emits
> > > > > the
> > > > > single most
> > > > > + * specific recognised situation *for that site* -- so the
> > > > > question
> > > > > is never
> > > > > + * "classify this whole failure", it is "what does this site
> > > > > detect?", which has
> > > > > + * one answer. A single underlying failure therefore
> > > > > legitimately
> > > > > produces a
> > > > > + * *chain* of reports from different layers, each with its
> > > > > own
> > > > > SIGID
> > > > > -- e.g. a
> > > > > + * GuC communication failure is reported as
> > > > > %XE_SIGID_RUNTIME_FW
> > > > > by
> > > > > the firmware
> > > > > + * path, the failed recovery as %XE_SIGID_GT_TDR by the
> > > > > reset
> > > > > path,
> > > > > and an
> > > > > + * aborted bind as %XE_SIGID_PROBE by the probe path. That
> > > > > chain
> > > > > lets triage
> > > > > + * follow a fault from origin to final effect; it is not a
> > > > > duplicate.
> > > > > + *
> > > > > + * If a site does not match any defined situation, keep
> > > > > using
> > > > > the
> > > > > ordinary
> > > > > + * ``xe_err()`` / ``xe_gt_err()`` logging rather than
> > > > > forcing a
> > > > > SIGID: a wrong
> > > > > + * or over-broad classification is harder to retire than a
> > > > > missing
> > > > > one. When a
> > > > > + * new situation is genuinely worth triaging, add it to the
> > > > > list
> > > > > below.
> > > > > + *
> > > > > + * Scope: software-emitted signatures only
> > > > > + * ---------------------------------------
> > > > > + *
> > > > > + * This header enumerates only the situations that the
> > > > > *driver
> > > > > itself* detects
> > > > > + * and reports from software: probe abort, wedged,
> > > > > survivability,
> > > > > driver-
> > > > > + * detected firmware failures, engine TDR, memory faults and
> > > > > IO/bus
> > > > > faults.
> > > > > + * These are the only values the driver assigns.
> > > > > + *
> > > > > + * Signatures that *originate* in firmware or hardware are a
> > > > > different thing:
> > > > > + * they are produced and identified by the firmware or the
> > > > > hardware
> > > > > itself
> > > > > + * (e.g. via their own records or error counters), and the
> > > > > driver
> > > > > merely logs
> > > > > + * them as they are given to us. They are deliberately *not*
> > > > > enumerated here --
> > > > > + * minting a driver-side id for a firmware/hardware-reported
> > > > > error
> > > > > would only
> > > > > + * duplicate an identifier the reporting layer already owns.
> > > > > The
> > > > > two
> > > > > + * driver-detected firmware situations below
> > > > > (%XE_SIGID_RUNTIME_FW,
> > > > > + * %XE_SIGID_DEVICE_FW) are software signatures: they mark
> > > > > that
> > > > > *the
> > > > > driver*
> > > > > + * observed a firmware problem, not a signature reported by
> > > > > the
> > > > > firmware.
> > > > > + *
> > > > > + * Numbering
> > > > > + * ---------
> > > > > + *
> > > > > + * SIGIDs are a single flat list numbered sequentially
> > > > > within
> > > > > the
> > > > > assigned range,
> > > > > + * in the order the situations were introduced. Values are
> > > > > stable:
> > > > > once assigned
> > > > > + * they are only ever appended, never renumbered or reused.
> > > > > + *
> > > > > + * A retired situation is deprecated in place, never re-
> > > > > purposed.
> > > > > + *
> > > > > + * First-order action (resolution buckets)
> > > > > + * ---------------------------------------
> > > > > + *
> > > > > + * So that a SIGID is actionable on its own, each one is
> > > > > tagged
> > > > > with
> > > > > a coarse
> > > > > + * *resolution bucket*: the first thing an operator should
> > > > > do on
> > > > > seeing it. The
> > > > > + * bucket is a stable, driver-owned hint; external
> > > > > documentation
> > > > > may
> > > > > refine it,
> > > > > + * but the in-tree value always stands on its own. Every new
> > > > > SIGID
> > > > > must pick a
> > > > > + * bucket, which forces the question "what should someone do
> > > > > about
> > > > > this?" to be
> > > > > + * answered up front. The buckets are::
> > > > > + *
> > > > > + *   COLLECT  -- capture logs and open a bug report
> > > > > + *   RETRY    -- transient or already recovered; watch for
> > > > > recurrence
> > > > > + *   UPDATE   -- a firmware update / flash is required
> > > > > + *   RECOVER  -- an explicit recovery step is needed
> > > > > (rebind,
> > > > > bus
> > > > > reset)
> > > > > + *   IGNORE   -- ignore if the SIGID severity is
> > > > > INFORMATIONAL
> > > > > + *
> > > > > + * The bucket is documentation only -- it is recorded per
> > > > > SIGID
> > > > > in
> > > > > the enum
> > > > > + * kernel-doc below and is not printed on the (deliberately
> > > > > lean)
> > > > > dmesg line.
> > > > > + *
> > > > > + * When to use SIGID logging
> > > > > + * -------------------------
> > > > > + *
> > > > > + * The xe_log_*() helpers are for these recognised fault
> > > > > situations
> > > > > only --
> > > > > + * important, operator-relevant faults and events. They are
> > > > > not
> > > > > a
> > > > > replacement
> > > > > + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-
> > > > > off
> > > > > diagnostics;
> > > > > + * using them for ordinary logging would dilute the fault
> > > > > stream.
> > > > > Not every
> > > > > + * ``xe_err()`` needs to become a SIGID report -- only those
> > > > > that
> > > > > correspond to
> > > > > + * a published situation.
> > > > > + *
> > > > > + * dmesg vs. the machine record
> > > > > + * ----------------------------
> > > > > + *
> > > > > + * The dmesg line stays close to a normal xe error message
> > > > > so it
> > > > > remains
> > > > > + * readable for admins; the only stable, machine-matchable
> > > > > token
> > > > > on
> > > > > it is
> > > > > + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an
> > > > > ABI:
> > > > > the
> > > > > surrounding
> > > > > + * text may change freely, and lines may be dropped. The
> > > > > durable
> > > > > record for
> > > > > + * tooling is the CPER record carrying the same SIGID
> > > > > (generation is
> > > > > a planned
> > > > > + * follow-up).
> > 
> > Ok I realize I'm coming late to the party here - I just haven't had
> > the
> 
> (no worries, I was late too)
> 
> > time to review this in detail. I really don't like having this ABI-
> > adjacent implementation. It feels like we will be on the hook for
> > maintaining things in the future that will limit our ability to
> > implement changes and debug. I get the notes that Rodrigo has
> > above,
> > but this just feels like the wrong approach to me.
> > 
> > That said, I don't want to block the work here. I know we have some
> > users looking for this for their own debug.
> > 
> > You have "dmesg is not ABI" here which is a start. What happens if
> > we
> > decide to drop one of these messages? 
> 
> we don't require any use of xe_log() to be permanent (see below)
> it can changed or dropped or replaced back with xe_err() any time.
> 
> > Is it only the ID itself that we
> > want to be stable and monotonically incrementing? 
> 
> correct, just use of the same SIGID in the log will always mean the
> same
> 
> > Or is the message
> > itself supposed to be stable? 
> 
> message can be changed any time, like in regular xe_err()
> 
> it is just an additional hint for debug (together with SEVERITY
> and reported errno)
> 
> > If we drop all references to a particular
> > ID is that ok? 
> 
> yes, if the ID is no longer applicable
> and this was already stated in DOC
> 
> > What if we have 10s of IDs or more that have no use in
> > the future and we move on to the next section? We don't care about
> > cleanup of this kind of thing? 
> 
> legacy SIGIDs stays forever, there will be no ID value reuse
> (also see DOC) but due to the way they are defined, it is unlikely
> that we will drop them
> 
> > Or the line above about "dmesg is not
> > ABI" means we can really do whatever we want with it?
> 
> I assume the only new requirement for us would be that we
> should not drop all xe_logs for any SIGID which is still
> applicable (and was not replaced with other SIGID)

It would be nice to make that explicit in the documentation.

I'm still pretty worried about the contractual aspect of this with
users who start relying on this. But if we take that out, from a purely
kernel debug usage aspect, I do like having this to help categorize
issues and flows. It seems like we should be able to do something with
this in printk directly (or the drm_* variants) rather than having
something specific to the GPU here. But as long as we don't make it too
strict, hopefully we can expand if there's interest there.

Let me go through in detail later today and get back.

Thanks,
Stuart

> 
> > 
> > Thanks,
> > Stuart
> > 

Re: [PATCH v3 02/23] drm/xe/log: Add structured SIGID error logging infrastructure

[Rodrigo Vivi]

On Thu, Aug 06, 2026 at 03:10:04PM -0400, Summers, Stuart wrote:
> On Thu, 2026-08-06 at 13:31 +0200, Michal Wajdeczko wrote:
> > 
> > 
> > On 8/6/2026 12:24 AM, Summers, Stuart wrote:
> > > On Tue, 2026-08-04 at 21:36 -0400, Rodrigo Vivi wrote:
> > > > On Tue, Aug 04, 2026 at 05:21:05PM -0400, Summers, Stuart wrote:
> > > > > On Thu, 2026-07-30 at 17:20 +0200, Michal Wajdeczko wrote:
> > > > > > From: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> > > > > > 
> > > > > > Today the driver reports faults with ad-hoc
> > > > > > drm_err()/xe_gt_err()
> > > > > > strings that have no stable shape. That is readable for a
> > > > > > human,
> > > > > > but
> > > > > > it
> > > > > > gives fleet tooling nothing durable to match on: the wording
> > > > > > changes
> > > > > > between releases, lines can be rate-limited or dropped under
> > > > > > an
> > > > > > error
> > > > > > storm, and there is no consistent way to ask "which
> > > > > > recognised
> > > > > > fault
> > > > > > just happened?".
> > > > > > 
> > > > > > Introduce a signature identifier (SIGID): a small, stable
> > > > > > integer
> > > > > > that
> > > > > > names one recognised Xe fault situation and serves as the
> > > > > > primary
> > > > > > handle
> > > > > > for triage. A SIGID maps, through published end-user
> > > > > > documentation,
> > > > > > to a
> > > > > > description and a recommended action; the driver only has to
> > > > > > emit
> > > > > > the
> > > > > > right SIGID next to the usual human-readable text.
> > > > > 
> > > > > I'm a little worried
> > > > 
> > > > I understand your feeling. We've been all through that:
> > > > 
> > > > https://lore.kernel.org/intel-xe/amqhoFzQaf1HsuFq@intel.com/
> > > > 
> > > > > we're introducing some ABI with this that isn't
> > > > > really maintainable in the long term:
> > > > 
> > > > I understand the fear and indeed the first proposals I got was
> > > > unmaintainable. My first record of pushing back on having
> > > > something
> > > > like this was November last year.
> > > > 
> > > > But I respectfully disagree here. This latest version is imho
> > > > organized and concise.
> > > > 
> > > > > we might decide to change the
> > > > > flow or change the way an error is reported or the situation
> > > > > that
> > > > > triggers this error from firmware or hardware might change for
> > > > > some
> > > > > reason.
> > > > 
> > > > You are right, dmesg is not ABI and it will never be. these logs
> > > > are aimed for developers and developers are free to change them
> > > > as
> > > > needed. This was a big counter-requirement I gave to the original
> > > > idea.
> > > > 
> > > > We are not moving all the logs to this format we are not
> > > > promising
> > > > dmesg stability.
> > > > 
> > > > The numbering stability however needs to be somewhat stable for
> > > > the CPER log in tracefs, that's the ABI. But then that meaning
> > > > shouldn't change if the code has to change. A new number should
> > > > be needed if the component/location/severity or recommended
> > > > recovery needs to be different.
> > > > 
> > > > But like I told Raag as well, no developer needs to invent any
> > > > number, if they don't know just use regular log messages.
> > > > We are not going to move all the logs towards this thing.
> > > > Also, the location of the issue is what triggers the ID...
> > > > it is very simple by nature. And we need to keep it simple.
> > > > 
> > > > > Does this lock us into a solution for all of this? I still need
> > > > > to go through the full patch series...
> > > > 
> > > > Yes, please take a look to the series. All reviews are welcomed.
> > > > 
> > > > > 
> > > > > The dmesg entries are generally for human debuggability. I get
> > > > > the
> > > > > desire to make these easier to parse for an AI tool or
> > > > > generated
> > > > > script, but we also don't want to prevent debug related changes
> > > > > for
> > > > > error handling and reporting.
> > > > 
> > > > We are not promising this. The stable ABI is only the CPER on
> > > > tracefs.
> > > > 
> > > > We need to always keep this in mind as stated in
> > > > Documentation/core-api/printk-index.rst:
> > > > 
> > > > """
> > > > The kernel messages are evolving together with the code. As a
> > > > result,
> > > > particular kernel messages are not KABI and never will be!
> > > > """
> > > > 
> > > > Thanks,
> > > > Rodrigo.
> > > > 
> > > > > 
> > > > > Thanks,
> > > > > Stuart
> > > > > 
> > > > > > 
> > > > > > Signed-off-by: Mallesh Koujalagi
> > > > > > <mallesh.koujalagi@intel.com>
> > > > > > Assisted-by: Copilot:Opus-4.8
> > > > > > Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
> > > > > > Co-developed-by: Michal Wajdeczko
> > > > > > <michal.wajdeczko@intel.com>
> > > > > > Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> > > > > > ---
> > > > > > Cc: Yoni Levitt <yoni.levitt@intel.com>
> > > > > > Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> > > > > > Cc: Raag Jadav <raag.jadav@intel.com>
> > > > > > Cc: Riana Tauro <riana.tauro@intel.com>
> > > > > > ---
> > > > > > v2: CORRECTED is still an error (Michal)
> > > > > >     prepare to decorate dmesg with comp/loc (Michal)
> > > > > > ---
> > > > > >  Documentation/gpu/xe/index.rst        |   1 +
> > > > > >  Documentation/gpu/xe/xe_sigid.rst     |  14 ++
> > > > > >  drivers/gpu/drm/xe/Makefile           |   1 +
> > > > > >  drivers/gpu/drm/xe/abi/xe_sigid_abi.h | 183
> > > > > > ++++++++++++++++++++++++++
> > > > > >  drivers/gpu/drm/xe/xe_log.c           | 135
> > > > > > +++++++++++++++++++
> > > > > >  drivers/gpu/drm/xe/xe_log.h           |  20 +++
> > > > > >  6 files changed, 354 insertions(+)
> > > > > >  create mode 100644 Documentation/gpu/xe/xe_sigid.rst
> > > > > >  create mode 100644 drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > >  create mode 100644 drivers/gpu/drm/xe/xe_log.c
> > > > > >  create mode 100644 drivers/gpu/drm/xe/xe_log.h
> > > > > > 
> > > > > > diff --git a/Documentation/gpu/xe/index.rst
> > > > > > b/Documentation/gpu/xe/index.rst
> > > > > > index 665c0e93601c..0247a255f7e6 100644
> > > > > > --- a/Documentation/gpu/xe/index.rst
> > > > > > +++ b/Documentation/gpu/xe/index.rst
> > > > > > @@ -35,3 +35,4 @@ The display, or :ref:`drm-kms`, support for
> > > > > > drm/xe
> > > > > > is provided by
> > > > > >     xe-drm-usage-stats.rst
> > > > > >     xe_configfs
> > > > > >     xe_gt_stats
> > > > > > +   xe_sigid
> > > > > > diff --git a/Documentation/gpu/xe/xe_sigid.rst
> > > > > > b/Documentation/gpu/xe/xe_sigid.rst
> > > > > > new file mode 100644
> > > > > > index 000000000000..45d84a62f185
> > > > > > --- /dev/null
> > > > > > +++ b/Documentation/gpu/xe/xe_sigid.rst
> > > > > > @@ -0,0 +1,14 @@
> > > > > > +.. SPDX-License-Identifier: (GPL-2.0+ OR MIT)
> > > > > > +
> > > > > > +========
> > > > > > +Xe SIGID
> > > > > > +========
> > > > > > +
> > > > > > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > > +   :doc: Xe Error Signatures (SIGID)
> > > > > > +
> > > > > > +Signature Identifiers
> > > > > > +=====================
> > > > > > +
> > > > > > +.. kernel-doc:: drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > > +   :internal:
> > > > > > diff --git a/drivers/gpu/drm/xe/Makefile
> > > > > > b/drivers/gpu/drm/xe/Makefile
> > > > > > index 67ada1d6c2fb..7ac3954737f9 100644
> > > > > > --- a/drivers/gpu/drm/xe/Makefile
> > > > > > +++ b/drivers/gpu/drm/xe/Makefile
> > > > > > @@ -87,6 +87,7 @@ xe-y += xe_bb.o \
> > > > > >         xe_hw_fence.o \
> > > > > >         xe_irq.o \
> > > > > >         xe_late_bind_fw.o \
> > > > > > +       xe_log.o \
> > > > > >         xe_lrc.o \
> > > > > >         xe_mem_pool.o \
> > > > > >         xe_migrate.o \
> > > > > > diff --git a/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > > b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > > new file mode 100644
> > > > > > index 000000000000..99717fdf74a6
> > > > > > --- /dev/null
> > > > > > +++ b/drivers/gpu/drm/xe/abi/xe_sigid_abi.h
> > > > > > @@ -0,0 +1,183 @@
> > > > > > +/* SPDX-License-Identifier: MIT */
> > > > > > +/*
> > > > > > + * Copyright © 2026 Intel Corporation
> > > > > > + */
> > > > > > +
> > > > > > +#ifndef _ABI_XE_SIGID_ABI_H_
> > > > > > +#define _ABI_XE_SIGID_ABI_H_
> > > > > > +
> > > > > > +/**
> > > > > > + * DOC: Xe Error Signatures (SIGID)
> > > > > > + *
> > > > > > + * What SIGID stands for
> > > > > > + * ---------------------
> > > > > > + *
> > > > > > + * SIGID is short for *Signature Identifier*. A SIGID is a
> > > > > > small,
> > > > > > stable integer
> > > > > > + * that names one *recognised Xe fault situation* -- nothing
> > > > > > more.
> > > > > > It is the
> > > > > > + * primary handle used for triage: a SIGID maps to a human
> > > > > > description and a
> > > > > > + * recommended first action. A coarse first-order action is
> > > > > > documented in-tree
> > > > > > + * per SIGID (see "First-order action" below) so the id is
> > > > > > actionable on its
> > > > > > + * own; published end-user documentation refines it with
> > > > > > finer,
> > > > > > cross-product
> > > > > > + * detail. The driver's only job is to emit the right SIGID
> > > > > > next
> > > > > > to
> > > > > > the usual
> > > > > > + * human-readable text.
> > > > > > + *
> > > > > > + * Why this exists
> > > > > > + * ---------------
> > > > > > + *
> > > > > > + * Today the driver reports faults with ad-hoc ``drm_err()``
> > > > > > /
> > > > > > ``xe_gt_err()``
> > > > > > + * strings that have no stable shape. That is fine for a
> > > > > > human
> > > > > > reading dmesg,
> > > > > > + * but it gives fleet tooling nothing durable to match on:
> > > > > > the
> > > > > > wording changes
> > > > > > + * between releases, lines can be rate-limited or dropped
> > > > > > under
> > > > > > an
> > > > > > error storm,
> > > > > > + * and there is no consistent way to ask "which recognised
> > > > > > fault
> > > > > > just happened?"
> > > > > > + * A SIGID answers exactly that one question, identically
> > > > > > across
> > > > > > driver and
> > > > > > + * firmware versions, and (eventually) across other Intel
> > > > > > devices in
> > > > > > a node.
> > > > > > + *
> > > > > > + * What a SIGID is (and is not)
> > > > > > + * ----------------------------
> > > > > > + *
> > > > > > + * A SIGID names *which situation* is being reported. It
> > > > > > deliberately does not
> > > > > > + * encode the detailed reason or the outcome. Those are
> > > > > > carried
> > > > > > alongside it::
> > > > > > + *
> > > > > > + *   SIGID    -> which recognised situation is being
> > > > > > reported
> > > > > > + *   severity -> how serious this instance is (see below --
> > > > > > not
> > > > > > fixed per SIGID)
> > > > > > + *   errno    -> the failing operation's error, shown with
> > > > > > %pe
> > > > > > + *   message  -> free-form human-readable context
> > > > > > + *
> > > > > > + * Severity is independent of the SIGID. The same situation
> > > > > > can
> > > > > > be
> > > > > > reported at
> > > > > > + * different severities depending on the instance and the
> > > > > > recovery
> > > > > > taken, so a
> > > > > > + * SIGID is never tied to one severity; the reporting site
> > > > > > chooses
> > > > > > it by calling
> > > > > > + * the matching xe_log_*() helper (see xe_log.h).
> > > > > > + *
> > > > > > + * How to pick a SIGID (the uniqueness rule)
> > > > > > + * -----------------------------------------
> > > > > > + *
> > > > > > + * Pick per *report site*, not per incident. Each site emits
> > > > > > the
> > > > > > single most
> > > > > > + * specific recognised situation *for that site* -- so the
> > > > > > question
> > > > > > is never
> > > > > > + * "classify this whole failure", it is "what does this site
> > > > > > detect?", which has
> > > > > > + * one answer. A single underlying failure therefore
> > > > > > legitimately
> > > > > > produces a
> > > > > > + * *chain* of reports from different layers, each with its
> > > > > > own
> > > > > > SIGID
> > > > > > -- e.g. a
> > > > > > + * GuC communication failure is reported as
> > > > > > %XE_SIGID_RUNTIME_FW
> > > > > > by
> > > > > > the firmware
> > > > > > + * path, the failed recovery as %XE_SIGID_GT_TDR by the
> > > > > > reset
> > > > > > path,
> > > > > > and an
> > > > > > + * aborted bind as %XE_SIGID_PROBE by the probe path. That
> > > > > > chain
> > > > > > lets triage
> > > > > > + * follow a fault from origin to final effect; it is not a
> > > > > > duplicate.
> > > > > > + *
> > > > > > + * If a site does not match any defined situation, keep
> > > > > > using
> > > > > > the
> > > > > > ordinary
> > > > > > + * ``xe_err()`` / ``xe_gt_err()`` logging rather than
> > > > > > forcing a
> > > > > > SIGID: a wrong
> > > > > > + * or over-broad classification is harder to retire than a
> > > > > > missing
> > > > > > one. When a
> > > > > > + * new situation is genuinely worth triaging, add it to the
> > > > > > list
> > > > > > below.
> > > > > > + *
> > > > > > + * Scope: software-emitted signatures only
> > > > > > + * ---------------------------------------
> > > > > > + *
> > > > > > + * This header enumerates only the situations that the
> > > > > > *driver
> > > > > > itself* detects
> > > > > > + * and reports from software: probe abort, wedged,
> > > > > > survivability,
> > > > > > driver-
> > > > > > + * detected firmware failures, engine TDR, memory faults and
> > > > > > IO/bus
> > > > > > faults.
> > > > > > + * These are the only values the driver assigns.
> > > > > > + *
> > > > > > + * Signatures that *originate* in firmware or hardware are a
> > > > > > different thing:
> > > > > > + * they are produced and identified by the firmware or the
> > > > > > hardware
> > > > > > itself
> > > > > > + * (e.g. via their own records or error counters), and the
> > > > > > driver
> > > > > > merely logs
> > > > > > + * them as they are given to us. They are deliberately *not*
> > > > > > enumerated here --
> > > > > > + * minting a driver-side id for a firmware/hardware-reported
> > > > > > error
> > > > > > would only
> > > > > > + * duplicate an identifier the reporting layer already owns.
> > > > > > The
> > > > > > two
> > > > > > + * driver-detected firmware situations below
> > > > > > (%XE_SIGID_RUNTIME_FW,
> > > > > > + * %XE_SIGID_DEVICE_FW) are software signatures: they mark
> > > > > > that
> > > > > > *the
> > > > > > driver*
> > > > > > + * observed a firmware problem, not a signature reported by
> > > > > > the
> > > > > > firmware.
> > > > > > + *
> > > > > > + * Numbering
> > > > > > + * ---------
> > > > > > + *
> > > > > > + * SIGIDs are a single flat list numbered sequentially
> > > > > > within
> > > > > > the
> > > > > > assigned range,
> > > > > > + * in the order the situations were introduced. Values are
> > > > > > stable:
> > > > > > once assigned
> > > > > > + * they are only ever appended, never renumbered or reused.
> > > > > > + *
> > > > > > + * A retired situation is deprecated in place, never re-
> > > > > > purposed.
> > > > > > + *
> > > > > > + * First-order action (resolution buckets)
> > > > > > + * ---------------------------------------
> > > > > > + *
> > > > > > + * So that a SIGID is actionable on its own, each one is
> > > > > > tagged
> > > > > > with
> > > > > > a coarse
> > > > > > + * *resolution bucket*: the first thing an operator should
> > > > > > do on
> > > > > > seeing it. The
> > > > > > + * bucket is a stable, driver-owned hint; external
> > > > > > documentation
> > > > > > may
> > > > > > refine it,
> > > > > > + * but the in-tree value always stands on its own. Every new
> > > > > > SIGID
> > > > > > must pick a
> > > > > > + * bucket, which forces the question "what should someone do
> > > > > > about
> > > > > > this?" to be
> > > > > > + * answered up front. The buckets are::
> > > > > > + *
> > > > > > + *   COLLECT  -- capture logs and open a bug report
> > > > > > + *   RETRY    -- transient or already recovered; watch for
> > > > > > recurrence
> > > > > > + *   UPDATE   -- a firmware update / flash is required
> > > > > > + *   RECOVER  -- an explicit recovery step is needed
> > > > > > (rebind,
> > > > > > bus
> > > > > > reset)
> > > > > > + *   IGNORE   -- ignore if the SIGID severity is
> > > > > > INFORMATIONAL
> > > > > > + *
> > > > > > + * The bucket is documentation only -- it is recorded per
> > > > > > SIGID
> > > > > > in
> > > > > > the enum
> > > > > > + * kernel-doc below and is not printed on the (deliberately
> > > > > > lean)
> > > > > > dmesg line.
> > > > > > + *
> > > > > > + * When to use SIGID logging
> > > > > > + * -------------------------
> > > > > > + *
> > > > > > + * The xe_log_*() helpers are for these recognised fault
> > > > > > situations
> > > > > > only --
> > > > > > + * important, operator-relevant faults and events. They are
> > > > > > not
> > > > > > a
> > > > > > replacement
> > > > > > + * for ``xe_info()`` / ``xe_dbg()`` / tracing, nor for one-
> > > > > > off
> > > > > > diagnostics;
> > > > > > + * using them for ordinary logging would dilute the fault
> > > > > > stream.
> > > > > > Not every
> > > > > > + * ``xe_err()`` needs to become a SIGID report -- only those
> > > > > > that
> > > > > > correspond to
> > > > > > + * a published situation.
> > > > > > + *
> > > > > > + * dmesg vs. the machine record
> > > > > > + * ----------------------------
> > > > > > + *
> > > > > > + * The dmesg line stays close to a normal xe error message
> > > > > > so it
> > > > > > remains
> > > > > > + * readable for admins; the only stable, machine-matchable
> > > > > > token
> > > > > > on
> > > > > > it is
> > > > > > + * ``SIGID=<n>`` (``dmesg | grep SIGID=``). dmesg is not an
> > > > > > ABI:
> > > > > > the
> > > > > > surrounding
> > > > > > + * text may change freely, and lines may be dropped. The
> > > > > > durable
> > > > > > record for
> > > > > > + * tooling is the CPER record carrying the same SIGID
> > > > > > (generation is
> > > > > > a planned
> > > > > > + * follow-up).
> > > 
> > > Ok I realize I'm coming late to the party here - I just haven't had
> > > the
> > 
> > (no worries, I was late too)
> > 
> > > time to review this in detail. I really don't like having this ABI-
> > > adjacent implementation. It feels like we will be on the hook for
> > > maintaining things in the future that will limit our ability to
> > > implement changes and debug. I get the notes that Rodrigo has
> > > above,
> > > but this just feels like the wrong approach to me.
> > > 
> > > That said, I don't want to block the work here. I know we have some
> > > users looking for this for their own debug.
> > > 
> > > You have "dmesg is not ABI" here which is a start. What happens if
> > > we
> > > decide to drop one of these messages? 
> > 
> > we don't require any use of xe_log() to be permanent (see below)
> > it can changed or dropped or replaced back with xe_err() any time.
> > 
> > > Is it only the ID itself that we
> > > want to be stable and monotonically incrementing? 
> > 
> > correct, just use of the same SIGID in the log will always mean the
> > same
> > 
> > > Or is the message
> > > itself supposed to be stable? 
> > 
> > message can be changed any time, like in regular xe_err()
> > 
> > it is just an additional hint for debug (together with SEVERITY
> > and reported errno)
> > 
> > > If we drop all references to a particular
> > > ID is that ok? 
> > 
> > yes, if the ID is no longer applicable
> > and this was already stated in DOC
> > 
> > > What if we have 10s of IDs or more that have no use in
> > > the future and we move on to the next section? We don't care about
> > > cleanup of this kind of thing? 
> > 
> > legacy SIGIDs stays forever, there will be no ID value reuse
> > (also see DOC) but due to the way they are defined, it is unlikely
> > that we will drop them
> > 
> > > Or the line above about "dmesg is not
> > > ABI" means we can really do whatever we want with it?
> > 
> > I assume the only new requirement for us would be that we
> > should not drop all xe_logs for any SIGID which is still
> > applicable (and was not replaced with other SIGID)

Well, if the code changes in a way that the function doesn't
exist anymore, what should we do?
We cannot guarantee that.

> 
> It would be nice to make that explicit in the documentation.

Right, we probably need some explicit mention about this case.
But we shouldn't commit to not remove a log line.

> 
> I'm still pretty worried about the contractual aspect of this with
> users who start relying on this. But if we take that out, from a purely
> kernel debug usage aspect, I do like having this to help categorize
> issues and flows. It seems like we should be able to do something with
> this in printk directly (or the drm_* variants) rather than having
> something specific to the GPU here. But as long as we don't make it too
> strict, hopefully we can expand if there's interest there.
> 
> Let me go through in detail later today and get back.

Yes please! :)

> 
> Thanks,
> Stuart
> 
> > 
> > > 
> > > Thanks,
> > > Stuart
> > > 
> 

Re: [PATCH v3 17/23] drm/xe: Report 'device wedged' errors using SIGID

[Mallesh, Koujalagi]

On 30-07-2026 08:51 pm, Michal Wajdeczko wrote:
> Report 'device wedged' error using xe_log_err_fatal() helper.
> Use -EIO as the error cause, as nothing else is provided here.
> The hints about the recovery method and bug filling are now
Typo 'filing'
> separated as it only needs to be printed once.
>
> Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
> Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
> Cc: Aravind Iddamsetty <aravind.iddamsetty@intel.com>
> Cc: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
> ---
>   drivers/gpu/drm/xe/xe_device.c | 16 ++++++++++------
>   1 file changed, 10 insertions(+), 6 deletions(-)
>
> diff --git a/drivers/gpu/drm/xe/xe_device.c b/drivers/gpu/drm/xe/xe_device.c
> index 4eed9a251e65..b1e9bcd9f5b4 100644
> --- a/drivers/gpu/drm/xe/xe_device.c
> +++ b/drivers/gpu/drm/xe/xe_device.c
> @@ -48,6 +48,7 @@
>   #include "xe_i2c.h"
>   #include "xe_irq.h"
>   #include "xe_late_bind_fw.h"
> +#include "xe_log.h"
>   #include "xe_mmio.h"
>   #include "xe_module.h"
>   #include "xe_nvm.h"
> @@ -1396,6 +1397,9 @@ void xe_device_set_wedged_method(struct xe_device *xe, unsigned long method)
>   	xe->wedged.method = method;
>   }
>   
> +#define WEDGED_URL	"https://docs.kernel.org/gpu/drm-uapi.html#device-wedging"
> +#define XE_BUG_URL	"https://gitlab.freedesktop.org/drm/xe/kernel/issues/new"

We can directly used url string, instead of define as macro, since we 
are not using anywhere else. OR

Please make scope to file only.

> +
>   /**
>    * xe_device_declare_wedged - Declare device wedged
>    * @xe: xe device instance
> @@ -1427,12 +1431,12 @@ void xe_device_declare_wedged(struct xe_device *xe)
>   	if (!atomic_xchg(&xe->wedged.flag, 1)) {
>   		xe->needs_flr_on_fini = true;
>   		xe_pm_runtime_get_noresume(xe);
> -		drm_err(&xe->drm,
> -			"CRITICAL: Xe has declared device %s as wedged.\n"
> -			"IOCTLs and executions are blocked.\n"
> -			"For recovery procedure, refer to https://docs.kernel.org/gpu/drm-uapi.html#device-wedging\n"
> -			"Please file a _new_ bug report at https://gitlab.freedesktop.org/drm/xe/kernel/issues/new\n",
> -			dev_name(xe->drm.dev));
> +
> +		xe_log_err_fatal(xe, WEDGED, -EIO, "Device declared wedged!\n");

Using -EIO is right? since we called this function with difference 
location (since we are not propagating errors), we may have different 
errors.

which may be misleading with -EIO.


Thanks,

-/Mallesh

> +		xe_err_once(xe, "IOCTLs and executions are now blocked!\n"
> +			    "For recovery procedure, refer to %s\n"
> +			    "Please file a _new_ bug report at %s\n",
> +			    WEDGED_URL, XE_BUG_URL);

>   	}
>   
>   	for_each_gt(gt, xe, id)