[PATCH v9 0/8] Add support for EU stall sampling

[PATCH v9 0/8] Add support for EU stall sampling

[Harish Chegondi]

The following patch series add support for EU stall sampling,
a new hardware feature first added in PVC and is being supported
in XE2 and later architecture GPUs. This feature would enable
capturing of EU stall data which include the IP address of the
instruction stalled and various stall reason counts.

Support for this feature is being added into Mesa:
https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/30142

New IGT tests for EU stall sampling are being added:
https://patchwork.freedesktop.org/series/143030/

This patch series has undergone basic testing with the new IGT tests.

Thank You.

v9: a. Split the big patch in v8 into two patches
    b. Moved all drop data handling code into one patch
    c. Several other code improvements as mentioned in the patches
v8: a. Used div_u64() instead of / to fix 32-bit build issue.
    b. Changed copyright year in new files to 2025.
    c. Renamed struct drm_xe_eu_stall_data_pvc to struct xe_eu_stall_data_pvc
    d. Renamed struct drm_xe_eu_stall_data_xe2 to struct xe_eu_stall_data_xe2

v7: a. Renamed input property DRM_XE_EU_STALL_PROP_EVENT_REPORT_COUNT
       to DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS to be consistent with
       OA. Renamed the corresponding internal variables.
    b. Fixed some commit messages based on review feedback.
    c. Changed sampling_rates from a pointer to flexible array.

v6: a. Changed the uAPI input to accept sampling rate in GPU cycles
       instead of sampling rate multiplier.
    b. Fix buffer wrap around over write bug (Matt Olson).
    c. Include EU stall sampling rates information and per XeCore buffer size in the query information.

v5: Addressed review feedback from v4 including
    a. Removed DRM_XE_EU_STALL_PROP_POLL_PERIOD from the uAPI (Ashutosh)
    b. Separated the patches for Xe_HPC and Xe2 (Matt R)
    c. Moved read() returning -EIO into a separate patch
    d. Removed spinlocks around set_bit() and clear_bit() (Matt R)
    e. Renamed several variables, structures and enums (Ashutosh and
Matt R)
    f. Addressed other review feedback.
v4: Addressed review feedback from v3 including
    a. Split the patch into multiple patches (Matt R)
    b. Added a new device query to get EU stall info (Ashutosh)
    c. Renamed all Dss to xecore (Matt R)
    d. Removed buffer size and disable at open input properties. (Matt R)
    e. Removed the "_SHIFT" macros (Matt R)
    f. Allocate the EU stall buffer only on system memory.
    g. Changed the work arounds to OOB (Matt R)
    h. Other review feedback.
v3: a. Removed data header and changed read() to return -EIO when data is dropped by the HW.
    b. Added a new DRM_XE_OBSERVATION_IOCTL_INFO to query EU stall data record info
    c. Added struct drm_xe_eu_stall_data_pvc and struct drm_xe_eu_stall_data_xe2
       to xe_drm.h. These declarations would help user space to parse the
       EU stall data
    d. Addressed other review comments from v2
v2: Rename xe perf layer as xe observation layer (Ashutosh)

Reviewed-by: Ben Olson <matthew.olson@intel.com>
Acked-by: Felix Degrood <felix.j.degrood@intel.com>
Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>

Harish Chegondi (8):
  drm/xe/topology: Add a function to find the index of the last enabled
    DSS in a mask
  drm/xe/uapi: Introduce API for EU stall sampling
  drm/xe/eustall: Add support to init, enable and disable EU stall
    sampling
  drm/xe/eustall: Add support to read() and poll() EU stall data
  drm/xe/eustall: Add support to handle dropped EU stall data
  drm/xe/eustall: Add EU stall sampling support for Xe2
  drm/xe/uapi: Add a device query to get EU stall sampling information
  drm/xe/eustall: Add workaround 22016596838 which applies to PVC.

 drivers/gpu/drm/xe/Makefile                |    1 +
 drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h |   29 +
 drivers/gpu/drm/xe/xe_eu_stall.c           | 1029 ++++++++++++++++++++
 drivers/gpu/drm/xe/xe_eu_stall.h           |   21 +
 drivers/gpu/drm/xe/xe_gt.c                 |    6 +
 drivers/gpu/drm/xe/xe_gt_topology.h        |   13 +
 drivers/gpu/drm/xe/xe_gt_types.h           |    3 +
 drivers/gpu/drm/xe/xe_observation.c        |   14 +
 drivers/gpu/drm/xe/xe_query.c              |   38 +
 drivers/gpu/drm/xe/xe_trace.h              |   33 +
 drivers/gpu/drm/xe/xe_wa_oob.rules         |    1 +
 include/uapi/drm/xe_drm.h                  |   74 ++
 12 files changed, 1262 insertions(+)
 create mode 100644 drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h
 create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.c
 create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.h

-- 
2.48.1

[PATCH v9 1/8] drm/xe/topology: Add a function to find the index of the last enabled DSS in a mask

[Harish Chegondi]

Last enabled DSS in a DSS mask can help estimate the maximum DSSes enabled
in the DSS mask, as the enabled DSSes can be discontiguous.

Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
---
 drivers/gpu/drm/xe/xe_gt_topology.h | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_gt_topology.h b/drivers/gpu/drm/xe/xe_gt_topology.h
index 746b325bbf6e..a72d26ba0653 100644
--- a/drivers/gpu/drm/xe/xe_gt_topology.h
+++ b/drivers/gpu/drm/xe/xe_gt_topology.h
@@ -25,6 +25,19 @@ void xe_gt_topology_init(struct xe_gt *gt);
 
 void xe_gt_topology_dump(struct xe_gt *gt, struct drm_printer *p);
 
+/**
+ * xe_gt_topology_mask_last_dss() - Returns the index of the last DSS in a mask.
+ * @mask: Input DSS mask
+ *
+ * Return: Index of the last DSS in the input DSS mask,
+ *	   XE_MAX_DSS_FUSE_BITS if DSS mask is empty.
+ */
+static inline unsigned int
+xe_gt_topology_mask_last_dss(const xe_dss_mask_t mask)
+{
+	return find_last_bit(mask, XE_MAX_DSS_FUSE_BITS);
+}
+
 unsigned int
 xe_dss_mask_group_ffs(const xe_dss_mask_t mask, int groupsize, int groupnum);
 
-- 
2.48.1

[PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Harish Chegondi]

A new hardware feature first introduced in PVC gives capability to
periodically sample EU stall state and record counts for different stall
reasons, on a per IP basis, aggregate across all EUs in a subslice and
record the samples in a buffer in each subslice. Eventually, the aggregated
data is written out to a buffer in the memory. This feature is also
supported in XE2 and later architecture GPUs.

Use an existing IOCTL - DRM_IOCTL_XE_OBSERVATION as the interface into the
driver from the user space to do initial setup and obtain a file descriptor
for the EU stall data stream.  Input parameter to the IOCTL is a struct
drm_xe_observation_param in which observation_type should be set to
DRM_XE_OBSERVATION_TYPE_EU_STALL, observation_op should be
DRM_XE_OBSERVATION_OP_STREAM_OPEN and param should point to a chain of
drm_xe_ext_set_property structures in which each structure has a pair of
property and value. The EU stall sampling input properties are defined in
drm_xe_eu_stall_property_id enum.

With the file descriptor obtained from DRM_IOCTL_XE_OBSERVATION, user space
can enable and disable EU stall sampling with the IOCTLs:
DRM_XE_OBSERVATION_IOCTL_ENABLE and DRM_XE_OBSERVATION_IOCTL_DISABLE.
User space can also call poll() to check for availability of data in the
buffer. The data can be read with read(). Finally, the file descriptor
can be closed with close().

v9: Changed some u32 to unsigned int.
    Moved some code around as per review feedback from v8.
v8: Used div_u64 instead of / to fix 32-bit build issue.
    Changed copyright year in xe_eu_stall.c/h to 2025.
v7: Renamed input property DRM_XE_EU_STALL_PROP_EVENT_REPORT_COUNT
    to DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS to be consistent with
    OA. Renamed the corresponding internal variables.
    Fixed some commit messages based on review feedback.
v6: Change the input sampling rate to GPU cycles instead of
    GPU cycles multiplier.

Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
---
 drivers/gpu/drm/xe/Makefile         |   1 +
 drivers/gpu/drm/xe/xe_eu_stall.c    | 280 ++++++++++++++++++++++++++++
 drivers/gpu/drm/xe/xe_eu_stall.h    |  16 ++
 drivers/gpu/drm/xe/xe_observation.c |  14 ++
 include/uapi/drm/xe_drm.h           |  38 ++++
 5 files changed, 349 insertions(+)
 create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.c
 create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.h

diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
index be73362ef334..05bcb9941c38 100644
--- a/drivers/gpu/drm/xe/Makefile
+++ b/drivers/gpu/drm/xe/Makefile
@@ -33,6 +33,7 @@ xe-y += xe_bb.o \
 	xe_device_sysfs.o \
 	xe_dma_buf.o \
 	xe_drm_client.o \
+	xe_eu_stall.o \
 	xe_exec.o \
 	xe_exec_queue.o \
 	xe_execlist.o \
diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
new file mode 100644
index 000000000000..0ceb3091f81e
--- /dev/null
+++ b/drivers/gpu/drm/xe/xe_eu_stall.c
@@ -0,0 +1,280 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2025 Intel Corporation
+ */
+
+#include <linux/anon_inodes.h>
+#include <linux/fs.h>
+#include <linux/poll.h>
+#include <linux/types.h>
+
+#include <uapi/drm/xe_drm.h>
+
+#include "xe_device.h"
+#include "xe_eu_stall.h"
+#include "xe_gt_printk.h"
+#include "xe_gt_topology.h"
+#include "xe_macros.h"
+#include "xe_observation.h"
+
+static size_t per_xecore_buf_size = SZ_512K;
+
+/**
+ * struct eu_stall_open_properties - EU stall sampling properties received
+ *				     from user space at open.
+ * @sampling_rate_mult: EU stall sampling rate multiplier.
+ *			HW will sample every (sampling_rate_mult x 251) cycles.
+ * @wait_num_reports: Minimum number of EU stall data reports to unblock poll().
+ * @gt: GT on which EU stall data will be captured.
+ */
+struct eu_stall_open_properties {
+	unsigned int sampling_rate_mult;
+	unsigned int wait_num_reports;
+	struct xe_gt *gt;
+};
+
+/**
+ * num_data_rows - Return the number of EU stall data rows of 64B each
+ *		   for a given data size.
+ *
+ * @data_size: EU stall data size
+ */
+static u32 num_data_rows(u32 data_size)
+{
+	return (data_size >> 6);
+}
+
+static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
+					   struct eu_stall_open_properties *props)
+{
+	value = div_u64(value, 251);
+	if (value == 0 || value > 7) {
+		drm_dbg(&xe->drm, "Invalid EU stall sampling rate %llu\n", value);
+		return -EINVAL;
+	}
+	props->sampling_rate_mult = value;
+	return 0;
+}
+
+static int set_prop_eu_stall_wait_num_reports(struct xe_device *xe, u64 value,
+					      struct eu_stall_open_properties *props)
+{
+	unsigned int max_wait_num_reports;
+
+	max_wait_num_reports = num_data_rows(per_xecore_buf_size * XE_MAX_DSS_FUSE_BITS);
+	if (value == 0 || value > max_wait_num_reports) {
+		drm_dbg(&xe->drm, "Invalid EU stall event report count %llu\n", value);
+		drm_dbg(&xe->drm, "Minimum event report count is 1, maximum is %u\n",
+			max_wait_num_reports);
+		return -EINVAL;
+	}
+	props->wait_num_reports = value;
+	return 0;
+}
+
+static int set_prop_eu_stall_gt_id(struct xe_device *xe, u64 value,
+				   struct eu_stall_open_properties *props)
+{
+	if (value >= xe->info.gt_count) {
+		drm_dbg(&xe->drm, "Invalid GT ID %llu for EU stall sampling\n", value);
+		return -EINVAL;
+	}
+	props->gt = xe_device_get_gt(xe, value);
+	return 0;
+}
+
+typedef int (*set_eu_stall_property_fn)(struct xe_device *xe, u64 value,
+					struct eu_stall_open_properties *props);
+
+static const set_eu_stall_property_fn xe_set_eu_stall_property_funcs[] = {
+	[DRM_XE_EU_STALL_PROP_SAMPLE_RATE] = set_prop_eu_stall_sampling_rate,
+	[DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS] = set_prop_eu_stall_wait_num_reports,
+	[DRM_XE_EU_STALL_PROP_GT_ID] = set_prop_eu_stall_gt_id,
+};
+
+static int xe_eu_stall_user_ext_set_property(struct xe_device *xe, u64 extension,
+					     struct eu_stall_open_properties *props)
+{
+	u64 __user *address = u64_to_user_ptr(extension);
+	struct drm_xe_ext_set_property ext;
+	int err;
+	u32 idx;
+
+	err = __copy_from_user(&ext, address, sizeof(ext));
+	if (XE_IOCTL_DBG(xe, err))
+		return -EFAULT;
+
+	if (XE_IOCTL_DBG(xe, ext.property >= ARRAY_SIZE(xe_set_eu_stall_property_funcs)) ||
+	    XE_IOCTL_DBG(xe, ext.pad))
+		return -EINVAL;
+
+	idx = array_index_nospec(ext.property, ARRAY_SIZE(xe_set_eu_stall_property_funcs));
+	return xe_set_eu_stall_property_funcs[idx](xe, ext.value, props);
+}
+
+typedef int (*xe_eu_stall_user_extension_fn)(struct xe_device *xe, u64 extension,
+					     struct eu_stall_open_properties *props);
+static const xe_eu_stall_user_extension_fn xe_eu_stall_user_extension_funcs[] = {
+	[DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY] = xe_eu_stall_user_ext_set_property,
+};
+
+static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
+				       struct eu_stall_open_properties *props)
+{
+	u64 __user *address = u64_to_user_ptr(extension);
+	struct drm_xe_user_extension ext;
+	int err;
+	u32 idx;
+
+	err = __copy_from_user(&ext, address, sizeof(ext));
+	if (XE_IOCTL_DBG(xe, err))
+		return -EFAULT;
+
+	if (XE_IOCTL_DBG(xe, ext.pad) ||
+	    XE_IOCTL_DBG(xe, ext.name >= ARRAY_SIZE(xe_eu_stall_user_extension_funcs)))
+		return -EINVAL;
+
+	idx = array_index_nospec(ext.name, ARRAY_SIZE(xe_eu_stall_user_extension_funcs));
+	err = xe_eu_stall_user_extension_funcs[idx](xe, extension, props);
+	if (XE_IOCTL_DBG(xe, err))
+		return err;
+
+	if (ext.next_extension)
+		return xe_eu_stall_user_extensions(xe, ext.next_extension, props);
+
+	return 0;
+}
+
+/**
+ * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
+ *
+ * @file: An xe EU stall data stream file
+ * @buf: destination buffer given by userspace
+ * @count: the number of bytes userspace wants to read
+ * @ppos: (inout) file seek position (unused)
+ *
+ * Userspace must enable the EU stall stream with DRM_XE_OBSERVATION_IOCTL_ENABLE
+ * before calling read().
+ *
+ * Returns: The number of bytes copied or a negative error code on failure.
+ */
+static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
+				       size_t count, loff_t *ppos)
+{
+	ssize_t ret = 0;
+
+	return ret;
+}
+
+/**
+ * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
+ *
+ * @file: An xe EU stall data stream file
+ * @wait: Poll table
+ *
+ * Returns: Bit mask of returned events.
+ */
+static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
+{
+	__poll_t ret = 0;
+
+	return ret;
+}
+
+/**
+ * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
+ *
+ * @file: An xe EU stall data stream file
+ * @cmd: the ioctl request
+ * @arg: the ioctl data
+ *
+ * Returns: zero on success or a negative error code.
+ *	    -EINVAL for an unknown ioctl request.
+ */
+static long xe_eu_stall_stream_ioctl(struct file *file,
+				     unsigned int cmd,
+				     unsigned long arg)
+{
+	switch (cmd) {
+	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
+		return 0;
+	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
+		return 0;
+	}
+
+	return -EINVAL;
+}
+
+/**
+ * xe_eu_stall_stream_close - handles userspace close() of a EU stall data
+ *			      stream file.
+ * @inode: anonymous inode associated with file
+ * @file: An xe EU stall data stream file
+ *
+ * Cleans up any resources associated with an open EU stall data stream file.
+ */
+static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
+{
+	return 0;
+}
+
+static const struct file_operations fops_eu_stall = {
+	.owner		= THIS_MODULE,
+	.llseek		= noop_llseek,
+	.release	= xe_eu_stall_stream_close,
+	.poll		= xe_eu_stall_stream_poll,
+	.read		= xe_eu_stall_stream_read,
+	.unlocked_ioctl = xe_eu_stall_stream_ioctl,
+	.compat_ioctl   = xe_eu_stall_stream_ioctl,
+};
+
+static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
+{
+	return false;
+}
+
+/**
+ * xe_eu_stall_stream_open - Open a xe EU stall data stream fd
+ *
+ * @dev: DRM device pointer
+ * @data: pointer to first struct @drm_xe_ext_set_property in
+ *	  the chain of input properties from the user space.
+ * @file: DRM file pointer
+ *
+ * This function opens a EU stall data stream with input properties from
+ * the user space.
+ *
+ * Returns: EU stall data stream fd on success or a negative error code.
+ */
+int xe_eu_stall_stream_open(struct drm_device *dev,
+			    u64 data,
+			    struct drm_file *file)
+{
+	struct xe_device *xe = to_xe_device(dev);
+	struct eu_stall_open_properties props = {};
+	int ret, stream_fd;
+
+	if (xe_observation_paranoid && !perfmon_capable()) {
+		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
+		return -EACCES;
+	}
+	if (!has_eu_stall_sampling_support(xe)) {
+		xe_gt_dbg(props.gt, "EU stall monitoring is not supported on this platform\n");
+		return -EPERM;
+	}
+
+	ret = xe_eu_stall_user_extensions(xe, data, &props);
+	if (ret)
+		return ret;
+
+	if (!props.gt) {
+		drm_dbg(&xe->drm, "GT ID not provided for EU stall sampling\n");
+		return -EINVAL;
+	}
+
+	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
+	if (stream_fd < 0)
+		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
+
+	return stream_fd;
+}
diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
new file mode 100644
index 000000000000..d514e78341d5
--- /dev/null
+++ b/drivers/gpu/drm/xe/xe_eu_stall.h
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2025 Intel Corporation
+ */
+
+#ifndef __XE_EU_STALL_H__
+#define __XE_EU_STALL_H__
+
+#include <drm/drm_device.h>
+#include <drm/drm_file.h>
+#include <linux/types.h>
+
+int xe_eu_stall_stream_open(struct drm_device *dev,
+			    u64 data,
+			    struct drm_file *file);
+#endif
diff --git a/drivers/gpu/drm/xe/xe_observation.c b/drivers/gpu/drm/xe/xe_observation.c
index 8ec1b84cbb9e..cca661de60ac 100644
--- a/drivers/gpu/drm/xe/xe_observation.c
+++ b/drivers/gpu/drm/xe/xe_observation.c
@@ -9,6 +9,7 @@
 #include <uapi/drm/xe_drm.h>
 
 #include "xe_oa.h"
+#include "xe_eu_stall.h"
 #include "xe_observation.h"
 
 u32 xe_observation_paranoid = true;
@@ -29,6 +30,17 @@ static int xe_oa_ioctl(struct drm_device *dev, struct drm_xe_observation_param *
 	}
 }
 
+static int xe_eu_stall_ioctl(struct drm_device *dev, struct drm_xe_observation_param *arg,
+			     struct drm_file *file)
+{
+	switch (arg->observation_op) {
+	case DRM_XE_OBSERVATION_OP_STREAM_OPEN:
+		return xe_eu_stall_stream_open(dev, arg->param, file);
+	default:
+		return -EINVAL;
+	}
+}
+
 /**
  * xe_observation_ioctl - The top level observation layer ioctl
  * @dev: @drm_device
@@ -51,6 +63,8 @@ int xe_observation_ioctl(struct drm_device *dev, void *data, struct drm_file *fi
 	switch (arg->observation_type) {
 	case DRM_XE_OBSERVATION_TYPE_OA:
 		return xe_oa_ioctl(dev, arg, file);
+	case DRM_XE_OBSERVATION_TYPE_EU_STALL:
+		return xe_eu_stall_ioctl(dev, arg, file);
 	default:
 		return -EINVAL;
 	}
diff --git a/include/uapi/drm/xe_drm.h b/include/uapi/drm/xe_drm.h
index 892f54d3aa09..1d79621f267b 100644
--- a/include/uapi/drm/xe_drm.h
+++ b/include/uapi/drm/xe_drm.h
@@ -1496,6 +1496,8 @@ struct drm_xe_wait_user_fence {
 enum drm_xe_observation_type {
 	/** @DRM_XE_OBSERVATION_TYPE_OA: OA observation stream type */
 	DRM_XE_OBSERVATION_TYPE_OA,
+	/** @DRM_XE_OBSERVATION_TYPE_EU_STALL: EU stall sampling observation stream type */
+	DRM_XE_OBSERVATION_TYPE_EU_STALL,
 };
 
 /**
@@ -1848,6 +1850,42 @@ enum drm_xe_pxp_session_type {
 /* ID of the protected content session managed by Xe when PXP is active */
 #define DRM_XE_PXP_HWDRM_DEFAULT_SESSION 0xf
 
+/**
+ * enum drm_xe_eu_stall_property_id - EU stall sampling input property ids.
+ *
+ * These properties are passed to the driver at open as a chain of
+ * @drm_xe_ext_set_property structures with @property set to these
+ * properties' enums and @value set to the corresponding values of these
+ * properties. @drm_xe_user_extension base.name should be set to
+ * @DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY.
+ *
+ * With the file descriptor obtained from open, user space must enable
+ * the EU stall stream fd with @DRM_XE_OBSERVATION_IOCTL_ENABLE before
+ * calling read(). EIO errno from read() indicates HW dropped data
+ * due to full buffer.
+ */
+enum drm_xe_eu_stall_property_id {
+#define DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY		0
+	/**
+	 * @DRM_XE_EU_STALL_PROP_GT_ID: @gt_id of the GT on which
+	 * EU stall data will be captured.
+	 */
+	DRM_XE_EU_STALL_PROP_GT_ID = 1,
+
+	/**
+	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate
+	 * in GPU cycles.
+	 */
+	DRM_XE_EU_STALL_PROP_SAMPLE_RATE,
+
+	/**
+	 * @DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS: Minimum number of
+	 * EU stall data reports to be present in the kernel buffer
+	 * before unblocking poll or read that is blocked.
+	 */
+	DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS,
+};
+
 #if defined(__cplusplus)
 }
 #endif
-- 
2.48.1

[PATCH v9 3/8] drm/xe/eustall: Add support to init, enable and disable EU stall sampling

[Harish Chegondi]

Implement EU stall sampling APIs introduced in the previous patch for
Xe_HPC (PVC). Add register definitions and the code that accesses these
registers to the APIs.

Add initialization and clean up functions and their implementations,
EU stall enable and disable functions.

v9: Moved structure definitions from xe_eu_stall.h to xe_eu_stall.c
    Moved read and poll implementations to the next patch
    Used xe_bo_create_pin_map_at_aligned instead of xe_bo_create_pin_map
    Changed lock names as per review feedback
    Moved drop data handling into a subsequent patch
    Moved code around as per review feedback
v8: Updated copyright year in xe_eu_stall_regs.h to 2025.
    Renamed struct drm_xe_eu_stall_data_pvc to struct xe_eu_stall_data_pvc
    since it is a local structure.
v6: Fix buffer wrap around over write bug (Matt Olson)

Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
---
 drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h |  29 ++
 drivers/gpu/drm/xe/xe_eu_stall.c           | 379 ++++++++++++++++++++-
 drivers/gpu/drm/xe/xe_eu_stall.h           |   7 +-
 drivers/gpu/drm/xe/xe_gt.c                 |   6 +
 drivers/gpu/drm/xe/xe_gt_types.h           |   3 +
 5 files changed, 408 insertions(+), 16 deletions(-)
 create mode 100644 drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h

diff --git a/drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h b/drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h
new file mode 100644
index 000000000000..c53f57fdde65
--- /dev/null
+++ b/drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h
@@ -0,0 +1,29 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2025 Intel Corporation
+ */
+
+#ifndef _XE_EU_STALL_REGS_H_
+#define _XE_EU_STALL_REGS_H_
+
+#include "regs/xe_reg_defs.h"
+
+#define XEHPC_EUSTALL_BASE			XE_REG_MCR(0xe520)
+#define   XEHPC_EUSTALL_BASE_BUF_ADDR		REG_GENMASK(31, 6)
+#define   XEHPC_EUSTALL_BASE_XECORE_BUF_SZ	REG_GENMASK(5, 3)
+#define   XEHPC_EUSTALL_BASE_ENABLE_SAMPLING	REG_BIT(1)
+
+#define XEHPC_EUSTALL_BASE_UPPER		XE_REG_MCR(0xe524)
+
+#define XEHPC_EUSTALL_REPORT			XE_REG_MCR(0xe528, XE_REG_OPTION_MASKED)
+#define   XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK	REG_GENMASK(15, 2)
+#define   XEHPC_EUSTALL_REPORT_OVERFLOW_DROP	REG_BIT(1)
+
+#define XEHPC_EUSTALL_REPORT1			XE_REG_MCR(0xe52c, XE_REG_OPTION_MASKED)
+#define   XEHPC_EUSTALL_REPORT1_READ_PTR_MASK	REG_GENMASK(15, 2)
+
+#define XEHPC_EUSTALL_CTRL			XE_REG_MCR(0xe53c, XE_REG_OPTION_MASKED)
+#define   EUSTALL_MOCS				REG_GENMASK(9, 3)
+#define   EUSTALL_SAMPLE_RATE			REG_GENMASK(2, 0)
+
+#endif
diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
index 0ceb3091f81e..12afa9720971 100644
--- a/drivers/gpu/drm/xe/xe_eu_stall.c
+++ b/drivers/gpu/drm/xe/xe_eu_stall.c
@@ -8,17 +8,57 @@
 #include <linux/poll.h>
 #include <linux/types.h>
 
+#include <drm/drm_drv.h>
 #include <uapi/drm/xe_drm.h>
 
+#include "xe_bo.h"
 #include "xe_device.h"
 #include "xe_eu_stall.h"
+#include "xe_force_wake.h"
+#include "xe_gt_mcr.h"
 #include "xe_gt_printk.h"
 #include "xe_gt_topology.h"
 #include "xe_macros.h"
 #include "xe_observation.h"
+#include "xe_pm.h"
+
+#include "regs/xe_eu_stall_regs.h"
+#include "regs/xe_gt_regs.h"
+
+#define POLL_PERIOD_MS	10
 
 static size_t per_xecore_buf_size = SZ_512K;
 
+struct per_xecore_buf {
+	/* Buffer vaddr */
+	u8 *vaddr;
+	/* Write pointer */
+	u32 write;
+	/* Read pointer */
+	u32 read;
+	/* lock to protect read and write pointers */
+	struct mutex ptr_lock;
+};
+
+struct xe_eu_stall_data_stream {
+	bool enabled;
+	size_t data_record_size;
+	size_t per_xecore_buf_size;
+	unsigned int wait_num_reports;
+	unsigned int sampling_rate_mult;
+
+	struct xe_gt *gt;
+	struct xe_bo *bo;
+	struct per_xecore_buf *xecore_buf;
+};
+
+struct xe_eu_stall_gt {
+	/* Lock to protect stream */
+	struct mutex stream_lock;
+	/* EU stall data stream */
+	struct xe_eu_stall_data_stream *stream;
+};
+
 /**
  * struct eu_stall_open_properties - EU stall sampling properties received
  *				     from user space at open.
@@ -33,6 +73,47 @@ struct eu_stall_open_properties {
 	struct xe_gt *gt;
 };
 
+/**
+ * struct xe_eu_stall_data_pvc - EU stall data format for PVC
+ *			Bits		Field
+ * @ip_addr:		0  to 28	IP (addr)
+ * @active_count:	29 to 36	active count
+ * @other_count:	37 to 44	other count
+ * @control_count:	45 to 52	control count
+ * @pipestall_count:	53 to 60	pipestall count
+ * @send_count:		61 to 68	send count
+ * @dist_acc_count:	69 to 76	dist_acc count
+ * @sbid_count:		77 to 84	sbid count
+ * @sync_count:		85 to 92	sync count
+ * @inst_fetch_count:	93 to 100	inst_fetch count
+ * @unused_bits:	101 to 127	unused bits
+ * @unused:		remaining	unused bytes
+ */
+struct xe_eu_stall_data_pvc {
+	__u64 ip_addr:29;
+	__u64 active_count:8;
+	__u64 other_count:8;
+	__u64 control_count:8;
+	__u64 pipestall_count:8;
+	__u64 send_count:8;
+	__u64 dist_acc_count:8;
+	__u64 sbid_count:8;
+	__u64 sync_count:8;
+	__u64 inst_fetch_count:8;
+	__u64 unused_bits:27;
+	__u64 unused[6];
+} __packed;
+
+static size_t xe_eu_stall_data_record_size(struct xe_device *xe)
+{
+	unsigned long record_size = 0;
+
+	if (xe->info.platform == XE_PVC)
+		record_size = sizeof(struct xe_eu_stall_data_pvc);
+
+	return record_size;
+}
+
 /**
  * num_data_rows - Return the number of EU stall data rows of 64B each
  *		   for a given data size.
@@ -44,6 +125,36 @@ static u32 num_data_rows(u32 data_size)
 	return (data_size >> 6);
 }
 
+/**
+ * xe_eu_stall_init() - Allocate and initialize GT level EU stall data
+ *			structure xe_eu_stall_gt within struct xe_gt.
+ *
+ * @gt: GT being initialized.
+ *
+ * Returns: zero on success or a negative error code.
+ */
+int xe_eu_stall_init(struct xe_gt *gt)
+{
+	gt->eu_stall = kzalloc(sizeof(*gt->eu_stall), GFP_KERNEL);
+	if (!gt->eu_stall)
+		return -ENOMEM;
+
+	mutex_init(&gt->eu_stall->stream_lock);
+	return 0;
+}
+
+/**
+ * xe_eu_stall_fini() - Clean up the GT level EU stall data
+ *			structure xe_eu_stall_gt within struct xe_gt.
+ *
+ * @gt: GT being cleaned up.
+ */
+void xe_eu_stall_fini(struct xe_gt *gt)
+{
+	mutex_destroy(&gt->eu_stall->stream_lock);
+	kfree(gt->eu_stall);
+}
+
 static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
 					   struct eu_stall_open_properties *props)
 {
@@ -166,6 +277,120 @@ static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
 	return ret;
 }
 
+static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
+{
+	if (stream->bo)
+		xe_bo_unpin_map_no_vm(stream->bo);
+}
+
+static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
+				   u16 num_xecore)
+{
+	struct xe_tile *tile = stream->gt->tile;
+	struct xe_bo *bo;
+	u32 size;
+
+	size = stream->per_xecore_buf_size * num_xecore;
+
+	bo = xe_bo_create_pin_map_at_aligned(tile->xe, tile, NULL,
+					     size, ~0ull, ttm_bo_type_kernel,
+					     XE_BO_FLAG_SYSTEM | XE_BO_FLAG_GGTT, SZ_64);
+	if (IS_ERR(bo))
+		return PTR_ERR(bo);
+
+	XE_WARN_ON(!IS_ALIGNED(xe_bo_ggtt_addr(bo), SZ_64));
+	stream->bo = bo;
+
+	return 0;
+}
+
+static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
+{
+	u32 write_ptr_reg, write_ptr, read_ptr_reg, reg_value;
+	struct per_xecore_buf *xecore_buf;
+	struct xe_gt *gt = stream->gt;
+	u16 group, instance;
+	unsigned int fw_ref;
+	int xecore;
+
+	/* Take runtime pm ref and forcewake to disable RC6 */
+	xe_pm_runtime_get(gt_to_xe(gt));
+	fw_ref = xe_force_wake_get(gt_to_fw(gt), XE_FW_RENDER);
+	if (!xe_force_wake_ref_has_domain(fw_ref, XE_FW_RENDER)) {
+		xe_gt_err(gt, "Failed to get RENDER forcewake\n");
+		xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
+		xe_pm_runtime_put(gt_to_xe(gt));
+		return -ETIMEDOUT;
+	}
+
+	for_each_dss_steering(xecore, gt, group, instance) {
+		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
+		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
+		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
+		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
+		/* Initialize the read pointer to the write pointer */
+		xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
+		write_ptr <<= 6;
+		write_ptr &= (stream->per_xecore_buf_size << 1) - 1;
+		xecore_buf = &stream->xecore_buf[xecore];
+		xecore_buf->write = write_ptr;
+		xecore_buf->read = write_ptr;
+	}
+	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
+				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
+				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
+						 stream->sampling_rate_mult));
+	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_CTRL, reg_value);
+	/* GGTT addresses can never be > 32 bits */
+	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE_UPPER, 0);
+	reg_value = xe_bo_ggtt_addr(stream->bo);
+	reg_value |= REG_FIELD_PREP(XEHPC_EUSTALL_BASE_XECORE_BUF_SZ, 2);
+	reg_value |= XEHPC_EUSTALL_BASE_ENABLE_SAMPLING;
+	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, reg_value);
+
+	return 0;
+}
+
+static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
+				   struct eu_stall_open_properties *props)
+{
+	struct per_xecore_buf *xecore_buf;
+	u16 num_xecore, group, instance;
+	struct xe_gt *gt = stream->gt;
+	xe_dss_mask_t all_xecore;
+	u32 vaddr_offset;
+	int ret, xecore;
+
+	stream->sampling_rate_mult = props->sampling_rate_mult;
+	stream->wait_num_reports = props->wait_num_reports;
+	stream->per_xecore_buf_size = per_xecore_buf_size;
+	stream->data_record_size = xe_eu_stall_data_record_size(gt_to_xe(gt));
+
+	bitmap_or(all_xecore, gt->fuse_topo.g_dss_mask, gt->fuse_topo.c_dss_mask,
+		  XE_MAX_DSS_FUSE_BITS);
+	/*
+	 * Enabled subslices can be discontiguous. Find the maximum number of subslices
+	 * that are enabled.
+	 */
+	num_xecore = xe_gt_topology_mask_last_dss(all_xecore) + 1;
+
+	ret = alloc_eu_stall_data_buf(stream, num_xecore);
+	if (ret)
+		return ret;
+
+	stream->xecore_buf = kcalloc(num_xecore, sizeof(*stream->xecore_buf), GFP_KERNEL);
+	if (!stream->xecore_buf)
+		return -ENOMEM;
+
+	for_each_dss_steering(xecore, gt, group, instance) {
+		xecore_buf = &stream->xecore_buf[xecore];
+		vaddr_offset = xecore * stream->per_xecore_buf_size;
+		xecore_buf->vaddr = stream->bo->vmap.vaddr + vaddr_offset;
+		mutex_init(&xecore_buf->ptr_lock);
+	}
+	return 0;
+}
+
 /**
  * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
  *
@@ -181,6 +406,49 @@ static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
 	return ret;
 }
 
+static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
+{
+	int ret = 0;
+
+	if (stream->enabled)
+		return ret;
+
+	stream->enabled = true;
+
+	ret = xe_eu_stall_stream_enable(stream);
+	return ret;
+}
+
+static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
+{
+	struct xe_gt *gt = stream->gt;
+
+	if (!stream->enabled)
+		return 0;
+
+	stream->enabled = false;
+
+	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
+
+	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
+	xe_pm_runtime_put(gt_to_xe(gt));
+
+	return 0;
+}
+
+static long xe_eu_stall_stream_ioctl_locked(struct xe_eu_stall_data_stream *stream,
+					    unsigned int cmd, unsigned long arg)
+{
+	switch (cmd) {
+	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
+		return xe_eu_stall_enable_locked(stream);
+	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
+		return xe_eu_stall_disable_locked(stream);
+	}
+
+	return -EINVAL;
+}
+
 /**
  * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
  *
@@ -195,14 +463,22 @@ static long xe_eu_stall_stream_ioctl(struct file *file,
 				     unsigned int cmd,
 				     unsigned long arg)
 {
-	switch (cmd) {
-	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
-		return 0;
-	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
-		return 0;
-	}
+	struct xe_eu_stall_data_stream *stream = file->private_data;
+	struct xe_gt *gt = stream->gt;
+	long ret;
 
-	return -EINVAL;
+	mutex_lock(&gt->eu_stall->stream_lock);
+	ret = xe_eu_stall_stream_ioctl_locked(stream, cmd, arg);
+	mutex_unlock(&gt->eu_stall->stream_lock);
+
+	return ret;
+}
+
+static void
+xe_eu_stall_stream_close_locked(struct xe_eu_stall_data_stream *stream)
+{
+	xe_eu_stall_disable_locked(stream);
+	free_eu_stall_data_buf(stream);
 }
 
 /**
@@ -215,6 +491,19 @@ static long xe_eu_stall_stream_ioctl(struct file *file,
  */
 static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
 {
+	struct xe_eu_stall_data_stream *stream = file->private_data;
+	struct xe_gt *gt = stream->gt;
+
+	mutex_lock(&gt->eu_stall->stream_lock);
+	xe_eu_stall_stream_close_locked(stream);
+	kfree(stream->xecore_buf);
+	kfree(stream);
+	gt->eu_stall->stream = NULL;
+	mutex_unlock(&gt->eu_stall->stream_lock);
+
+	/* Release the reference the EU stall stream kept on the driver */
+	drm_dev_put(&gt->tile->xe->drm);
+
 	return 0;
 }
 
@@ -230,7 +519,67 @@ static const struct file_operations fops_eu_stall = {
 
 static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
 {
-	return false;
+	return ((xe->info.platform == XE_PVC) ? true : false);
+}
+
+/**
+ * xe_eu_stall_stream_open_locked - Open a EU stall data stream FD.
+ * @dev: drm device instance
+ * @props: individually validated u64 property value pairs
+ * @file: drm file
+ *
+ * Returns: zero on success or a negative error code.
+ */
+static int
+xe_eu_stall_stream_open_locked(struct drm_device *dev,
+			       struct eu_stall_open_properties *props,
+			       struct drm_file *file)
+{
+	struct xe_eu_stall_data_stream *stream;
+	struct xe_gt *gt = props->gt;
+	unsigned long f_flags = 0;
+	int ret, stream_fd;
+
+	/* Only one session can be active at any time */
+	if (gt->eu_stall->stream) {
+		xe_gt_dbg(gt, "EU stall sampling session already active\n");
+		return -EBUSY;
+	}
+
+	stream = kzalloc(sizeof(*stream), GFP_KERNEL);
+	if (!stream)
+		return -ENOMEM;
+
+	gt->eu_stall->stream = stream;
+	stream->gt = gt;
+
+	ret = xe_eu_stall_stream_init(stream, props);
+	if (ret) {
+		xe_gt_dbg(gt, "EU stall stream init failed : %d\n", ret);
+		goto err_alloc;
+	}
+
+	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, stream, f_flags);
+	if (stream_fd < 0) {
+		ret = stream_fd;
+		xe_gt_dbg(gt, "EU stall inode get fd failed : %d\n", ret);
+		goto err_open;
+	}
+
+	/* Take a reference on the driver that will be kept with stream_fd
+	 * until its release.
+	 */
+	drm_dev_get(&gt->tile->xe->drm);
+
+	return stream_fd;
+
+err_open:
+	free_eu_stall_data_buf(stream);
+err_alloc:
+	gt->eu_stall->stream = NULL;
+	kfree(stream->xecore_buf);
+	kfree(stream);
+	return ret;
 }
 
 /**
@@ -252,7 +601,7 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
 {
 	struct xe_device *xe = to_xe_device(dev);
 	struct eu_stall_open_properties props = {};
-	int ret, stream_fd;
+	int ret;
 
 	if (xe_observation_paranoid && !perfmon_capable()) {
 		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
@@ -263,6 +612,10 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
 		return -EPERM;
 	}
 
+	/* Initialize and set default values */
+	props.wait_num_reports = 1;
+	props.sampling_rate_mult = 4;
+
 	ret = xe_eu_stall_user_extensions(xe, data, &props);
 	if (ret)
 		return ret;
@@ -272,9 +625,9 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
 		return -EINVAL;
 	}
 
-	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
-	if (stream_fd < 0)
-		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
+	mutex_lock(&props.gt->eu_stall->stream_lock);
+	ret = xe_eu_stall_stream_open_locked(dev, &props, file);
+	mutex_unlock(&props.gt->eu_stall->stream_lock);
 
-	return stream_fd;
+	return ret;
 }
diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
index d514e78341d5..e42250c1d294 100644
--- a/drivers/gpu/drm/xe/xe_eu_stall.h
+++ b/drivers/gpu/drm/xe/xe_eu_stall.h
@@ -6,9 +6,10 @@
 #ifndef __XE_EU_STALL_H__
 #define __XE_EU_STALL_H__
 
-#include <drm/drm_device.h>
-#include <drm/drm_file.h>
-#include <linux/types.h>
+#include "xe_gt_types.h"
+
+int xe_eu_stall_init(struct xe_gt *gt);
+void xe_eu_stall_fini(struct xe_gt *gt);
 
 int xe_eu_stall_stream_open(struct drm_device *dev,
 			    u64 data,
diff --git a/drivers/gpu/drm/xe/xe_gt.c b/drivers/gpu/drm/xe/xe_gt.c
index 9fb8f1e678dc..ee5a16727300 100644
--- a/drivers/gpu/drm/xe/xe_gt.c
+++ b/drivers/gpu/drm/xe/xe_gt.c
@@ -60,6 +60,7 @@
 #include "xe_vm.h"
 #include "xe_wa.h"
 #include "xe_wopcm.h"
+#include "xe_eu_stall.h"
 
 static void gt_fini(struct drm_device *drm, void *arg)
 {
@@ -159,6 +160,7 @@ void xe_gt_remove(struct xe_gt *gt)
 		xe_hw_fence_irq_finish(&gt->fence_irq[i]);
 
 	xe_gt_disable_host_l2_vram(gt);
+	xe_eu_stall_fini(gt);
 }
 
 static void gt_reset_worker(struct work_struct *w);
@@ -625,6 +627,10 @@ int xe_gt_init(struct xe_gt *gt)
 
 	xe_gt_record_user_engines(gt);
 
+	err = xe_eu_stall_init(gt);
+	if (err)
+		return err;
+
 	return 0;
 }
 
diff --git a/drivers/gpu/drm/xe/xe_gt_types.h b/drivers/gpu/drm/xe/xe_gt_types.h
index 6e66bf0e8b3f..833a1a67e9ae 100644
--- a/drivers/gpu/drm/xe/xe_gt_types.h
+++ b/drivers/gpu/drm/xe/xe_gt_types.h
@@ -430,6 +430,9 @@ struct xe_gt {
 
 	/** @oa: oa observation subsystem per gt info */
 	struct xe_oa_gt oa;
+
+	/** @eu_stall: EU stall counters subsystem per gt info */
+	struct xe_eu_stall_gt *eu_stall;
 };
 
 #endif
-- 
2.48.1

[PATCH v9 4/8] drm/xe/eustall: Add support to read() and poll() EU stall data

[Harish Chegondi]

Implement the EU stall sampling APIs to read() and poll() EU stall data.
A work function periodically polls the EU stall data buffer write pointer
registers to look for any new data and caches the write pointer. The read
function compares the cached read and write pointers and copies any new
data to the user space.

v9:  New patch split from the previous patch.
     Used *_delayed_work functions instead of hrtimer
     Addressed the review feedback in read and poll functions

Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
---
 drivers/gpu/drm/xe/xe_eu_stall.c | 267 ++++++++++++++++++++++++++++++-
 drivers/gpu/drm/xe/xe_trace.h    |  33 ++++
 2 files changed, 298 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
index 12afa9720971..53f17aac7d3b 100644
--- a/drivers/gpu/drm/xe/xe_eu_stall.c
+++ b/drivers/gpu/drm/xe/xe_eu_stall.c
@@ -21,6 +21,7 @@
 #include "xe_macros.h"
 #include "xe_observation.h"
 #include "xe_pm.h"
+#include "xe_trace.h"
 
 #include "regs/xe_eu_stall_regs.h"
 #include "regs/xe_gt_regs.h"
@@ -41,7 +42,9 @@ struct per_xecore_buf {
 };
 
 struct xe_eu_stall_data_stream {
+	bool pollin;
 	bool enabled;
+	wait_queue_head_t poll_wq;
 	size_t data_record_size;
 	size_t per_xecore_buf_size;
 	unsigned int wait_num_reports;
@@ -50,6 +53,8 @@ struct xe_eu_stall_data_stream {
 	struct xe_gt *gt;
 	struct xe_bo *bo;
 	struct per_xecore_buf *xecore_buf;
+	struct delayed_work buf_poll_work;
+	struct workqueue_struct *buf_poll_wq;
 };
 
 struct xe_eu_stall_gt {
@@ -256,6 +261,190 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
 	return 0;
 }
 
+/**
+ * buf_data_size - Calculate the number of bytes in a circular buffer
+ *		   given the read and write pointers and the size of
+ *		   the buffer.
+ *
+ * @buf_size: Size of the circular buffer
+ * @read_ptr: Read pointer with an additional overflow bit
+ * @write_ptr: Write pointer with an additional overflow bit
+ *
+ * Since the read and write pointers have an additional overflow bit,
+ * this function calculates the offsets from the pointers and use the
+ * offsets to calculate the data size in the buffer.
+ *
+ * Returns: number of bytes of data in the buffer
+ */
+static u32 buf_data_size(size_t buf_size, u32 read_ptr, u32 write_ptr)
+{
+	u32 read_offset, write_offset, size = 0;
+
+	if (read_ptr == write_ptr)
+		goto exit;
+
+	read_offset = read_ptr & (buf_size - 1);
+	write_offset = write_ptr & (buf_size - 1);
+
+	if (write_offset > read_offset)
+		size = write_offset - read_offset;
+	else
+		size = buf_size - read_offset + write_offset;
+exit:
+	return size;
+}
+
+/**
+ * eu_stall_data_buf_poll - Poll for EU stall data in the buffer.
+ *
+ * @stream: xe EU stall data stream instance
+ *
+ * Returns: true if the EU stall buffer contains minimum stall data as
+ *	    specified by the event report count, else false.
+ */
+static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
+{
+	u32 read_ptr, write_ptr_reg, write_ptr, total_data = 0;
+	u32 buf_size = stream->per_xecore_buf_size;
+	struct per_xecore_buf *xecore_buf;
+	struct xe_gt *gt = stream->gt;
+	bool min_data_present = false;
+	u16 group, instance;
+	unsigned int xecore;
+
+	for_each_dss_steering(xecore, gt, group, instance) {
+		xecore_buf = &stream->xecore_buf[xecore];
+		mutex_lock(&xecore_buf->ptr_lock);
+		read_ptr = xecore_buf->read;
+		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT,
+						       group, instance);
+		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
+		write_ptr <<= 6;
+		write_ptr &= ((buf_size << 1) - 1);
+		if (write_ptr != read_ptr && !min_data_present) {
+			total_data += buf_data_size(buf_size, read_ptr, write_ptr);
+			/*
+			 * Check if there are at least minimum number of stall data
+			 * rows for poll() to indicate that the data is present.
+			 * Each stall data row is 64B (cacheline size).
+			 */
+			if (num_data_rows(total_data) >= stream->wait_num_reports)
+				min_data_present = true;
+		}
+		xecore_buf->write = write_ptr;
+		mutex_unlock(&xecore_buf->ptr_lock);
+	}
+	return min_data_present;
+}
+
+static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
+				     char __user *buf, size_t count,
+				     size_t *total_data_size, struct xe_gt *gt,
+				     u16 group, u16 instance, unsigned int xecore)
+{
+	size_t read_data_size, copy_size, buf_size, data_record_size;
+	u32 read_ptr_reg, read_ptr, write_ptr;
+	u8 *xecore_start_vaddr, *read_vaddr;
+	struct per_xecore_buf *xecore_buf;
+	u32 read_offset, write_offset;
+	int ret = 0;
+
+	/* Hardware increments the read and write pointers such that they can
+	 * overflow into one additional bit. For example, a 256KB size buffer
+	 * offset pointer needs 18 bits. But HW uses 19 bits for the read and
+	 * write pointers. This technique avoids wasting a slot in the buffer.
+	 * Read and write offsets are calculated from the pointers in order to
+	 * check if the write pointer has wrapped around the array.
+	 */
+	xecore_buf = &stream->xecore_buf[xecore];
+	mutex_lock(&xecore_buf->ptr_lock);
+	xecore_start_vaddr = xecore_buf->vaddr;
+	read_ptr = xecore_buf->read;
+	write_ptr = xecore_buf->write;
+	buf_size = stream->per_xecore_buf_size;
+	data_record_size = stream->data_record_size;
+
+	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
+	/* Read only the data that the user space buffer can accommodate */
+	if ((*total_data_size + read_data_size) > count) {
+		read_data_size = count - *total_data_size;
+		read_data_size = (read_data_size / data_record_size) * data_record_size;
+	}
+	if (read_data_size == 0)
+		goto exit;
+
+	read_offset = read_ptr & (buf_size - 1);
+	write_offset = write_ptr & (buf_size - 1);
+	read_vaddr = xecore_start_vaddr + read_offset;
+
+	if (write_offset > read_offset) {
+		if (copy_to_user((buf + *total_data_size), read_vaddr, read_data_size)) {
+			ret = -EFAULT;
+			goto exit;
+		}
+	} else {
+		if (read_data_size >= (buf_size - read_offset))
+			copy_size = buf_size - read_offset;
+		else
+			copy_size = read_data_size;
+		if (copy_to_user((buf + *total_data_size), read_vaddr, copy_size)) {
+			ret = -EFAULT;
+			goto exit;
+		}
+		if (copy_to_user((buf + *total_data_size + copy_size),
+				 xecore_start_vaddr, read_data_size - copy_size)) {
+			ret = -EFAULT;
+			goto exit;
+		}
+	}
+
+	*total_data_size += read_data_size;
+	read_ptr += read_data_size;
+
+	/* Read pointer can overflow into one additional bit */
+	read_ptr &= (buf_size << 1) - 1;
+	read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, (read_ptr >> 6));
+	read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
+	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
+	xecore_buf->read = read_ptr;
+	trace_xe_eu_stall_data_read(group, instance, read_ptr, write_ptr,
+				    read_offset, write_offset, *total_data_size);
+exit:
+	mutex_unlock(&xecore_buf->ptr_lock);
+	return ret;
+}
+
+/**
+ * xe_eu_stall_stream_read_locked - copy EU stall counters data from the
+ *				    per xecore buffers to the userspace buffer
+ * @stream: A stream opened for EU stall count metrics
+ * @file: An xe EU stall data stream file
+ * @buf: destination buffer given by userspace
+ * @count: the number of bytes userspace wants to read
+ *
+ * Returns: Number of bytes copied or a negative error code
+ * If we've successfully copied any data then reporting that takes
+ * precedence over any internal error status, so the data isn't lost.
+ */
+static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *stream,
+					      struct file *file, char __user *buf,
+					      size_t count)
+{
+	struct xe_gt *gt = stream->gt;
+	size_t total_size = 0;
+	u16 group, instance;
+	unsigned int xecore;
+	int ret = 0;
+
+	for_each_dss_steering(xecore, gt, group, instance) {
+		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
+						gt, group, instance, xecore);
+		if (ret || count == total_size)
+			break;
+	}
+	return total_size ?: (ret ?: -EAGAIN);
+}
+
 /**
  * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
  *
@@ -272,7 +461,35 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
 static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
 				       size_t count, loff_t *ppos)
 {
-	ssize_t ret = 0;
+	struct xe_eu_stall_data_stream *stream = file->private_data;
+	struct xe_gt *gt = stream->gt;
+	ssize_t ret;
+
+	if (count == 0)
+		return -EINVAL;
+
+	if (!stream->enabled) {
+		xe_gt_dbg(gt, "EU stall data stream not enabled to read\n");
+		return -EINVAL;
+	}
+
+	if (!(file->f_flags & O_NONBLOCK)) {
+		do {
+			ret = wait_event_interruptible(stream->poll_wq, stream->pollin);
+			if (ret)
+				return -EINTR;
+
+			mutex_lock(&gt->eu_stall->stream_lock);
+			ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
+			mutex_unlock(&gt->eu_stall->stream_lock);
+		} while (ret == -EAGAIN);
+	} else {
+		mutex_lock(&gt->eu_stall->stream_lock);
+		ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
+		mutex_unlock(&gt->eu_stall->stream_lock);
+	}
+
+	stream->pollin = false;
 
 	return ret;
 }
@@ -281,6 +498,7 @@ static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
 {
 	if (stream->bo)
 		xe_bo_unpin_map_no_vm(stream->bo);
+	destroy_workqueue(stream->buf_poll_wq);
 }
 
 static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
@@ -351,6 +569,21 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
 	return 0;
 }
 
+static void eu_stall_data_buf_poll_work_fn(struct work_struct *work)
+{
+	struct xe_eu_stall_data_stream *stream =
+		container_of(work, typeof(*stream), buf_poll_work.work);
+
+	if (eu_stall_data_buf_poll(stream)) {
+		stream->pollin = true;
+		wake_up(&stream->poll_wq);
+	}
+	if (stream->enabled)
+		queue_delayed_work(stream->buf_poll_wq,
+				   &stream->buf_poll_work,
+				   msecs_to_jiffies(POLL_PERIOD_MS));
+}
+
 static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
 				   struct eu_stall_open_properties *props)
 {
@@ -361,6 +594,11 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
 	u32 vaddr_offset;
 	int ret, xecore;
 
+	init_waitqueue_head(&stream->poll_wq);
+	INIT_DELAYED_WORK(&stream->buf_poll_work, eu_stall_data_buf_poll_work_fn);
+	stream->buf_poll_wq = alloc_ordered_workqueue("xe_eu_stall", 0);
+	if (!stream->buf_poll_wq)
+		return -ENOMEM;
 	stream->sampling_rate_mult = props->sampling_rate_mult;
 	stream->wait_num_reports = props->wait_num_reports;
 	stream->per_xecore_buf_size = per_xecore_buf_size;
@@ -391,6 +629,19 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
 	return 0;
 }
 
+static __poll_t xe_eu_stall_stream_poll_locked(struct xe_eu_stall_data_stream *stream,
+					       struct file *file, poll_table *wait)
+{
+	__poll_t events = 0;
+
+	poll_wait(file, &stream->poll_wq, wait);
+
+	if (stream->pollin)
+		events |= EPOLLIN;
+
+	return events;
+}
+
 /**
  * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
  *
@@ -401,7 +652,13 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
  */
 static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
 {
-	__poll_t ret = 0;
+	struct xe_eu_stall_data_stream *stream = file->private_data;
+	struct xe_gt *gt = stream->gt;
+	__poll_t ret;
+
+	mutex_lock(&gt->eu_stall->stream_lock);
+	ret = xe_eu_stall_stream_poll_locked(stream, file, wait);
+	mutex_unlock(&gt->eu_stall->stream_lock);
 
 	return ret;
 }
@@ -416,6 +673,9 @@ static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
 	stream->enabled = true;
 
 	ret = xe_eu_stall_stream_enable(stream);
+	queue_delayed_work(stream->buf_poll_wq,
+			   &stream->buf_poll_work,
+			   msecs_to_jiffies(POLL_PERIOD_MS));
 	return ret;
 }
 
@@ -429,6 +689,9 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
 	stream->enabled = false;
 
 	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
+	/* Check for any new EU stall data one last time */
+	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);
+	flush_delayed_work(&stream->buf_poll_work);
 
 	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
 	xe_pm_runtime_put(gt_to_xe(gt));
diff --git a/drivers/gpu/drm/xe/xe_trace.h b/drivers/gpu/drm/xe/xe_trace.h
index d5281de04d54..1cc6bfc34ccb 100644
--- a/drivers/gpu/drm/xe/xe_trace.h
+++ b/drivers/gpu/drm/xe/xe_trace.h
@@ -427,6 +427,39 @@ DEFINE_EVENT(xe_pm_runtime, xe_pm_runtime_get_ioctl,
 	     TP_ARGS(xe, caller)
 );
 
+TRACE_EVENT(xe_eu_stall_data_read,
+	    TP_PROTO(u8 slice, u8 subslice,
+		     u32 read_ptr, u32 write_ptr,
+		     u32 read_offset, u32 write_offset,
+		     size_t total_size),
+	    TP_ARGS(slice, subslice, read_ptr, write_ptr,
+		    read_offset, write_offset, total_size),
+
+	    TP_STRUCT__entry(__field(u8, slice)
+			     __field(u8, subslice)
+			     __field(u32, read_ptr)
+			     __field(u32, write_ptr)
+			     __field(u32, read_offset)
+			     __field(u32, write_offset)
+			     __field(size_t, total_size)
+			     ),
+
+	    TP_fast_assign(__entry->slice = slice;
+			   __entry->subslice = subslice;
+			   __entry->read_ptr = read_ptr;
+			   __entry->write_ptr = write_ptr;
+			   __entry->read_offset = read_offset;
+			   __entry->write_offset = write_offset;
+			   __entry->total_size = total_size;
+			   ),
+
+	    TP_printk("slice:%u subslice:%u readptr:0x%x writeptr:0x%x read off:%u write off:%u size:%zu ",
+		      __entry->slice, __entry->subslice,
+		      __entry->read_ptr, __entry->write_ptr,
+		      __entry->read_offset, __entry->write_offset,
+		      __entry->total_size)
+);
+
 #endif
 
 /* This part must be outside protection */
-- 
2.48.1

[PATCH v9 5/8] drm/xe/eustall: Add support to handle dropped EU stall data

[Harish Chegondi]

If the user space doesn't read the EU stall data fast enough,
it is possible that the EU stall data buffer can get filled,
and if the hardware wants to write more data, it simply drops
data due to unavailable buffer space. In that case, hardware
sets a bit in a register. If the driver detects data drop,
the driver read() returns -EIO error to let the user space
know that HW has dropped data. The -EIO error is returned
even if there is EU stall data in the buffer. A subsequent
read by the user space returns the remaining EU stall data.

v9:  Move all data drop handling code to this patch
     Clear all drop data bits before returning -EIO.

Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
---
 drivers/gpu/drm/xe/xe_eu_stall.c | 39 ++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
index 53f17aac7d3b..428267010805 100644
--- a/drivers/gpu/drm/xe/xe_eu_stall.c
+++ b/drivers/gpu/drm/xe/xe_eu_stall.c
@@ -53,6 +53,10 @@ struct xe_eu_stall_data_stream {
 	struct xe_gt *gt;
 	struct xe_bo *bo;
 	struct per_xecore_buf *xecore_buf;
+	struct {
+		bool reported_to_user;
+		xe_dss_mask_t mask;
+	} data_drop;
 	struct delayed_work buf_poll_work;
 	struct workqueue_struct *buf_poll_wq;
 };
@@ -331,12 +335,24 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
 			if (num_data_rows(total_data) >= stream->wait_num_reports)
 				min_data_present = true;
 		}
+		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
+			set_bit(xecore, stream->data_drop.mask);
 		xecore_buf->write = write_ptr;
 		mutex_unlock(&xecore_buf->ptr_lock);
 	}
 	return min_data_present;
 }
 
+static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
+{
+	u32 write_ptr_reg;
+
+	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
+	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
+
+	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
+}
+
 static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
 				     char __user *buf, size_t count,
 				     size_t *total_data_size, struct xe_gt *gt,
@@ -436,6 +452,22 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
 	unsigned int xecore;
 	int ret = 0;
 
+	if (bitmap_weight(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS)) {
+		if (!stream->data_drop.reported_to_user) {
+			for_each_dss_steering(xecore, gt, group, instance) {
+				if (test_bit(xecore, stream->data_drop.mask)) {
+					clear_dropped_eviction_line_bit(gt, group, instance);
+					clear_bit(xecore, stream->data_drop.mask);
+				}
+			}
+			stream->data_drop.reported_to_user = true;
+			xe_gt_dbg(gt, "EU stall data dropped in XeCores: %*pb\n",
+				  XE_MAX_DSS_FUSE_BITS, stream->data_drop.mask);
+			return -EIO;
+		}
+		stream->data_drop.reported_to_user = false;
+	}
+
 	for_each_dss_steering(xecore, gt, group, instance) {
 		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
 						gt, group, instance, xecore);
@@ -457,6 +489,7 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
  * before calling read().
  *
  * Returns: The number of bytes copied or a negative error code on failure.
+ *	    -EIO if HW drops any EU stall data when the buffer is full.
  */
 static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
 				       size_t count, loff_t *ppos)
@@ -543,6 +576,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
 
 	for_each_dss_steering(xecore, gt, group, instance) {
 		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
+		/* Clear any drop bits set and not cleared in the previous session. */
+		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
+			clear_dropped_eviction_line_bit(gt, group, instance);
 		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
 		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
 		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
@@ -554,6 +590,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
 		xecore_buf->write = write_ptr;
 		xecore_buf->read = write_ptr;
 	}
+	stream->data_drop.reported_to_user = false;
+	bitmap_zero(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS);
+
 	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
 				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
 				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
-- 
2.48.1

[PATCH v9 6/8] drm/xe/eustall: Add EU stall sampling support for Xe2

[Harish Chegondi]

Add EU stall sampling support for Xe2 architecture GPUs - LNL and BMG.
EU stall data format for LNL and BMG is different from that of PVC.

v9: Use GRAPHICS_VER() check instead of platform

v8: Renamed struct drm_xe_eu_stall_data_xe2 to struct xe_eu_stall_data_xe2
    since it is a local structure.

Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
---
 drivers/gpu/drm/xe/xe_eu_stall.c | 51 ++++++++++++++++++++++++++++++--
 1 file changed, 48 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
index 428267010805..52f8f40ba9a6 100644
--- a/drivers/gpu/drm/xe/xe_eu_stall.c
+++ b/drivers/gpu/drm/xe/xe_eu_stall.c
@@ -113,12 +113,51 @@ struct xe_eu_stall_data_pvc {
 	__u64 unused[6];
 } __packed;
 
+/**
+ * struct xe_eu_stall_data_xe2 - EU stall data format for LNL, BMG
+ *			Bits		Field
+ * @ip_addr:		0  to 28	IP (addr)
+ * @tdr_count:		29 to 36	Tdr count
+ * @other_count:	37 to 44	other count
+ * @control_count:	45 to 52	control count
+ * @pipestall_count:	53 to 60	pipestall count
+ * @send_count:		61 to 68	send count
+ * @dist_acc_count:	69 to 76	dist_acc count
+ * @sbid_count:		77 to 84	sbid count
+ * @sync_count:		85 to 92	sync count
+ * @inst_fetch_count:	93 to 100	inst_fetch count
+ * @active_count:	101 to 108	Active count
+ * @ex_id:		109 to 111	Exid
+ * @end_flag:		112		EndFlag (is always 1)
+ * @unused_bits:	113 to 127	unused bits
+ * @unused:		remaining	unused bytes
+ */
+struct xe_eu_stall_data_xe2 {
+	__u64 ip_addr:29;
+	__u64 tdr_count:8;
+	__u64 other_count:8;
+	__u64 control_count:8;
+	__u64 pipestall_count:8;
+	__u64 send_count:8;
+	__u64 dist_acc_count:8;
+	__u64 sbid_count:8;
+	__u64 sync_count:8;
+	__u64 inst_fetch_count:8;
+	__u64 active_count:8;
+	__u64 ex_id:3;
+	__u64 end_flag:1;
+	__u64 unused_bits:15;
+	__u64 unused[6];
+} __packed;
+
 static size_t xe_eu_stall_data_record_size(struct xe_device *xe)
 {
 	unsigned long record_size = 0;
 
 	if (xe->info.platform == XE_PVC)
 		record_size = sizeof(struct xe_eu_stall_data_pvc);
+	else if (GRAPHICS_VER(xe) >= 20)
+		record_size = sizeof(struct xe_eu_stall_data_xe2);
 
 	return record_size;
 }
@@ -345,10 +384,16 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
 
 static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
 {
+	struct xe_device *xe = gt_to_xe(gt);
 	u32 write_ptr_reg;
 
-	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
-	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
+	/* On PVC, the overflow bit has to be cleared by writing 1 to it.
+	 * On other GPUs, the bit has to be cleared by writing 0 to it.
+	 */
+	if (GRAPHICS_VER(xe) >= 20)
+		write_ptr_reg = _MASKED_BIT_DISABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
+	else
+		write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
 
 	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
 }
@@ -821,7 +866,7 @@ static const struct file_operations fops_eu_stall = {
 
 static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
 {
-	return ((xe->info.platform == XE_PVC) ? true : false);
+	return ((xe->info.platform == XE_PVC || GRAPHICS_VER(xe) >= 20) ? true : false);
 }
 
 /**
-- 
2.48.1

[PATCH v9 7/8] drm/xe/uapi: Add a device query to get EU stall sampling information

[Harish Chegondi]

User space can get the EU stall data record size, EU stall capabilities,
EU stall sampling rates, and per XeCore buffer size with query IOCTL
DRM_IOCTL_XE_DEVICE_QUERY with .query set to DRM_XE_DEVICE_QUERY_EU_STALL.
A struct drm_xe_query_eu_stall will be returned to the user space along
with an array of supported sampling rates sorted in the fastest sampling
rate first order. sampling_rates in struct drm_xe_query_eu_stall will
point to the array of sampling rates.

Any capabilities in EU stall sampling as of this patch are considered
as base capabilities. New capability bits will be added for any new
functionality added later.

v9: Move reserved fields above num_sampling_rates in
    struct drm_xe_query_eu_stall.
v7: Change sampling_rates from a pointer to flexible array.
v6: Include EU stall sampling rates information and
    per XeCore buffer size in the query information.

Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
---
 drivers/gpu/drm/xe/xe_eu_stall.c | 43 ++++++++++++++++++++++++++++++--
 drivers/gpu/drm/xe/xe_eu_stall.h |  4 +++
 drivers/gpu/drm/xe/xe_query.c    | 38 ++++++++++++++++++++++++++++
 include/uapi/drm/xe_drm.h        | 40 +++++++++++++++++++++++++++--
 4 files changed, 121 insertions(+), 4 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
index 52f8f40ba9a6..4dce58f60405 100644
--- a/drivers/gpu/drm/xe/xe_eu_stall.c
+++ b/drivers/gpu/drm/xe/xe_eu_stall.c
@@ -150,9 +150,48 @@ struct xe_eu_stall_data_xe2 {
 	__u64 unused[6];
 } __packed;
 
-static size_t xe_eu_stall_data_record_size(struct xe_device *xe)
+const u64 eu_stall_sampling_rates[] = {251, 251 * 2, 251 * 3, 251 * 4, 251 * 5, 251 * 6, 251 * 7};
+
+/**
+ * xe_eu_stall_get_sampling_rates - get EU stall sampling rates information.
+ *
+ * @num_rates_ptr: Pointer to a u32 to return the number of sampling rates.
+ * @rates_ptr: double u64 pointer to point to an array of sampling rates.
+ *
+ * Stores the number of sampling rates and pointer to the array of
+ * sampling rates in the input pointers.
+ *
+ * Returns: Size of the EU stall sampling rates array.
+ */
+size_t xe_eu_stall_get_sampling_rates(u32 *num_rates_ptr, const u64 **rates_ptr)
+{
+	*num_rates_ptr = ARRAY_SIZE(eu_stall_sampling_rates);
+	*rates_ptr = eu_stall_sampling_rates;
+
+	return sizeof(eu_stall_sampling_rates);
+}
+
+/**
+ * xe_eu_stall_get_per_xecore_buf_size - get per XeCore buffer size.
+ *
+ * Returns: The per XeCore buffer size used to allocate the per GT
+ *	    EU stall data buffer.
+ */
+size_t xe_eu_stall_get_per_xecore_buf_size(void)
+{
+	return per_xecore_buf_size;
+}
+
+/**
+ * xe_eu_stall_data_record_size - get EU stall data record size.
+ *
+ * @xe: Pointer to a Xe device.
+ *
+ * Returns: EU stall data record size.
+ */
+size_t xe_eu_stall_data_record_size(struct xe_device *xe)
 {
-	unsigned long record_size = 0;
+	size_t record_size = 0;
 
 	if (xe->info.platform == XE_PVC)
 		record_size = sizeof(struct xe_eu_stall_data_pvc);
diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
index e42250c1d294..c612fbaf2901 100644
--- a/drivers/gpu/drm/xe/xe_eu_stall.h
+++ b/drivers/gpu/drm/xe/xe_eu_stall.h
@@ -8,6 +8,10 @@
 
 #include "xe_gt_types.h"
 
+size_t xe_eu_stall_get_per_xecore_buf_size(void);
+size_t xe_eu_stall_data_record_size(struct xe_device *xe);
+size_t xe_eu_stall_get_sampling_rates(u32 *num_rates_ptr,
+				      const u64 **rates_ptr);
 int xe_eu_stall_init(struct xe_gt *gt);
 void xe_eu_stall_fini(struct xe_gt *gt);
 
diff --git a/drivers/gpu/drm/xe/xe_query.c b/drivers/gpu/drm/xe/xe_query.c
index 042f87a688e7..2402bb6b221c 100644
--- a/drivers/gpu/drm/xe/xe_query.c
+++ b/drivers/gpu/drm/xe/xe_query.c
@@ -16,6 +16,7 @@
 #include "regs/xe_gt_regs.h"
 #include "xe_bo.h"
 #include "xe_device.h"
+#include "xe_eu_stall.h"
 #include "xe_exec_queue.h"
 #include "xe_force_wake.h"
 #include "xe_ggtt.h"
@@ -726,6 +727,42 @@ static int query_pxp_status(struct xe_device *xe, struct drm_xe_device_query *qu
 	return 0;
 }
 
+static int query_eu_stall(struct xe_device *xe,
+			  struct drm_xe_device_query *query)
+{
+	void __user *query_ptr = u64_to_user_ptr(query->data);
+	struct drm_xe_query_eu_stall *info;
+	size_t size, array_size;
+	const u64 *rates_ptr;
+	u32 num_rates;
+	int ret;
+
+	array_size = xe_eu_stall_get_sampling_rates(&num_rates, &rates_ptr);
+	size = sizeof(struct drm_xe_query_eu_stall) + array_size;
+
+	if (query->size == 0) {
+		query->size = size;
+		return 0;
+	} else if (XE_IOCTL_DBG(xe, query->size != size)) {
+		return -EINVAL;
+	}
+
+	info = kzalloc(size, GFP_KERNEL);
+	if (!info)
+		return -ENOMEM;
+
+	info->num_sampling_rates = num_rates;
+	info->capabilities = DRM_XE_EU_STALL_CAPS_BASE;
+	info->record_size = xe_eu_stall_data_record_size(xe);
+	info->per_xecore_buf_size = xe_eu_stall_get_per_xecore_buf_size();
+	memcpy(info->sampling_rates, rates_ptr, array_size);
+
+	ret = copy_to_user(query_ptr, info, size);
+	kfree(info);
+
+	return ret ? -EFAULT : 0;
+}
+
 static int (* const xe_query_funcs[])(struct xe_device *xe,
 				      struct drm_xe_device_query *query) = {
 	query_engines,
@@ -738,6 +775,7 @@ static int (* const xe_query_funcs[])(struct xe_device *xe,
 	query_uc_fw_version,
 	query_oa_units,
 	query_pxp_status,
+	query_eu_stall,
 };
 
 int xe_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
diff --git a/include/uapi/drm/xe_drm.h b/include/uapi/drm/xe_drm.h
index 1d79621f267b..c2c0983a9f2a 100644
--- a/include/uapi/drm/xe_drm.h
+++ b/include/uapi/drm/xe_drm.h
@@ -735,6 +735,7 @@ struct drm_xe_device_query {
 #define DRM_XE_DEVICE_QUERY_UC_FW_VERSION	7
 #define DRM_XE_DEVICE_QUERY_OA_UNITS		8
 #define DRM_XE_DEVICE_QUERY_PXP_STATUS		9
+#define DRM_XE_DEVICE_QUERY_EU_STALL		10
 	/** @query: The type of data to query */
 	__u32 query;
 
@@ -1873,8 +1874,8 @@ enum drm_xe_eu_stall_property_id {
 	DRM_XE_EU_STALL_PROP_GT_ID = 1,
 
 	/**
-	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate
-	 * in GPU cycles.
+	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate in
+	 * GPU cycles from @sampling_rates in struct @drm_xe_query_eu_stall
 	 */
 	DRM_XE_EU_STALL_PROP_SAMPLE_RATE,
 
@@ -1886,6 +1887,41 @@ enum drm_xe_eu_stall_property_id {
 	DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS,
 };
 
+/**
+ * struct drm_xe_query_eu_stall - Information about EU stall sampling.
+ *
+ * If a query is made with a struct @drm_xe_device_query where .query
+ * is equal to @DRM_XE_DEVICE_QUERY_EU_STALL, then the reply uses
+ * struct @drm_xe_query_eu_stall in .data.
+ */
+struct drm_xe_query_eu_stall {
+	/** @extensions: Pointer to the first extension struct, if any */
+	__u64 extensions;
+
+	/** @capabilities: EU stall capabilities bit-mask */
+	__u64 capabilities;
+#define DRM_XE_EU_STALL_CAPS_BASE		(1 << 0)
+
+	/** @record_size: size of each EU stall data record */
+	__u64 record_size;
+
+	/** @per_xecore_buf_size: Per XeCore buffer size */
+	__u64 per_xecore_buf_size;
+
+	/** @reserved: Reserved */
+	__u64 reserved[5];
+
+	/** @num_sampling_rates: Number of sampling rates supported */
+	__u64 num_sampling_rates;
+
+	/**
+	 * @sampling_rates: Flexible array of sampling rates
+	 * sorted in the fastest to slowest order.
+	 * Sampling rates are specified in GPU clock cycles.
+	 */
+	__u64 sampling_rates[];
+};
+
 #if defined(__cplusplus)
 }
 #endif
-- 
2.48.1

[PATCH v9 8/8] drm/xe/eustall: Add workaround 22016596838 which applies to PVC.

[Harish Chegondi]

Add PVC workaround 22016596838 that disables EU DOP gating
during EU stall sampling.

Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
---
 drivers/gpu/drm/xe/xe_eu_stall.c   | 10 ++++++++++
 drivers/gpu/drm/xe/xe_wa_oob.rules |  1 +
 2 files changed, 11 insertions(+)

diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
index 4dce58f60405..6acb87a25f78 100644
--- a/drivers/gpu/drm/xe/xe_eu_stall.c
+++ b/drivers/gpu/drm/xe/xe_eu_stall.c
@@ -9,6 +9,7 @@
 #include <linux/types.h>
 
 #include <drm/drm_drv.h>
+#include <generated/xe_wa_oob.h>
 #include <uapi/drm/xe_drm.h>
 
 #include "xe_bo.h"
@@ -22,6 +23,7 @@
 #include "xe_observation.h"
 #include "xe_pm.h"
 #include "xe_trace.h"
+#include "xe_wa.h"
 
 #include "regs/xe_eu_stall_regs.h"
 #include "regs/xe_gt_regs.h"
@@ -658,6 +660,10 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
 		return -ETIMEDOUT;
 	}
 
+	if (XE_WA(gt, 22016596838))
+		xe_gt_mcr_multicast_write(gt, ROW_CHICKEN2,
+					  _MASKED_BIT_ENABLE(DISABLE_DOP_GATING));
+
 	for_each_dss_steering(xecore, gt, group, instance) {
 		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
 		/* Clear any drop bits set and not cleared in the previous session. */
@@ -816,6 +822,10 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
 	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);
 	flush_delayed_work(&stream->buf_poll_work);
 
+	if (XE_WA(gt, 22016596838))
+		xe_gt_mcr_multicast_write(gt, ROW_CHICKEN2,
+					  _MASKED_BIT_DISABLE(DISABLE_DOP_GATING));
+
 	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
 	xe_pm_runtime_put(gt_to_xe(gt));
 
diff --git a/drivers/gpu/drm/xe/xe_wa_oob.rules b/drivers/gpu/drm/xe/xe_wa_oob.rules
index 228436532282..8e2cae7f7135 100644
--- a/drivers/gpu/drm/xe/xe_wa_oob.rules
+++ b/drivers/gpu/drm/xe/xe_wa_oob.rules
@@ -5,6 +5,7 @@
 22011391025	PLATFORM(DG2)
 22012727170	SUBPLATFORM(DG2, G11)
 22012727685	SUBPLATFORM(DG2, G11)
+22016596838	PLATFORM(PVC)
 18020744125	PLATFORM(PVC)
 1509372804	PLATFORM(PVC), GRAPHICS_STEP(A0, C0)
 1409600907	GRAPHICS_VERSION_RANGE(1200, 1250)
-- 
2.48.1

✓ CI.Patch_applied: success for Add support for EU stall sampling

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

=== Applying kernel patches on branch 'drm-tip' with base: ===
Base commit: 656e731586e5 drm-tip: 2025y-02m-10d-13h-06m-50s UTC integration manifest
=== git am output follows ===
Applying: drm/xe/topology: Add a function to find the index of the last enabled DSS in a mask
Applying: drm/xe/uapi: Introduce API for EU stall sampling
Applying: drm/xe/eustall: Add support to init, enable and disable EU stall sampling
Applying: drm/xe/eustall: Add support to read() and poll() EU stall data
Applying: drm/xe/eustall: Add support to handle dropped EU stall data
Applying: drm/xe/eustall: Add EU stall sampling support for Xe2
Applying: drm/xe/uapi: Add a device query to get EU stall sampling information
Applying: drm/xe/eustall: Add workaround 22016596838 which applies to PVC.

✗ CI.checkpatch: warning for Add support for EU stall sampling

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling
URL   : https://patchwork.freedesktop.org/series/144609/
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
22f9cda3436b4fe965b5c5f31d2f2c1bcb483189
+ cd /kernel
+ git config --global --add safe.directory /kernel
+ git log -n1
commit 2a84c579ede3aef33ef3ad47689de2e58919408d
Author: Harish Chegondi <harish.chegondi@intel.com>
Date:   Mon Feb 10 05:46:49 2025 -0800

    drm/xe/eustall: Add workaround 22016596838 which applies to PVC.
    
    Add PVC workaround 22016596838 that disables EU DOP gating
    during EU stall sampling.
    
    Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
+ /mt/dim checkpatch 656e731586e568a8633c0bd16d28dcec8d67f237 drm-intel
6a3956ad2764 drm/xe/topology: Add a function to find the index of the last enabled DSS in a mask
3bfb725caddb drm/xe/uapi: Introduce API for EU stall sampling
-:56: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#56: 
new file mode 100644

total: 0 errors, 1 warnings, 0 checks, 385 lines checked
c0bcdec48ead drm/xe/eustall: Add support to init, enable and disable EU stall sampling
-:28: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#28: 
new file mode 100644

total: 0 errors, 1 warnings, 0 checks, 531 lines checked
bf03308b6e3d drm/xe/eustall: Add support to read() and poll() EU stall data
f87b3ab276cc drm/xe/eustall: Add support to handle dropped EU stall data
bc376b13eca7 drm/xe/eustall: Add EU stall sampling support for Xe2
ce82acf1eb8d drm/xe/uapi: Add a device query to get EU stall sampling information
2a84c579ede3 drm/xe/eustall: Add workaround 22016596838 which applies to PVC.

✓ CI.KUnit: success for Add support for EU stall sampling

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

+ trap cleanup EXIT
+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig
[14:33:13] Configuring KUnit Kernel ...
Generating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[14:33:17] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json ARCH=um O=.kunit --jobs=48
../lib/iomap.c:156:5: warning: no previous prototype for ‘ioread64_lo_hi’ [-Wmissing-prototypes]
  156 | u64 ioread64_lo_hi(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~
../lib/iomap.c:163:5: warning: no previous prototype for ‘ioread64_hi_lo’ [-Wmissing-prototypes]
  163 | u64 ioread64_hi_lo(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~
../lib/iomap.c:170:5: warning: no previous prototype for ‘ioread64be_lo_hi’ [-Wmissing-prototypes]
  170 | u64 ioread64be_lo_hi(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~~~
../lib/iomap.c:178:5: warning: no previous prototype for ‘ioread64be_hi_lo’ [-Wmissing-prototypes]
  178 | u64 ioread64be_hi_lo(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~~~
../lib/iomap.c:264:6: warning: no previous prototype for ‘iowrite64_lo_hi’ [-Wmissing-prototypes]
  264 | void iowrite64_lo_hi(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~
../lib/iomap.c:272:6: warning: no previous prototype for ‘iowrite64_hi_lo’ [-Wmissing-prototypes]
  272 | void iowrite64_hi_lo(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~
../lib/iomap.c:280:6: warning: no previous prototype for ‘iowrite64be_lo_hi’ [-Wmissing-prototypes]
  280 | void iowrite64be_lo_hi(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~~~
../lib/iomap.c:288:6: warning: no previous prototype for ‘iowrite64be_hi_lo’ [-Wmissing-prototypes]
  288 | void iowrite64be_hi_lo(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~~~

[14:33:43] Starting KUnit Kernel (1/1)...
[14:33:43] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[14:33:44] ================== guc_buf (11 subtests) ===================
[14:33:44] [PASSED] test_smallest
[14:33:44] [PASSED] test_largest
[14:33:44] [PASSED] test_granular
[14:33:44] [PASSED] test_unique
[14:33:44] [PASSED] test_overlap
[14:33:44] [PASSED] test_reusable
[14:33:44] [PASSED] test_too_big
[14:33:44] [PASSED] test_flush
[14:33:44] [PASSED] test_lookup
[14:33:44] [PASSED] test_data
[14:33:44] [PASSED] test_class
[14:33:44] ===================== [PASSED] guc_buf =====================
[14:33:44] =================== guc_dbm (7 subtests) ===================
[14:33:44] [PASSED] test_empty
[14:33:44] [PASSED] test_default
[14:33:44] ======================== test_size  ========================
[14:33:44] [PASSED] 4
[14:33:44] [PASSED] 8
[14:33:44] [PASSED] 32
[14:33:44] [PASSED] 256
[14:33:44] ==================== [PASSED] test_size ====================
[14:33:44] ======================= test_reuse  ========================
[14:33:44] [PASSED] 4
[14:33:44] [PASSED] 8
[14:33:44] [PASSED] 32
[14:33:44] [PASSED] 256
[14:33:44] =================== [PASSED] test_reuse ====================
[14:33:44] =================== test_range_overlap  ====================
[14:33:44] [PASSED] 4
[14:33:44] [PASSED] 8
[14:33:44] [PASSED] 32
[14:33:44] [PASSED] 256
[14:33:44] =============== [PASSED] test_range_overlap ================
[14:33:44] =================== test_range_compact  ====================
[14:33:44] [PASSED] 4
[14:33:44] [PASSED] 8
[14:33:44] [PASSED] 32
[14:33:44] [PASSED] 256
[14:33:44] =============== [PASSED] test_range_compact ================
[14:33:44] ==================== test_range_spare  =====================
[14:33:44] [PASSED] 4
[14:33:44] [PASSED] 8
[14:33:44] [PASSED] 32
[14:33:44] [PASSED] 256
[14:33:44] ================ [PASSED] test_range_spare =================
[14:33:44] ===================== [PASSED] guc_dbm =====================
[14:33:44] =================== guc_idm (6 subtests) ===================
[14:33:44] [PASSED] bad_init
[14:33:44] [PASSED] no_init
[14:33:44] [PASSED] init_fini
[14:33:44] [PASSED] check_used
[14:33:44] [PASSED] check_quota
[14:33:44] [PASSED] check_all
[14:33:44] ===================== [PASSED] guc_idm =====================
[14:33:44] ================== no_relay (3 subtests) ===================
[14:33:44] [PASSED] xe_drops_guc2pf_if_not_ready
[14:33:44] [PASSED] xe_drops_guc2vf_if_not_ready
[14:33:44] [PASSED] xe_rejects_send_if_not_ready
[14:33:44] ==================== [PASSED] no_relay =====================
[14:33:44] ================== pf_relay (14 subtests) ==================
[14:33:44] [PASSED] pf_rejects_guc2pf_too_short
[14:33:44] [PASSED] pf_rejects_guc2pf_too_long
[14:33:44] [PASSED] pf_rejects_guc2pf_no_payload
[14:33:44] [PASSED] pf_fails_no_payload
[14:33:44] [PASSED] pf_fails_bad_origin
[14:33:44] [PASSED] pf_fails_bad_type
[14:33:44] [PASSED] pf_txn_reports_error
[14:33:44] [PASSED] pf_txn_sends_pf2guc
[14:33:44] [PASSED] pf_sends_pf2guc
[14:33:44] [SKIPPED] pf_loopback_nop
[14:33:44] [SKIPPED] pf_loopback_echo
[14:33:44] [SKIPPED] pf_loopback_fail
[14:33:44] [SKIPPED] pf_loopback_busy
[14:33:44] [SKIPPED] pf_loopback_retry
[14:33:44] ==================== [PASSED] pf_relay =====================
[14:33:44] ================== vf_relay (3 subtests) ===================
[14:33:44] [PASSED] vf_rejects_guc2vf_too_short
[14:33:44] [PASSED] vf_rejects_guc2vf_too_long
[14:33:44] [PASSED] vf_rejects_guc2vf_no_payload
[14:33:44] ==================== [PASSED] vf_relay =====================
[14:33:44] ================= pf_service (11 subtests) =================
[14:33:44] [PASSED] pf_negotiate_any
[14:33:44] [PASSED] pf_negotiate_base_match
[14:33:44] [PASSED] pf_negotiate_base_newer
[14:33:44] [PASSED] pf_negotiate_base_next
[14:33:44] [SKIPPED] pf_negotiate_base_older
[14:33:44] [PASSED] pf_negotiate_base_prev
[14:33:44] [PASSED] pf_negotiate_latest_match
[14:33:44] [PASSED] pf_negotiate_latest_newer
[14:33:44] [PASSED] pf_negotiate_latest_next
[14:33:44] [SKIPPED] pf_negotiate_latest_older
[14:33:44] [SKIPPED] pf_negotiate_latest_prev
[14:33:44] =================== [PASSED] pf_service ====================
[14:33:44] ===================== lmtt (1 subtest) =====================
[14:33:44] ======================== test_ops  =========================
[14:33:44] [PASSED] 2-level
[14:33:44] [PASSED] multi-level
[14:33:44] ==================== [PASSED] test_ops =====================
[14:33:44] ====================== [PASSED] lmtt =======================
[14:33:44] =================== xe_mocs (2 subtests) ===================
[14:33:44] ================ xe_live_mocs_kernel_kunit  ================
[14:33:44] =========== [SKIPPED] xe_live_mocs_kernel_kunit ============
[14:33:44] ================ xe_live_mocs_reset_kunit  =================
[14:33:44] ============ [SKIPPED] xe_live_mocs_reset_kunit ============
[14:33:44] ==================== [SKIPPED] xe_mocs =====================
[14:33:44] ================= xe_migrate (2 subtests) ==================
[14:33:44] ================= xe_migrate_sanity_kunit  =================
[14:33:44] ============ [SKIPPED] xe_migrate_sanity_kunit =============
[14:33:44] ================== xe_validate_ccs_kunit  ==================
[14:33:44] ============= [SKIPPED] xe_validate_ccs_kunit ==============
[14:33:44] =================== [SKIPPED] xe_migrate ===================
[14:33:44] ================== xe_dma_buf (1 subtest) ==================
[14:33:44] ==================== xe_dma_buf_kunit  =====================
[14:33:44] ================ [SKIPPED] xe_dma_buf_kunit ================
[14:33:44] =================== [SKIPPED] xe_dma_buf ===================
[14:33:44] ================= xe_bo_shrink (1 subtest) =================
[14:33:44] =================== xe_bo_shrink_kunit  ====================
[14:33:44] =============== [SKIPPED] xe_bo_shrink_kunit ===============
[14:33:44] ================== [SKIPPED] xe_bo_shrink ==================
[14:33:44] ==================== xe_bo (2 subtests) ====================
[14:33:44] ================== xe_ccs_migrate_kunit  ===================
[14:33:44] ============== [SKIPPED] xe_ccs_migrate_kunit ==============
stty: 'standard input': Inappropriate ioctl for device
[14:33:44] ==================== xe_bo_evict_kunit  ====================
[14:33:44] =============== [SKIPPED] xe_bo_evict_kunit ================
[14:33:44] ===================== [SKIPPED] xe_bo ======================
[14:33:44] ==================== args (11 subtests) ====================
[14:33:44] [PASSED] count_args_test
[14:33:44] [PASSED] call_args_example
[14:33:44] [PASSED] call_args_test
[14:33:44] [PASSED] drop_first_arg_example
[14:33:44] [PASSED] drop_first_arg_test
[14:33:44] [PASSED] first_arg_example
[14:33:44] [PASSED] first_arg_test
[14:33:44] [PASSED] last_arg_example
[14:33:44] [PASSED] last_arg_test
[14:33:44] [PASSED] pick_arg_example
[14:33:44] [PASSED] sep_comma_example
[14:33:44] ====================== [PASSED] args =======================
[14:33:44] =================== xe_pci (2 subtests) ====================
[14:33:44] [PASSED] xe_gmdid_graphics_ip
[14:33:44] [PASSED] xe_gmdid_media_ip
[14:33:44] ===================== [PASSED] xe_pci ======================
[14:33:44] =================== xe_rtp (2 subtests) ====================
[14:33:44] =============== xe_rtp_process_to_sr_tests  ================
[14:33:44] [PASSED] coalesce-same-reg
[14:33:44] [PASSED] no-match-no-add
[14:33:44] [PASSED] match-or
[14:33:44] [PASSED] match-or-xfail
[14:33:44] [PASSED] no-match-no-add-multiple-rules
[14:33:44] [PASSED] two-regs-two-entries
[14:33:44] [PASSED] clr-one-set-other
[14:33:44] [PASSED] set-field
[14:33:44] [PASSED] conflict-duplicate
[14:33:44] [PASSED] conflict-not-disjoint
[14:33:44] [PASSED] conflict-reg-type
[14:33:44] =========== [PASSED] xe_rtp_process_to_sr_tests ============
[14:33:44] ================== xe_rtp_process_tests  ===================
[14:33:44] [PASSED] active1
[14:33:44] [PASSED] active2
[14:33:44] [PASSED] active-inactive
[14:33:44] [PASSED] inactive-active
[14:33:44] [PASSED] inactive-1st_or_active-inactive
[14:33:44] [PASSED] inactive-2nd_or_active-inactive
[14:33:44] [PASSED] inactive-last_or_active-inactive
[14:33:44] [PASSED] inactive-no_or_active-inactive
[14:33:44] ============== [PASSED] xe_rtp_process_tests ===============
[14:33:44] ===================== [PASSED] xe_rtp ======================
[14:33:44] ==================== xe_wa (1 subtest) =====================
[14:33:44] ======================== xe_wa_gt  =========================
[14:33:44] [PASSED] TIGERLAKE (B0)
[14:33:44] [PASSED] DG1 (A0)
[14:33:44] [PASSED] DG1 (B0)
[14:33:44] [PASSED] ALDERLAKE_S (A0)
[14:33:44] [PASSED] ALDERLAKE_S (B0)
[14:33:44] [PASSED] ALDERLAKE_S (C0)
[14:33:44] [PASSED] ALDERLAKE_S (D0)
[14:33:44] [PASSED] ALDERLAKE_P (A0)
[14:33:44] [PASSED] ALDERLAKE_P (B0)
[14:33:44] [PASSED] ALDERLAKE_P (C0)
[14:33:44] [PASSED] ALDERLAKE_S_RPLS (D0)
[14:33:44] [PASSED] ALDERLAKE_P_RPLU (E0)
[14:33:44] [PASSED] DG2_G10 (C0)
[14:33:44] [PASSED] DG2_G11 (B1)
[14:33:44] [PASSED] DG2_G12 (A1)
[14:33:44] [PASSED] METEORLAKE (g:A0, m:A0)
[14:33:44] [PASSED] METEORLAKE (g:A0, m:A0)
[14:33:44] [PASSED] METEORLAKE (g:A0, m:A0)
[14:33:44] [PASSED] LUNARLAKE (g:A0, m:A0)
[14:33:44] [PASSED] LUNARLAKE (g:B0, m:A0)
[14:33:44] [PASSED] BATTLEMAGE (g:A0, m:A1)
[14:33:44] ==================== [PASSED] xe_wa_gt =====================
[14:33:44] ====================== [PASSED] xe_wa ======================
[14:33:44] ============================================================
[14:33:44] Testing complete. Ran 133 tests: passed: 117, skipped: 16
[14:33:44] Elapsed time: 30.465s total, 4.170s configuring, 26.029s building, 0.245s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/tests/.kunitconfig
[14:33:44] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[14:33:46] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json ARCH=um O=.kunit --jobs=48
../lib/iomap.c:156:5: warning: no previous prototype for ‘ioread64_lo_hi’ [-Wmissing-prototypes]
  156 | u64 ioread64_lo_hi(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~
../lib/iomap.c:163:5: warning: no previous prototype for ‘ioread64_hi_lo’ [-Wmissing-prototypes]
  163 | u64 ioread64_hi_lo(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~
../lib/iomap.c:170:5: warning: no previous prototype for ‘ioread64be_lo_hi’ [-Wmissing-prototypes]
  170 | u64 ioread64be_lo_hi(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~~~
../lib/iomap.c:178:5: warning: no previous prototype for ‘ioread64be_hi_lo’ [-Wmissing-prototypes]
  178 | u64 ioread64be_hi_lo(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~~~
../lib/iomap.c:264:6: warning: no previous prototype for ‘iowrite64_lo_hi’ [-Wmissing-prototypes]
  264 | void iowrite64_lo_hi(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~
../lib/iomap.c:272:6: warning: no previous prototype for ‘iowrite64_hi_lo’ [-Wmissing-prototypes]
  272 | void iowrite64_hi_lo(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~
../lib/iomap.c:280:6: warning: no previous prototype for ‘iowrite64be_lo_hi’ [-Wmissing-prototypes]
  280 | void iowrite64be_lo_hi(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~~~
../lib/iomap.c:288:6: warning: no previous prototype for ‘iowrite64be_hi_lo’ [-Wmissing-prototypes]
  288 | void iowrite64be_hi_lo(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~~~

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

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

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

✓ CI.Build: success for Add support for EU stall sampling

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/events/amd/
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/events/amd/amd-uncore.ko
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/events/rapl.ko
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/kvm/
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/kvm/kvm.ko
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/kvm/kvm-intel.ko
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/kvm/kvm-amd.ko
lib/modules/6.14.0-rc2-xe+/kernel/kernel/
lib/modules/6.14.0-rc2-xe+/kernel/kernel/kheaders.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/
lib/modules/6.14.0-rc2-xe+/kernel/crypto/ecrdsa_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/xcbc.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/serpent_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/aria_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/crypto_simd.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/adiantum.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/tcrypt.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/crypto_engine.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/zstd.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/asymmetric_keys/
lib/modules/6.14.0-rc2-xe+/kernel/crypto/asymmetric_keys/pkcs7_test_key.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/asymmetric_keys/pkcs8_key_parser.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/des_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/xctr.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/authenc.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/sm4_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/camellia_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/sm3.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/pcrypt.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/aegis128.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/af_alg.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/algif_aead.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cmac.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/sm3_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/aes_ti.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/chacha_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/poly1305_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/nhpoly1305.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/crc32_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/essiv.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/ccm.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/wp512.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/streebog_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/authencesn.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/echainiv.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/lrw.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cryptd.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/crypto_user.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/algif_hash.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/polyval-generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/hctr2.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/842.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/pcbc.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/ansi_cprng.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cast6_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/twofish_common.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/twofish_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/lz4hc.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/blowfish_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/md4.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/chacha20poly1305.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/curve25519-generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/lz4.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/rmd160.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/algif_skcipher.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cast5_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/fcrypt.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/ecdsa_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/sm4.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cast_common.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/blowfish_common.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/michael_mic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_xor.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_tx.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_memcpy.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_pq.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_raid6_recov.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/algif_rng.ko
lib/modules/6.14.0-rc2-xe+/kernel/block/
lib/modules/6.14.0-rc2-xe+/kernel/block/bfq.ko
lib/modules/6.14.0-rc2-xe+/kernel/block/kyber-iosched.ko
lib/modules/6.14.0-rc2-xe+/build
lib/modules/6.14.0-rc2-xe+/modules.alias.bin
lib/modules/6.14.0-rc2-xe+/modules.builtin
lib/modules/6.14.0-rc2-xe+/modules.softdep
lib/modules/6.14.0-rc2-xe+/modules.alias
lib/modules/6.14.0-rc2-xe+/modules.order
lib/modules/6.14.0-rc2-xe+/modules.symbols
lib/modules/6.14.0-rc2-xe+/modules.dep.bin
+ mv kernel-nodebug.tar.gz ..
+ cd ..
+ rm -rf archive
++ date +%s
+ echo -e '\e[0Ksection_end:1739199039:package_x86_64_nodebug\r\e[0K'
^[[0Ksection_end:1739199039:package_x86_64_nodebug
^[[0K
+ sync
+ cleanup
++ stat -c %u:%g /kernel
+ chown -R 1003:1003 /kernel

✓ CI.Hooks: success for Add support for EU stall sampling

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

run-parts: executing /workspace/ci/hooks/00-showenv
+ export
+ grep -Ei '(^|\W)CI_'
declare -x CI_KERNEL_BUILD_DIR="/workspace/kernel/build64-default"
declare -x CI_KERNEL_SRC_DIR="/workspace/kernel"
declare -x CI_TOOLS_SRC_DIR="/workspace/ci"
declare -x CI_WORKSPACE_DIR="/workspace"
run-parts: executing /workspace/ci/hooks/10-build-W1
+ SRC_DIR=/workspace/kernel
+ RESTORE_DISPLAY_CONFIG=0
+ '[' -n /workspace/kernel/build64-default ']'
+ BUILD_DIR=/workspace/kernel/build64-default
+ cd /workspace/kernel
++ nproc
+ make -j48 O=/workspace/kernel/build64-default modules_prepare
make[1]: Entering directory '/workspace/kernel/build64-default'
  GEN     Makefile
mkdir -p /workspace/kernel/build64-default/tools/objtool && make O=/workspace/kernel/build64-default subdir=tools/objtool --no-print-directory -C objtool 
  CALL    ../scripts/checksyscalls.sh
  INSTALL libsubcmd_headers
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/exec-cmd.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/help.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/pager.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/parse-options.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/run-command.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/sigchain.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/subcmd-config.o
  LD      /workspace/kernel/build64-default/tools/objtool/libsubcmd/libsubcmd-in.o
  AR      /workspace/kernel/build64-default/tools/objtool/libsubcmd/libsubcmd.a
  CC      /workspace/kernel/build64-default/tools/objtool/weak.o
  CC      /workspace/kernel/build64-default/tools/objtool/check.o
  CC      /workspace/kernel/build64-default/tools/objtool/special.o
  CC      /workspace/kernel/build64-default/tools/objtool/builtin-check.o
  CC      /workspace/kernel/build64-default/tools/objtool/elf.o
  CC      /workspace/kernel/build64-default/tools/objtool/arch/x86/special.o
  CC      /workspace/kernel/build64-default/tools/objtool/objtool.o
  CC      /workspace/kernel/build64-default/tools/objtool/orc_gen.o
  CC      /workspace/kernel/build64-default/tools/objtool/orc_dump.o
  CC      /workspace/kernel/build64-default/tools/objtool/arch/x86/decode.o
  CC      /workspace/kernel/build64-default/tools/objtool/arch/x86/orc.o
  CC      /workspace/kernel/build64-default/tools/objtool/libstring.o
  CC      /workspace/kernel/build64-default/tools/objtool/libctype.o
  CC      /workspace/kernel/build64-default/tools/objtool/str_error_r.o
  CC      /workspace/kernel/build64-default/tools/objtool/librbtree.o
  LD      /workspace/kernel/build64-default/tools/objtool/arch/x86/objtool-in.o
  LD      /workspace/kernel/build64-default/tools/objtool/objtool-in.o
  LINK    /workspace/kernel/build64-default/tools/objtool/objtool
make[1]: Leaving directory '/workspace/kernel/build64-default'
++ nproc
+ make -j48 O=/workspace/kernel/build64-default W=1 drivers/gpu/drm/xe
make[1]: Entering directory '/workspace/kernel/build64-default'
make[2]: Nothing to be done for 'drivers/gpu/drm/xe'.
make[1]: Leaving directory '/workspace/kernel/build64-default'
run-parts: executing /workspace/ci/hooks/11-build-32b
+++ realpath /workspace/ci/hooks/11-build-32b
++ dirname /workspace/ci/hooks/11-build-32b
+ THIS_SCRIPT_DIR=/workspace/ci/hooks
+ SRC_DIR=/workspace/kernel
+ TOOLS_SRC_DIR=/workspace/ci
+ '[' -n /workspace/kernel/build64-default ']'
+ BUILD_DIR=/workspace/kernel/build64-default
+ BUILD_DIR=/workspace/kernel/build64-default/build32
+ cd /workspace/kernel
+ mkdir -p /workspace/kernel/build64-default/build32
++ nproc
+ make -j48 ARCH=i386 O=/workspace/kernel/build64-default/build32 defconfig
make[1]: Entering directory '/workspace/kernel/build64-default/build32'
  GEN     Makefile
  HOSTCC  scripts/basic/fixdep
  HOSTCC  scripts/kconfig/conf.o
  HOSTCC  scripts/kconfig/confdata.o
  HOSTCC  scripts/kconfig/expr.o
  LEX     scripts/kconfig/lexer.lex.c
  YACC    scripts/kconfig/parser.tab.[ch]
  HOSTCC  scripts/kconfig/menu.o
  HOSTCC  scripts/kconfig/preprocess.o
  HOSTCC  scripts/kconfig/symbol.o
  HOSTCC  scripts/kconfig/util.o
  HOSTCC  scripts/kconfig/lexer.lex.o
  HOSTCC  scripts/kconfig/parser.tab.o
  HOSTLD  scripts/kconfig/conf
*** Default configuration is based on 'i386_defconfig'
#
# configuration written to .config
#
make[1]: Leaving directory '/workspace/kernel/build64-default/build32'
+ cd /workspace/kernel/build64-default/build32
+ /workspace/kernel/scripts/kconfig/merge_config.sh .config /workspace/ci/kernel/fragments/10-xe.fragment
Using .config as base
Merging /workspace/ci/kernel/fragments/10-xe.fragment
Value of CONFIG_DRM_XE is redefined by fragment /workspace/ci/kernel/fragments/10-xe.fragment:
Previous value: # CONFIG_DRM_XE is not set
New value: CONFIG_DRM_XE=m

  GEN     Makefile

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]
#
# configuration written to .config
#
Value requested for CONFIG_HAVE_UID16 not in final .config
Requested value:  CONFIG_HAVE_UID16=y
Actual value:     

Value requested for CONFIG_UID16 not in final .config
Requested value:  CONFIG_UID16=y
Actual value:     

Value requested for CONFIG_X86_32 not in final .config
Requested value:  CONFIG_X86_32=y
Actual value:     

Value requested for CONFIG_OUTPUT_FORMAT not in final .config
Requested value:  CONFIG_OUTPUT_FORMAT="elf32-i386"
Actual value:     CONFIG_OUTPUT_FORMAT="elf64-x86-64"

Value requested for CONFIG_ARCH_MMAP_RND_BITS_MIN not in final .config
Requested value:  CONFIG_ARCH_MMAP_RND_BITS_MIN=8
Actual value:     CONFIG_ARCH_MMAP_RND_BITS_MIN=28

Value requested for CONFIG_ARCH_MMAP_RND_BITS_MAX not in final .config
Requested value:  CONFIG_ARCH_MMAP_RND_BITS_MAX=16
Actual value:     CONFIG_ARCH_MMAP_RND_BITS_MAX=32

Value requested for CONFIG_PGTABLE_LEVELS not in final .config
Requested value:  CONFIG_PGTABLE_LEVELS=2
Actual value:     CONFIG_PGTABLE_LEVELS=5

Value requested for CONFIG_X86_BIGSMP not in final .config
Requested value:  # CONFIG_X86_BIGSMP is not set
Actual value:     

Value requested for CONFIG_X86_INTEL_QUARK not in final .config
Requested value:  # CONFIG_X86_INTEL_QUARK is not set
Actual value:     

Value requested for CONFIG_X86_RDC321X not in final .config
Requested value:  # CONFIG_X86_RDC321X is not set
Actual value:     

Value requested for CONFIG_X86_32_NON_STANDARD not in final .config
Requested value:  # CONFIG_X86_32_NON_STANDARD is not set
Actual value:     

Value requested for CONFIG_X86_32_IRIS not in final .config
Requested value:  # CONFIG_X86_32_IRIS is not set
Actual value:     

Value requested for CONFIG_M486SX not in final .config
Requested value:  # CONFIG_M486SX is not set
Actual value:     

Value requested for CONFIG_M486 not in final .config
Requested value:  # CONFIG_M486 is not set
Actual value:     

Value requested for CONFIG_M586 not in final .config
Requested value:  # CONFIG_M586 is not set
Actual value:     

Value requested for CONFIG_M586TSC not in final .config
Requested value:  # CONFIG_M586TSC is not set
Actual value:     

Value requested for CONFIG_M586MMX not in final .config
Requested value:  # CONFIG_M586MMX is not set
Actual value:     

Value requested for CONFIG_M686 not in final .config
Requested value:  CONFIG_M686=y
Actual value:     

Value requested for CONFIG_MPENTIUMII not in final .config
Requested value:  # CONFIG_MPENTIUMII is not set
Actual value:     

Value requested for CONFIG_MPENTIUMIII not in final .config
Requested value:  # CONFIG_MPENTIUMIII is not set
Actual value:     

Value requested for CONFIG_MPENTIUMM not in final .config
Requested value:  # CONFIG_MPENTIUMM is not set
Actual value:     

Value requested for CONFIG_MPENTIUM4 not in final .config
Requested value:  # CONFIG_MPENTIUM4 is not set
Actual value:     

Value requested for CONFIG_MK6 not in final .config
Requested value:  # CONFIG_MK6 is not set
Actual value:     

Value requested for CONFIG_MK7 not in final .config
Requested value:  # CONFIG_MK7 is not set
Actual value:     

Value requested for CONFIG_MCRUSOE not in final .config
Requested value:  # CONFIG_MCRUSOE is not set
Actual value:     

Value requested for CONFIG_MEFFICEON not in final .config
Requested value:  # CONFIG_MEFFICEON is not set
Actual value:     

Value requested for CONFIG_MWINCHIPC6 not in final .config
Requested value:  # CONFIG_MWINCHIPC6 is not set
Actual value:     

Value requested for CONFIG_MWINCHIP3D not in final .config
Requested value:  # CONFIG_MWINCHIP3D is not set
Actual value:     

Value requested for CONFIG_MELAN not in final .config
Requested value:  # CONFIG_MELAN is not set
Actual value:     

Value requested for CONFIG_MGEODEGX1 not in final .config
Requested value:  # CONFIG_MGEODEGX1 is not set
Actual value:     

Value requested for CONFIG_MGEODE_LX not in final .config
Requested value:  # CONFIG_MGEODE_LX is not set
Actual value:     

Value requested for CONFIG_MCYRIXIII not in final .config
Requested value:  # CONFIG_MCYRIXIII is not set
Actual value:     

Value requested for CONFIG_MVIAC3_2 not in final .config
Requested value:  # CONFIG_MVIAC3_2 is not set
Actual value:     

Value requested for CONFIG_MVIAC7 not in final .config
Requested value:  # CONFIG_MVIAC7 is not set
Actual value:     

Value requested for CONFIG_X86_GENERIC not in final .config
Requested value:  # CONFIG_X86_GENERIC is not set
Actual value:     

Value requested for CONFIG_X86_INTERNODE_CACHE_SHIFT not in final .config
Requested value:  CONFIG_X86_INTERNODE_CACHE_SHIFT=5
Actual value:     CONFIG_X86_INTERNODE_CACHE_SHIFT=6

Value requested for CONFIG_X86_L1_CACHE_SHIFT not in final .config
Requested value:  CONFIG_X86_L1_CACHE_SHIFT=5
Actual value:     CONFIG_X86_L1_CACHE_SHIFT=6

Value requested for CONFIG_X86_USE_PPRO_CHECKSUM not in final .config
Requested value:  CONFIG_X86_USE_PPRO_CHECKSUM=y
Actual value:     

Value requested for CONFIG_X86_MINIMUM_CPU_FAMILY not in final .config
Requested value:  CONFIG_X86_MINIMUM_CPU_FAMILY=6
Actual value:     CONFIG_X86_MINIMUM_CPU_FAMILY=64

Value requested for CONFIG_CPU_SUP_TRANSMETA_32 not in final .config
Requested value:  CONFIG_CPU_SUP_TRANSMETA_32=y
Actual value:     

Value requested for CONFIG_CPU_SUP_VORTEX_32 not in final .config
Requested value:  CONFIG_CPU_SUP_VORTEX_32=y
Actual value:     

Value requested for CONFIG_HPET_TIMER not in final .config
Requested value:  # CONFIG_HPET_TIMER is not set
Actual value:     CONFIG_HPET_TIMER=y

Value requested for CONFIG_NR_CPUS_RANGE_END not in final .config
Requested value:  CONFIG_NR_CPUS_RANGE_END=8
Actual value:     CONFIG_NR_CPUS_RANGE_END=512

Value requested for CONFIG_NR_CPUS_DEFAULT not in final .config
Requested value:  CONFIG_NR_CPUS_DEFAULT=8
Actual value:     CONFIG_NR_CPUS_DEFAULT=64

Value requested for CONFIG_X86_ANCIENT_MCE not in final .config
Requested value:  # CONFIG_X86_ANCIENT_MCE is not set
Actual value:     

Value requested for CONFIG_X86_LEGACY_VM86 not in final .config
Requested value:  # CONFIG_X86_LEGACY_VM86 is not set
Actual value:     

Value requested for CONFIG_X86_ESPFIX32 not in final .config
Requested value:  CONFIG_X86_ESPFIX32=y
Actual value:     

Value requested for CONFIG_TOSHIBA not in final .config
Requested value:  # CONFIG_TOSHIBA is not set
Actual value:     

Value requested for CONFIG_X86_REBOOTFIXUPS not in final .config
Requested value:  # CONFIG_X86_REBOOTFIXUPS is not set
Actual value:     

Value requested for CONFIG_MICROCODE_INITRD32 not in final .config
Requested value:  CONFIG_MICROCODE_INITRD32=y
Actual value:     

Value requested for CONFIG_NOHIGHMEM not in final .config
Requested value:  # CONFIG_NOHIGHMEM is not set
Actual value:     

Value requested for CONFIG_HIGHMEM4G not in final .config
Requested value:  CONFIG_HIGHMEM4G=y
Actual value:     

Value requested for CONFIG_HIGHMEM64G not in final .config
Requested value:  # CONFIG_HIGHMEM64G is not set
Actual value:     

Value requested for CONFIG_VMSPLIT_3G not in final .config
Requested value:  CONFIG_VMSPLIT_3G=y
Actual value:     

Value requested for CONFIG_VMSPLIT_3G_OPT not in final .config
Requested value:  # CONFIG_VMSPLIT_3G_OPT is not set
Actual value:     

Value requested for CONFIG_VMSPLIT_2G not in final .config
Requested value:  # CONFIG_VMSPLIT_2G is not set
Actual value:     

Value requested for CONFIG_VMSPLIT_2G_OPT not in final .config
Requested value:  # CONFIG_VMSPLIT_2G_OPT is not set
Actual value:     

Value requested for CONFIG_VMSPLIT_1G not in final .config
Requested value:  # CONFIG_VMSPLIT_1G is not set
Actual value:     

Value requested for CONFIG_PAGE_OFFSET not in final .config
Requested value:  CONFIG_PAGE_OFFSET=0xC0000000
Actual value:     

Value requested for CONFIG_HIGHMEM not in final .config
Requested value:  CONFIG_HIGHMEM=y
Actual value:     

Value requested for CONFIG_X86_PAE not in final .config
Requested value:  # CONFIG_X86_PAE is not set
Actual value:     

Value requested for CONFIG_ARCH_FLATMEM_ENABLE not in final .config
Requested value:  CONFIG_ARCH_FLATMEM_ENABLE=y
Actual value:     

Value requested for CONFIG_ARCH_SELECT_MEMORY_MODEL not in final .config
Requested value:  CONFIG_ARCH_SELECT_MEMORY_MODEL=y
Actual value:     

Value requested for CONFIG_ILLEGAL_POINTER_VALUE not in final .config
Requested value:  CONFIG_ILLEGAL_POINTER_VALUE=0
Actual value:     CONFIG_ILLEGAL_POINTER_VALUE=0xdead000000000000

Value requested for CONFIG_HIGHPTE not in final .config
Requested value:  # CONFIG_HIGHPTE is not set
Actual value:     

Value requested for CONFIG_COMPAT_VDSO not in final .config
Requested value:  # CONFIG_COMPAT_VDSO is not set
Actual value:     

Value requested for CONFIG_FUNCTION_PADDING_CFI not in final .config
Requested value:  CONFIG_FUNCTION_PADDING_CFI=0
Actual value:     CONFIG_FUNCTION_PADDING_CFI=11

Value requested for CONFIG_FUNCTION_PADDING_BYTES not in final .config
Requested value:  CONFIG_FUNCTION_PADDING_BYTES=4
Actual value:     CONFIG_FUNCTION_PADDING_BYTES=16

Value requested for CONFIG_APM not in final .config
Requested value:  # CONFIG_APM is not set
Actual value:     

Value requested for CONFIG_X86_POWERNOW_K6 not in final .config
Requested value:  # CONFIG_X86_POWERNOW_K6 is not set
Actual value:     

Value requested for CONFIG_X86_POWERNOW_K7 not in final .config
Requested value:  # CONFIG_X86_POWERNOW_K7 is not set
Actual value:     

Value requested for CONFIG_X86_GX_SUSPMOD not in final .config
Requested value:  # CONFIG_X86_GX_SUSPMOD is not set
Actual value:     

Value requested for CONFIG_X86_SPEEDSTEP_ICH not in final .config
Requested value:  # CONFIG_X86_SPEEDSTEP_ICH is not set
Actual value:     

Value requested for CONFIG_X86_SPEEDSTEP_SMI not in final .config
Requested value:  # CONFIG_X86_SPEEDSTEP_SMI is not set
Actual value:     

Value requested for CONFIG_X86_CPUFREQ_NFORCE2 not in final .config
Requested value:  # CONFIG_X86_CPUFREQ_NFORCE2 is not set
Actual value:     

Value requested for CONFIG_X86_LONGRUN not in final .config
Requested value:  # CONFIG_X86_LONGRUN is not set
Actual value:     

Value requested for CONFIG_X86_LONGHAUL not in final .config
Requested value:  # CONFIG_X86_LONGHAUL is not set
Actual value:     

Value requested for CONFIG_X86_E_POWERSAVER not in final .config
Requested value:  # CONFIG_X86_E_POWERSAVER is not set
Actual value:     

Value requested for CONFIG_PCI_GOBIOS not in final .config
Requested value:  # CONFIG_PCI_GOBIOS is not set
Actual value:     

Value requested for CONFIG_PCI_GOMMCONFIG not in final .config
Requested value:  # CONFIG_PCI_GOMMCONFIG is not set
Actual value:     

Value requested for CONFIG_PCI_GODIRECT not in final .config
Requested value:  # CONFIG_PCI_GODIRECT is not set
Actual value:     

Value requested for CONFIG_PCI_GOANY not in final .config
Requested value:  CONFIG_PCI_GOANY=y
Actual value:     

Value requested for CONFIG_PCI_BIOS not in final .config
Requested value:  CONFIG_PCI_BIOS=y
Actual value:     

Value requested for CONFIG_ISA not in final .config
Requested value:  # CONFIG_ISA is not set
Actual value:     

Value requested for CONFIG_SCx200 not in final .config
Requested value:  # CONFIG_SCx200 is not set
Actual value:     

Value requested for CONFIG_OLPC not in final .config
Requested value:  # CONFIG_OLPC is not set
Actual value:     

Value requested for CONFIG_ALIX not in final .config
Requested value:  # CONFIG_ALIX is not set
Actual value:     

Value requested for CONFIG_NET5501 not in final .config
Requested value:  # CONFIG_NET5501 is not set
Actual value:     

Value requested for CONFIG_GEOS not in final .config
Requested value:  # CONFIG_GEOS is not set
Actual value:     

Value requested for CONFIG_COMPAT_32 not in final .config
Requested value:  CONFIG_COMPAT_32=y
Actual value:     

Value requested for CONFIG_HAVE_ATOMIC_IOMAP not in final .config
Requested value:  CONFIG_HAVE_ATOMIC_IOMAP=y
Actual value:     

Value requested for CONFIG_ARCH_32BIT_OFF_T not in final .config
Requested value:  CONFIG_ARCH_32BIT_OFF_T=y
Actual value:     

Value requested for CONFIG_ARCH_WANT_IPC_PARSE_VERSION not in final .config
Requested value:  CONFIG_ARCH_WANT_IPC_PARSE_VERSION=y
Actual value:     

Value requested for CONFIG_MODULES_USE_ELF_REL not in final .config
Requested value:  CONFIG_MODULES_USE_ELF_REL=y
Actual value:     

Value requested for CONFIG_ARCH_MMAP_RND_BITS not in final .config
Requested value:  CONFIG_ARCH_MMAP_RND_BITS=8
Actual value:     CONFIG_ARCH_MMAP_RND_BITS=28

Value requested for CONFIG_CLONE_BACKWARDS not in final .config
Requested value:  CONFIG_CLONE_BACKWARDS=y
Actual value:     

Value requested for CONFIG_OLD_SIGSUSPEND3 not in final .config
Requested value:  CONFIG_OLD_SIGSUSPEND3=y
Actual value:     

Value requested for CONFIG_OLD_SIGACTION not in final .config
Requested value:  CONFIG_OLD_SIGACTION=y
Actual value:     

Value requested for CONFIG_ARCH_SPLIT_ARG64 not in final .config
Requested value:  CONFIG_ARCH_SPLIT_ARG64=y
Actual value:     

Value requested for CONFIG_FUNCTION_ALIGNMENT not in final .config
Requested value:  CONFIG_FUNCTION_ALIGNMENT=4
Actual value:     CONFIG_FUNCTION_ALIGNMENT=16

Value requested for CONFIG_SELECT_MEMORY_MODEL not in final .config
Requested value:  CONFIG_SELECT_MEMORY_MODEL=y
Actual value:     

Value requested for CONFIG_FLATMEM_MANUAL not in final .config
Requested value:  CONFIG_FLATMEM_MANUAL=y
Actual value:     

Value requested for CONFIG_SPARSEMEM_MANUAL not in final .config
Requested value:  # CONFIG_SPARSEMEM_MANUAL is not set
Actual value:     

Value requested for CONFIG_FLATMEM not in final .config
Requested value:  CONFIG_FLATMEM=y
Actual value:     

Value requested for CONFIG_SPARSEMEM_STATIC not in final .config
Requested value:  CONFIG_SPARSEMEM_STATIC=y
Actual value:     

Value requested for CONFIG_BOUNCE not in final .config
Requested value:  CONFIG_BOUNCE=y
Actual value:     

Value requested for CONFIG_KMAP_LOCAL not in final .config
Requested value:  CONFIG_KMAP_LOCAL=y
Actual value:     

Value requested for CONFIG_HOTPLUG_PCI_COMPAQ not in final .config
Requested value:  # CONFIG_HOTPLUG_PCI_COMPAQ is not set
Actual value:     

Value requested for CONFIG_HOTPLUG_PCI_IBM not in final .config
Requested value:  # CONFIG_HOTPLUG_PCI_IBM is not set
Actual value:     

Value requested for CONFIG_EFI_CAPSULE_QUIRK_QUARK_CSH not in final .config
Requested value:  CONFIG_EFI_CAPSULE_QUIRK_QUARK_CSH=y
Actual value:     

Value requested for CONFIG_PCH_PHUB not in final .config
Requested value:  # CONFIG_PCH_PHUB is not set
Actual value:     

Value requested for CONFIG_SCSI_NSP32 not in final .config
Requested value:  # CONFIG_SCSI_NSP32 is not set
Actual value:     

Value requested for CONFIG_PATA_CS5520 not in final .config
Requested value:  # CONFIG_PATA_CS5520 is not set
Actual value:     

Value requested for CONFIG_PATA_CS5530 not in final .config
Requested value:  # CONFIG_PATA_CS5530 is not set
Actual value:     

Value requested for CONFIG_PATA_CS5535 not in final .config
Requested value:  # CONFIG_PATA_CS5535 is not set
Actual value:     

Value requested for CONFIG_PATA_CS5536 not in final .config
Requested value:  # CONFIG_PATA_CS5536 is not set
Actual value:     

Value requested for CONFIG_PATA_SC1200 not in final .config
Requested value:  # CONFIG_PATA_SC1200 is not set
Actual value:     

Value requested for CONFIG_PCH_GBE not in final .config
Requested value:  # CONFIG_PCH_GBE is not set
Actual value:     

Value requested for CONFIG_INPUT_WISTRON_BTNS not in final .config
Requested value:  # CONFIG_INPUT_WISTRON_BTNS is not set
Actual value:     

Value requested for CONFIG_SERIAL_TIMBERDALE not in final .config
Requested value:  # CONFIG_SERIAL_TIMBERDALE is not set
Actual value:     

Value requested for CONFIG_SERIAL_PCH_UART not in final .config
Requested value:  # CONFIG_SERIAL_PCH_UART is not set
Actual value:     

Value requested for CONFIG_HW_RANDOM_GEODE not in final .config
Requested value:  CONFIG_HW_RANDOM_GEODE=y
Actual value:     

Value requested for CONFIG_SONYPI not in final .config
Requested value:  # CONFIG_SONYPI is not set
Actual value:     

Value requested for CONFIG_PC8736x_GPIO not in final .config
Requested value:  # CONFIG_PC8736x_GPIO is not set
Actual value:     

Value requested for CONFIG_NSC_GPIO not in final .config
Requested value:  # CONFIG_NSC_GPIO is not set
Actual value:     

Value requested for CONFIG_I2C_EG20T not in final .config
Requested value:  # CONFIG_I2C_EG20T is not set
Actual value:     

Value requested for CONFIG_SCx200_ACB not in final .config
Requested value:  # CONFIG_SCx200_ACB is not set
Actual value:     

Value requested for CONFIG_PTP_1588_CLOCK_PCH not in final .config
Requested value:  # CONFIG_PTP_1588_CLOCK_PCH is not set
Actual value:     

Value requested for CONFIG_SBC8360_WDT not in final .config
Requested value:  # CONFIG_SBC8360_WDT is not set
Actual value:     

Value requested for CONFIG_SBC7240_WDT not in final .config
Requested value:  # CONFIG_SBC7240_WDT is not set
Actual value:     

Value requested for CONFIG_MFD_CS5535 not in final .config
Requested value:  # CONFIG_MFD_CS5535 is not set
Actual value:     

Value requested for CONFIG_AGP_ALI not in final .config
Requested value:  # CONFIG_AGP_ALI is not set
Actual value:     

Value requested for CONFIG_AGP_ATI not in final .config
Requested value:  # CONFIG_AGP_ATI is not set
Actual value:     

Value requested for CONFIG_AGP_AMD not in final .config
Requested value:  # CONFIG_AGP_AMD is not set
Actual value:     

Value requested for CONFIG_AGP_NVIDIA not in final .config
Requested value:  # CONFIG_AGP_NVIDIA is not set
Actual value:     

Value requested for CONFIG_AGP_SWORKS not in final .config
Requested value:  # CONFIG_AGP_SWORKS is not set
Actual value:     

Value requested for CONFIG_AGP_EFFICEON not in final .config
Requested value:  # CONFIG_AGP_EFFICEON is not set
Actual value:     

Value requested for CONFIG_SND_CS5530 not in final .config
Requested value:  # CONFIG_SND_CS5530 is not set
Actual value:     

Value requested for CONFIG_SND_CS5535AUDIO not in final .config
Requested value:  # CONFIG_SND_CS5535AUDIO is not set
Actual value:     

Value requested for CONFIG_SND_SIS7019 not in final .config
Requested value:  # CONFIG_SND_SIS7019 is not set
Actual value:     

Value requested for CONFIG_LEDS_OT200 not in final .config
Requested value:  # CONFIG_LEDS_OT200 is not set
Actual value:     

Value requested for CONFIG_PCH_DMA not in final .config
Requested value:  # CONFIG_PCH_DMA is not set
Actual value:     

Value requested for CONFIG_CLKSRC_I8253 not in final .config
Requested value:  CONFIG_CLKSRC_I8253=y
Actual value:     

Value requested for CONFIG_MAILBOX not in final .config
Requested value:  # CONFIG_MAILBOX is not set
Actual value:     CONFIG_MAILBOX=y

Value requested for CONFIG_CRYPTO_SERPENT_SSE2_586 not in final .config
Requested value:  # CONFIG_CRYPTO_SERPENT_SSE2_586 is not set
Actual value:     

Value requested for CONFIG_CRYPTO_TWOFISH_586 not in final .config
Requested value:  # CONFIG_CRYPTO_TWOFISH_586 is not set
Actual value:     

Value requested for CONFIG_CRYPTO_DEV_GEODE not in final .config
Requested value:  # CONFIG_CRYPTO_DEV_GEODE is not set
Actual value:     

Value requested for CONFIG_CRYPTO_DEV_HIFN_795X not in final .config
Requested value:  # CONFIG_CRYPTO_DEV_HIFN_795X is not set
Actual value:     

Value requested for CONFIG_CRYPTO_LIB_POLY1305_RSIZE not in final .config
Requested value:  CONFIG_CRYPTO_LIB_POLY1305_RSIZE=1
Actual value:     CONFIG_CRYPTO_LIB_POLY1305_RSIZE=11

Value requested for CONFIG_AUDIT_GENERIC not in final .config
Requested value:  CONFIG_AUDIT_GENERIC=y
Actual value:     

Value requested for CONFIG_GENERIC_VDSO_32 not in final .config
Requested value:  CONFIG_GENERIC_VDSO_32=y
Actual value:     

Value requested for CONFIG_DEBUG_KMAP_LOCAL not in final .config
Requested value:  # CONFIG_DEBUG_KMAP_LOCAL is not set
Actual value:     

Value requested for CONFIG_DEBUG_HIGHMEM not in final .config
Requested value:  # CONFIG_DEBUG_HIGHMEM is not set
Actual value:     

Value requested for CONFIG_HAVE_DEBUG_STACKOVERFLOW not in final .config
Requested value:  CONFIG_HAVE_DEBUG_STACKOVERFLOW=y
Actual value:     

Value requested for CONFIG_DEBUG_STACKOVERFLOW not in final .config
Requested value:  # CONFIG_DEBUG_STACKOVERFLOW is not set
Actual value:     

Value requested for CONFIG_HAVE_FUNCTION_GRAPH_TRACER not in final .config
Requested value:  CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
Actual value:     

Value requested for CONFIG_HAVE_FUNCTION_GRAPH_FREGS not in final .config
Requested value:  CONFIG_HAVE_FUNCTION_GRAPH_FREGS=y
Actual value:     

Value requested for CONFIG_HAVE_FTRACE_GRAPH_FUNC not in final .config
Requested value:  CONFIG_HAVE_FTRACE_GRAPH_FUNC=y
Actual value:     

Value requested for CONFIG_DRM_KUNIT_TEST not in final .config
Requested value:  CONFIG_DRM_KUNIT_TEST=m
Actual value:     

Value requested for CONFIG_DRM_XE_WERROR not in final .config
Requested value:  CONFIG_DRM_XE_WERROR=y
Actual value:     

Value requested for CONFIG_DRM_XE_DEBUG not in final .config
Requested value:  CONFIG_DRM_XE_DEBUG=y
Actual value:     

Value requested for CONFIG_DRM_XE_DEBUG_MEM not in final .config
Requested value:  CONFIG_DRM_XE_DEBUG_MEM=y
Actual value:     

Value requested for CONFIG_DRM_XE_KUNIT_TEST not in final .config
Requested value:  CONFIG_DRM_XE_KUNIT_TEST=m
Actual value:     

++ nproc
+ make -j48 ARCH=i386 olddefconfig
  GEN     Makefile

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]
#
# configuration written to .config
#
++ nproc
+ make -j48 ARCH=i386
  SYNC    include/config/auto.conf.cmd
  GEN     Makefile

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]
  GEN     Makefile
  WRAP    arch/x86/include/generated/uapi/asm/bpf_perf_event.h
  WRAP    arch/x86/include/generated/uapi/asm/errno.h
  WRAP    arch/x86/include/generated/uapi/asm/fcntl.h
  WRAP    arch/x86/include/generated/uapi/asm/ioctl.h
  WRAP    arch/x86/include/generated/uapi/asm/ioctls.h
  UPD     include/generated/uapi/linux/version.h
  WRAP    arch/x86/include/generated/uapi/asm/ipcbuf.h
  SYSHDR  arch/x86/include/generated/uapi/asm/unistd_32.h
  WRAP    arch/x86/include/generated/uapi/asm/param.h
  SYSHDR  arch/x86/include/generated/uapi/asm/unistd_64.h
  WRAP    arch/x86/include/generated/uapi/asm/poll.h
  SYSHDR  arch/x86/include/generated/uapi/asm/unistd_x32.h
  WRAP    arch/x86/include/generated/uapi/asm/resource.h
  SYSTBL  arch/x86/include/generated/asm/syscalls_32.h
  WRAP    arch/x86/include/generated/uapi/asm/socket.h
  WRAP    arch/x86/include/generated/uapi/asm/sockios.h
  WRAP    arch/x86/include/generated/uapi/asm/termbits.h
  WRAP    arch/x86/include/generated/uapi/asm/termios.h
  WRAP    arch/x86/include/generated/uapi/asm/types.h
  HOSTCC  arch/x86/tools/relocs_32.o
  UPD     include/generated/compile.h
  HOSTCC  arch/x86/tools/relocs_64.o
  HOSTCC  arch/x86/tools/relocs_common.o
  WRAP    arch/x86/include/generated/asm/early_ioremap.h
  WRAP    arch/x86/include/generated/asm/fprobe.h
  WRAP    arch/x86/include/generated/asm/mcs_spinlock.h
  WRAP    arch/x86/include/generated/asm/mmzone.h
  WRAP    arch/x86/include/generated/asm/irq_regs.h
  WRAP    arch/x86/include/generated/asm/kmap_size.h
  WRAP    arch/x86/include/generated/asm/local64.h
  WRAP    arch/x86/include/generated/asm/mmiowb.h
  WRAP    arch/x86/include/generated/asm/module.lds.h
  WRAP    arch/x86/include/generated/asm/rwonce.h
  HOSTCC  scripts/kallsyms
  HOSTCC  scripts/sorttable
  HOSTCC  scripts/asn1_compiler
  HOSTCC  scripts/selinux/mdp/mdp
  HOSTLD  arch/x86/tools/relocs
  UPD     include/config/kernel.release
  UPD     include/generated/utsrelease.h
  CC      scripts/mod/empty.o
  HOSTCC  scripts/mod/mk_elfconfig
  CC      scripts/mod/devicetable-offsets.s
  UPD     scripts/mod/devicetable-offsets.h
  MKELF   scripts/mod/elfconfig.h
  HOSTCC  scripts/mod/modpost.o
  HOSTCC  scripts/mod/file2alias.o
  HOSTCC  scripts/mod/sumversion.o
  HOSTCC  scripts/mod/symsearch.o
  HOSTLD  scripts/mod/modpost
  CC      kernel/bounds.s
  CHKSHA1 /workspace/kernel/include/linux/atomic/atomic-arch-fallback.h
  CHKSHA1 /workspace/kernel/include/linux/atomic/atomic-instrumented.h
  CHKSHA1 /workspace/kernel/include/linux/atomic/atomic-long.h
  UPD     include/generated/timeconst.h
  UPD     include/generated/bounds.h
  CC      arch/x86/kernel/asm-offsets.s
  UPD     include/generated/asm-offsets.h
  CALL    /workspace/kernel/scripts/checksyscalls.sh
  LDS     scripts/module.lds
  HOSTCC  usr/gen_init_cpio
  CC      init/main.o
  CC      init/do_mounts.o
  CC      certs/system_keyring.o
  UPD     init/utsversion-tmp.h
  CC      init/do_mounts_initrd.o
  CC      ipc/util.o
  CC      ipc/msgutil.o
  CC      init/initramfs.o
  CC      security/commoncap.o
  CC      io_uring/io_uring.o
  CC      security/lsm_syscalls.o
  CC      ipc/msg.o
  CC      init/calibrate.o
  AS      arch/x86/lib/atomic64_cx8_32.o
  CC      arch/x86/realmode/init.o
  CC      io_uring/opdef.o
  CC      mm/filemap.o
  AR      arch/x86/crypto/built-in.a
  CC      block/bdev.o
  AS      arch/x86/lib/checksum_32.o
  CC      security/min_addr.o
  CC      arch/x86/pci/i386.o
  CC      arch/x86/power/cpu.o
  AR      arch/x86/net/built-in.a
  CC      arch/x86/video/video-common.o
  CC      ipc/sem.o
  CC      security/integrity/iint.o
  HOSTCC  security/selinux/genheaders
  CC      security/keys/gc.o
  AR      virt/lib/built-in.a
  CC      fs/nfs_common/nfsacl.o
  CC      fs/iomap/trace.o
  CC      fs/quota/dquot.o
  CC      arch/x86/events/amd/core.o
  CC      fs/proc/task_mmu.o
  CC      lib/math/div64.o
  CC      arch/x86/mm/pat/set_memory.o
  AR      arch/x86/platform/atom/built-in.a
  CC      arch/x86/virt/svm/cmdline.o
  CC      net/core/sock.o
  CC      fs/proc/inode.o
  AR      drivers/cache/built-in.a
  CC      block/partitions/core.o
  CC      arch/x86/kernel/fpu/init.o
  AR      virt/built-in.a
  CC      fs/notify/dnotify/dnotify.o
  CC      sound/core/seq/seq.o
  AR      sound/i2c/other/built-in.a
  AR      arch/x86/platform/ce4100/built-in.a
  AR      drivers/irqchip/built-in.a
  CC      arch/x86/entry/vdso/vma.o
  AR      sound/i2c/built-in.a
  CC      arch/x86/entry/vdso/extable.o
  CC      arch/x86/platform/efi/memmap.o
  CC      arch/x86/lib/cmdline.o
  CC      fs/notify/inotify/inotify_fsnotify.o
  AS      arch/x86/lib/cmpxchg8b_emu.o
  AR      drivers/bus/mhi/built-in.a
  CC      kernel/sched/core.o
  AR      drivers/bus/built-in.a
  CC      crypto/asymmetric_keys/asymmetric_type.o
  CC      kernel/sched/fair.o
  AR      drivers/pwm/built-in.a
  AR      drivers/leds/trigger/built-in.a
  AR      arch/x86/virt/svm/built-in.a
  AR      drivers/leds/blink/built-in.a
  AR      arch/x86/virt/vmx/built-in.a
  AR      arch/x86/virt/built-in.a
  AR      drivers/leds/simple/built-in.a
  CC      arch/x86/lib/cpu.o
  CC      drivers/leds/led-core.o
  CC      init/init_task.o
  CC      lib/math/gcd.o
  GEN     security/selinux/flask.h security/selinux/av_permissions.h
  CC      security/selinux/avc.o
  CC      lib/math/lcm.o
  CC      lib/math/int_log.o
  AR      fs/notify/fanotify/built-in.a
  LDS     arch/x86/entry/vdso/vdso32/vdso32.lds
  GEN     usr/initramfs_data.cpio
  CC      arch/x86/events/amd/lbr.o
  COPY    usr/initramfs_inc_data
  AS      usr/initramfs_data.o
  CC      lib/math/int_pow.o
  AR      usr/built-in.a
  HOSTCC  certs/extract-cert
  CC      block/fops.o
  CC      arch/x86/kernel/fpu/bugs.o
  CC      lib/math/int_sqrt.o
  CC      arch/x86/kernel/fpu/core.o
  CC      lib/math/reciprocal_div.o
  CC      arch/x86/lib/delay.o
  CC      sound/core/seq/seq_lock.o
  CC      fs/notify/inotify/inotify_user.o
  AS      arch/x86/realmode/rm/header.o
  CC      lib/math/rational.o
  AS      arch/x86/realmode/rm/trampoline_32.o
  AR      arch/x86/video/built-in.a
  CC      block/bio.o
  AS      arch/x86/realmode/rm/stack.o
  AS      arch/x86/realmode/rm/reboot.o
  AS      arch/x86/realmode/rm/wakeup_asm.o
  CERT    certs/x509_certificate_list
  CERT    certs/signing_key.x509
  AS      certs/system_certificates.o
  CC      block/elevator.o
  CC      arch/x86/realmode/rm/wakemain.o
  CC      fs/nfs_common/grace.o
  CC      security/integrity/integrity_audit.o
  AR      certs/built-in.a
  CC      block/blk-core.o
  CC      security/selinux/hooks.o
  CC      drivers/leds/led-class.o
  CC      sound/core/seq/seq_clientmgr.o
  CC      arch/x86/kernel/fpu/regset.o
  CC      arch/x86/pci/init.o
  CC      crypto/asymmetric_keys/restrict.o
  CC      arch/x86/realmode/rm/video-mode.o
  CC      security/keys/key.o
  CC      security/keys/keyring.o
  CC      arch/x86/platform/efi/quirks.o
  AR      fs/notify/dnotify/built-in.a
  AS      arch/x86/entry/vdso/vdso32/note.o
  CC      fs/nfs_common/common.o
  CC      ipc/shm.o
  CC      crypto/api.o
  AS      arch/x86/lib/getuser.o
  AS      arch/x86/entry/vdso/vdso32/system_call.o
  CC      arch/x86/power/hibernate_32.o
  CC      block/blk-sysfs.o
  AS      arch/x86/entry/vdso/vdso32/sigreturn.o
  GEN     arch/x86/lib/inat-tables.c
  CC      arch/x86/entry/vdso/vdso32/vclock_gettime.o
  CC      arch/x86/lib/insn-eval.o
  AS      arch/x86/realmode/rm/copy.o
  CC      block/partitions/msdos.o
  AS      arch/x86/realmode/rm/bioscall.o
  CC      arch/x86/realmode/rm/regs.o
  CC      fs/proc/root.o
  AR      lib/math/built-in.a
  CC      arch/x86/realmode/rm/video-vga.o
  CC      lib/crypto/mpi/generic_mpih-lshift.o
  CC      fs/proc/base.o
  CC      mm/mempool.o
  CC      arch/x86/realmode/rm/video-vesa.o
  CC      drivers/leds/led-triggers.o
  CC      arch/x86/realmode/rm/video-bios.o
  CC      fs/iomap/iter.o
  CC      lib/crypto/mpi/generic_mpih-mul1.o
  CC      crypto/asymmetric_keys/signature.o
  CC      arch/x86/events/amd/ibs.o
  CC      net/core/request_sock.o
  CC      net/core/skbuff.o
  PASYMS  arch/x86/realmode/rm/pasyms.h
  CC      sound/core/seq/seq_memory.o
  LDS     arch/x86/realmode/rm/realmode.lds
  CC      fs/proc/generic.o
  LD      arch/x86/realmode/rm/realmode.elf
  RELOCS  arch/x86/realmode/rm/realmode.relocs
  OBJCOPY arch/x86/realmode/rm/realmode.bin
  AS      arch/x86/realmode/rmpiggy.o
  AR      arch/x86/realmode/built-in.a
  CC      kernel/sched/build_policy.o
  CC      arch/x86/mm/pat/memtype.o
  CC      arch/x86/pci/pcbios.o
  CC      security/selinux/selinuxfs.o
  AR      security/integrity/built-in.a
  CC      sound/core/sound.o
  CC      arch/x86/kernel/cpu/mce/core.o
  CC      init/version.o
  CC      crypto/cipher.o
  AR      fs/nfs_common/built-in.a
  CC      arch/x86/entry/vdso/vdso32/vgetcpu.o
  AR      arch/x86/platform/geode/built-in.a
  AS      arch/x86/power/hibernate_asm_32.o
  HOSTCC  arch/x86/entry/vdso/vdso2c
  CC      arch/x86/power/hibernate.o
  AR      fs/notify/inotify/built-in.a
  CC      fs/notify/fsnotify.o
  CC      fs/notify/notification.o
  CC      arch/x86/events/amd/uncore.o
  CC      security/keys/keyctl.o
  AR      init/built-in.a
  CC      mm/oom_kill.o
  CC      arch/x86/kernel/fpu/signal.o
  CC      crypto/asymmetric_keys/public_key.o
  CC      arch/x86/platform/efi/efi.o
  CC      sound/core/init.o
  CC      block/partitions/efi.o
  CC      arch/x86/lib/insn.o
  CC      lib/crypto/mpi/generic_mpih-mul2.o
  CC      arch/x86/platform/efi/efi_32.o
  CC      arch/x86/mm/init.o
  AR      sound/drivers/opl3/built-in.a
  AR      drivers/leds/built-in.a
  CC      arch/x86/mm/init_32.o
  AR      sound/isa/ad1816a/built-in.a
  AR      sound/drivers/opl4/built-in.a
  CC      arch/x86/mm/fault.o
  AR      sound/isa/ad1848/built-in.a
  CC      drivers/pci/msi/pcidev_msi.o
  AR      sound/drivers/mpu401/built-in.a
  CC      drivers/pci/pcie/portdrv.o
  AR      sound/drivers/vx/built-in.a
  AR      sound/isa/cs423x/built-in.a
  AR      sound/drivers/pcsp/built-in.a
  AR      sound/isa/es1688/built-in.a
  AR      sound/drivers/built-in.a
  AR      sound/isa/galaxy/built-in.a
  CC      arch/x86/kernel/fpu/xstate.o
  AR      sound/isa/gus/built-in.a
  AR      sound/isa/msnd/built-in.a
  AR      sound/isa/opti9xx/built-in.a
  AR      sound/isa/sb/built-in.a
  CC      fs/iomap/buffered-io.o
  AR      sound/isa/wavefront/built-in.a
  CC      arch/x86/entry/vdso/vdso32-setup.o
  AR      sound/isa/wss/built-in.a
  AR      sound/isa/built-in.a
  CC      fs/quota/quota_v2.o
  CC      arch/x86/kernel/cpu/mce/severity.o
  CC      fs/notify/group.o
  CC      fs/proc/array.o
  AR      arch/x86/entry/vsyscall/built-in.a
  CC      sound/core/seq/seq_queue.o
  CC      ipc/syscall.o
  CC      arch/x86/kernel/cpu/mtrr/mtrr.o
  CC      arch/x86/lib/kaslr.o
  CC      arch/x86/pci/mmconfig_32.o
  CC      crypto/compress.o
  CC      arch/x86/kernel/cpu/mtrr/if.o
  ASN.1   crypto/asymmetric_keys/x509.asn1.[ch]
  AS      arch/x86/platform/efi/efi_stub_32.o
  AR      sound/pci/ac97/built-in.a
  AR      arch/x86/power/built-in.a
  AR      sound/pci/ali5451/built-in.a
  CC      arch/x86/kernel/cpu/mce/genpool.o
  AR      sound/ppc/built-in.a
  VDSO    arch/x86/entry/vdso/vdso32.so.dbg
  AR      sound/pci/asihpi/built-in.a
  CC      arch/x86/mm/pat/memtype_interval.o
  AR      sound/pci/au88x0/built-in.a
  CC      arch/x86/mm/ioremap.o
  AR      sound/pci/aw2/built-in.a
  CC      kernel/sched/build_utility.o
  AR      sound/pci/ctxfi/built-in.a
  OBJCOPY arch/x86/entry/vdso/vdso32.so
  VDSO2C  arch/x86/entry/vdso/vdso-image-32.c
  CC      arch/x86/entry/vdso/vdso-image-32.o
  AR      sound/pci/ca0106/built-in.a
  AR      sound/pci/cs46xx/built-in.a
  CC      arch/x86/lib/memcpy_32.o
  AR      sound/pci/cs5535audio/built-in.a
  AR      sound/pci/lola/built-in.a
  CC      lib/crypto/mpi/generic_mpih-mul3.o
  AR      sound/pci/lx6464es/built-in.a
  ASN.1   crypto/asymmetric_keys/x509_akid.asn1.[ch]
  AS      arch/x86/lib/memmove_32.o
  CC      crypto/asymmetric_keys/x509_loader.o
  AR      sound/pci/echoaudio/built-in.a
  CC      arch/x86/lib/misc.o
  AR      sound/pci/emu10k1/built-in.a
  CC      sound/pci/hda/hda_bind.o
  CC      arch/x86/lib/pc-conf-reg.o
  AR      sound/pci/ice1712/built-in.a
  AS      arch/x86/entry/entry.o
  CC      lib/zlib_inflate/inffast.o
  CC      sound/pci/hda/hda_codec.o
  CC      io_uring/kbuf.o
  CC      drivers/pci/msi/api.o
  CC      arch/x86/pci/direct.o
  AR      arch/x86/entry/vdso/built-in.a
  AS      arch/x86/entry/entry_32.o
  CC      crypto/asymmetric_keys/x509_public_key.o
  AS      arch/x86/lib/putuser.o
  CC      arch/x86/entry/syscall_32.o
  AR      block/partitions/built-in.a
  CC      arch/x86/platform/efi/runtime-map.o
  CC      arch/x86/kernel/cpu/microcode/core.o
  CC      drivers/pci/pcie/rcec.o
  AS      arch/x86/lib/retpoline.o
  CC      fs/quota/quota_tree.o
  CC      arch/x86/lib/string_32.o
  CC      lib/zlib_inflate/inflate.o
  CC      fs/notify/mark.o
  CC      arch/x86/kernel/cpu/microcode/intel.o
  AR      arch/x86/events/amd/built-in.a
  CC      block/blk-flush.o
  CC      arch/x86/events/intel/core.o
  CC      arch/x86/kernel/cpu/microcode/amd.o
  CC      arch/x86/lib/strstr_32.o
  CC      net/ethernet/eth.o
  CC      arch/x86/lib/usercopy.o
  CC      drivers/pci/pcie/bwctrl.o
  CC      drivers/pci/pcie/aspm.o
  CC      security/keys/permission.o
  CC      ipc/ipc_sysctl.o
  AR      sound/pci/korg1212/built-in.a
  CC      arch/x86/events/intel/bts.o
  CC      sound/core/seq/seq_fifo.o
  CC      mm/fadvise.o
  CC      arch/x86/entry/common.o
  CC      arch/x86/kernel/cpu/mtrr/generic.o
  AR      arch/x86/mm/pat/built-in.a
  ASN.1   crypto/asymmetric_keys/pkcs7.asn1.[ch]
  CC      fs/notify/fdinfo.o
  CC      lib/crypto/mpi/generic_mpih-rshift.o
  CC      drivers/video/console/dummycon.o
  CC      ipc/mqueue.o
  CC      lib/zlib_inflate/infutil.o
  AR      arch/x86/kernel/fpu/built-in.a
  CC      fs/proc/fd.o
  CC      arch/x86/events/zhaoxin/core.o
  CC      arch/x86/lib/usercopy_32.o
  CC      arch/x86/mm/extable.o
  AR      net/802/built-in.a
  CC      lib/zlib_inflate/inftrees.o
  CC      crypto/asymmetric_keys/pkcs7_trust.o
  AR      sound/arm/built-in.a
  CC      arch/x86/pci/mmconfig-shared.o
  CC      fs/proc/proc_tty.o
  CC      drivers/video/backlight/backlight.o
  CC      arch/x86/kernel/cpu/mce/intel.o
  CC      block/blk-settings.o
  CC      io_uring/rsrc.o
  CC      fs/iomap/direct-io.o
  CC      drivers/pci/msi/msi.o
  AR      drivers/pci/pwrctrl/built-in.a
  CC      security/keys/process_keys.o
  CC      kernel/locking/mutex.o
  CC      arch/x86/kernel/acpi/boot.o
  AR      arch/x86/platform/efi/built-in.a
  CC      arch/x86/lib/msr-smp.o
  AR      arch/x86/platform/iris/built-in.a
  CC      lib/zlib_inflate/inflate_syms.o
  CC      arch/x86/platform/intel/iosf_mbi.o
  CC      sound/core/seq/seq_prioq.o
  CC      arch/x86/mm/mmap.o
  CC      arch/x86/kernel/cpu/cacheinfo.o
  CC      arch/x86/pci/fixup.o
  CC      lib/crypto/mpi/generic_mpih-sub1.o
  CC      drivers/video/console/vgacon.o
  AR      drivers/idle/built-in.a
  CC      crypto/asymmetric_keys/pkcs7_verify.o
  CC      block/blk-ioc.o
  CC      kernel/locking/semaphore.o
  CC      fs/quota/quota.o
  AR      fs/notify/built-in.a
  CC      security/security.o
  AR      arch/x86/kernel/cpu/microcode/built-in.a
  CC      crypto/algapi.o
  CC      fs/kernfs/mount.o
  CC      fs/sysfs/file.o
  CC      arch/x86/lib/cache-smp.o
  CC      mm/maccess.o
  AS      arch/x86/entry/thunk.o
  AR      arch/x86/entry/built-in.a
  CC      arch/x86/lib/crc32-glue.o
  AR      lib/zlib_inflate/built-in.a
  CC      arch/x86/pci/acpi.o
  CC      fs/kernfs/inode.o
  CC      security/lsm_audit.o
  CC      arch/x86/events/core.o
  CC      arch/x86/kernel/cpu/mce/amd.o
  CC      fs/proc/cmdline.o
  AR      drivers/video/fbdev/core/built-in.a
  CC      drivers/pci/hotplug/pci_hotplug_core.o
  AR      drivers/video/fbdev/omap/built-in.a
  CC      arch/x86/kernel/cpu/mtrr/cleanup.o
  AR      arch/x86/events/zhaoxin/built-in.a
  CC      arch/x86/kernel/cpu/mtrr/amd.o
  AR      drivers/video/fbdev/omap2/omapfb/dss/built-in.a
  AR      drivers/video/fbdev/omap2/omapfb/displays/built-in.a
  AR      drivers/video/fbdev/omap2/omapfb/built-in.a
  CC      drivers/pci/pcie/pme.o
  CC      crypto/asymmetric_keys/x509.asn1.o
  AR      drivers/video/fbdev/omap2/built-in.a
  AR      drivers/video/fbdev/built-in.a
  CC      crypto/asymmetric_keys/x509_akid.asn1.o
  AR      arch/x86/platform/intel-mid/built-in.a
  CC      arch/x86/kernel/cpu/mce/threshold.o
  CC      crypto/asymmetric_keys/x509_cert_parser.o
  AR      net/ethernet/built-in.a
  CC      crypto/asymmetric_keys/pkcs7.asn1.o
  CC      arch/x86/mm/pgtable.o
  CC      lib/crypto/mpi/generic_mpih-add1.o
  CC      lib/zlib_deflate/deflate.o
  AS      arch/x86/lib/crc32-pclmul.o
  AR      arch/x86/platform/intel/built-in.a
  CC      kernel/locking/rwsem.o
  CC      arch/x86/lib/msr.o
  AR      arch/x86/platform/intel-quark/built-in.a
  CC      sound/core/seq/seq_timer.o
  AR      arch/x86/platform/olpc/built-in.a
  AR      drivers/video/backlight/built-in.a
  AR      arch/x86/platform/scx200/built-in.a
  AR      arch/x86/platform/ts5500/built-in.a
  AR      sound/sh/built-in.a
  CC      io_uring/notif.o
  AR      arch/x86/platform/uv/built-in.a
  AR      arch/x86/platform/built-in.a
  CC      drivers/pci/hotplug/acpi_pcihp.o
  CC      drivers/pci/msi/irqdomain.o
  CC      fs/iomap/fiemap.o
  CC      security/keys/request_key.o
  CC      block/blk-map.o
  CC      sound/pci/hda/hda_jack.o
  CC      fs/proc/consoles.o
  CC      mm/page-writeback.o
  CC      lib/zlib_deflate/deftree.o
  CC      sound/core/memory.o
  CC      arch/x86/kernel/acpi/sleep.o
  CC      fs/sysfs/dir.o
  CC      arch/x86/mm/physaddr.o
  CC      net/core/datagram.o
  AR      sound/pci/mixart/built-in.a
  CC      arch/x86/pci/legacy.o
  CC      security/selinux/netlink.o
  CC      fs/kernfs/dir.o
  CC      net/sched/sch_generic.o
  CC      ipc/namespace.o
  CC      fs/quota/kqid.o
  AR      drivers/video/console/built-in.a
  CC      drivers/video/aperture.o
  CC      fs/proc/cpuinfo.o
  CC      io_uring/tctx.o
  CC      security/keys/request_key_auth.o
  CC      crypto/asymmetric_keys/pkcs7_parser.o
  CC      lib/crypto/mpi/mpicoder.o
  CC      sound/core/seq/seq_system.o
  CC      arch/x86/kernel/cpu/mtrr/cyrix.o
  CC      security/selinux/nlmsgtab.o
  AR      drivers/pci/pcie/built-in.a
  CC      arch/x86/mm/tlb.o
  CC      lib/lzo/lzo1x_compress.o
  CC      io_uring/filetable.o
  CC      fs/sysfs/symlink.o
  CC      sound/pci/hda/hda_auto_parser.o
  CC      net/netlink/af_netlink.o
  AR      drivers/pci/hotplug/built-in.a
  CC      sound/pci/hda/hda_sysfs.o
  CC      mm/folio-compat.o
  CC      arch/x86/kernel/cpu/mtrr/centaur.o
  AS      arch/x86/lib/msr-reg.o
  CC      kernel/locking/percpu-rwsem.o
  CC      fs/iomap/seek.o
  AR      drivers/pci/msi/built-in.a
  CC      arch/x86/lib/msr-reg-export.o
  AR      drivers/pci/controller/dwc/built-in.a
  CC      fs/iomap/swapfile.o
  CC      lib/zlib_deflate/deflate_syms.o
  AR      drivers/pci/controller/mobiveil/built-in.a
  CC      arch/x86/events/intel/ds.o
  AR      drivers/pci/controller/plda/built-in.a
  CC      security/selinux/netif.o
  CC      security/device_cgroup.o
  AR      drivers/pci/controller/built-in.a
  AR      drivers/pci/switch/built-in.a
  CC      block/blk-merge.o
  CC      drivers/pci/access.o
  CC      fs/quota/netlink.o
  CC      ipc/mq_sysctl.o
  CC      fs/proc/devices.o
  AR      crypto/asymmetric_keys/built-in.a
  CC      block/blk-timeout.o
  CC      arch/x86/pci/irq.o
  CC      crypto/scatterwalk.o
  AS      arch/x86/lib/hweight.o
  AS      arch/x86/kernel/acpi/wakeup_32.o
  CC      arch/x86/lib/iomem.o
  CC      arch/x86/kernel/acpi/cstate.o
  CC      sound/core/control.o
  CC      security/keys/user_defined.o
  CC      sound/core/seq/seq_ports.o
  AR      arch/x86/kernel/cpu/mce/built-in.a
  CC      sound/core/seq/seq_info.o
  CC      sound/core/seq/seq_dummy.o
  CC      lib/lzo/lzo1x_decompress_safe.o
  CC      security/keys/proc.o
  CC      arch/x86/kernel/apic/apic.o
  AR      lib/zlib_deflate/built-in.a
  CC      arch/x86/kernel/kprobes/core.o
  CC      fs/sysfs/mount.o
  CC      drivers/video/cmdline.o
  CC      lib/crypto/mpi/mpi-add.o
  CC      arch/x86/kernel/cpu/mtrr/legacy.o
  CC      arch/x86/lib/atomic64_32.o
  AR      ipc/built-in.a
  CC      net/sched/sch_mq.o
  CC      kernel/locking/spinlock.o
  CC      crypto/proc.o
  AR      sound/synth/emux/built-in.a
  AR      sound/synth/built-in.a
  CC      arch/x86/lib/inat.o
  CC      arch/x86/events/probe.o
  AR      drivers/char/ipmi/built-in.a
  CC      io_uring/rw.o
  CC      lib/crypto/memneq.o
  CC      drivers/acpi/acpica/dsargs.o
  CC      io_uring/net.o
  CC      lib/crypto/utils.o
  AR      kernel/sched/built-in.a
  AR      arch/x86/lib/built-in.a
  AR      arch/x86/lib/lib.a
  AR      sound/usb/misc/built-in.a
  AR      fs/iomap/built-in.a
  AR      sound/usb/usx2y/built-in.a
  AR      sound/pci/nm256/built-in.a
  CC      fs/devpts/inode.o
  AR      sound/usb/caiaq/built-in.a
  CC      fs/netfs/buffered_read.o
  AR      arch/x86/kernel/acpi/built-in.a
  AR      sound/usb/6fire/built-in.a
  CC      drivers/video/nomodeset.o
  CC      fs/ext4/balloc.o
  AR      sound/usb/hiface/built-in.a
  AR      lib/lzo/built-in.a
  AR      sound/usb/bcd2000/built-in.a
  CC      net/netlink/genetlink.o
  AR      sound/usb/built-in.a
  CC      net/netlink/policy.o
  CC      fs/kernfs/file.o
  CC      fs/proc/interrupts.o
  CC      fs/ext4/bitmap.o
  AR      arch/x86/kernel/cpu/mtrr/built-in.a
  AR      sound/firewire/built-in.a
  CC      arch/x86/kernel/cpu/scattered.o
  AR      net/bpf/built-in.a
  CC      arch/x86/kernel/apic/apic_common.o
  CC      arch/x86/kernel/apic/apic_noop.o
  CC      sound/core/misc.o
  CC      drivers/acpi/acpica/dscontrol.o
  AR      fs/quota/built-in.a
  CC      arch/x86/mm/cpu_entry_area.o
  CC      crypto/aead.o
  CC      security/selinux/netnode.o
  CC      kernel/locking/osq_lock.o
  CC      mm/readahead.o
  CC      drivers/pci/bus.o
  CC      security/keys/sysctl.o
  CC      security/selinux/netport.o
  CC      sound/pci/hda/hda_controller.o
  CC      lib/crypto/mpi/mpi-bit.o
  AR      drivers/acpi/pmic/built-in.a
  CC      block/blk-lib.o
  CC      drivers/video/hdmi.o
  CC      kernel/power/qos.o
  AR      sound/core/seq/built-in.a
  CC      crypto/geniv.o
  CC      arch/x86/events/intel/knc.o
  CC      sound/pci/hda/hda_proc.o
  CC      arch/x86/kernel/cpu/topology_common.o
  CC      fs/sysfs/group.o
  CC      net/core/stream.o
  CC      kernel/locking/qspinlock.o
  CC      kernel/power/main.o
  CC      kernel/power/console.o
  CC      sound/core/device.o
  LDS     arch/x86/kernel/vmlinux.lds
  CC      sound/core/info.o
  CC      fs/netfs/buffered_write.o
  CC      fs/jbd2/transaction.o
  CC      fs/netfs/direct_read.o
  CC      drivers/acpi/acpica/dsdebug.o
  CC      fs/proc/loadavg.o
  CC      arch/x86/kernel/kprobes/opt.o
  CC      arch/x86/pci/common.o
  CC      fs/jbd2/commit.o
  AR      fs/devpts/built-in.a
  CC      fs/ext4/block_validity.o
  CC      lib/crypto/chacha.o
  CC      io_uring/poll.o
  CC      arch/x86/mm/maccess.o
  CC      net/core/scm.o
  CC      net/sched/sch_frag.o
  CC      security/keys/keyctl_pkey.o
  CC      drivers/pci/probe.o
  CC      drivers/acpi/acpica/dsfield.o
  CC      fs/kernfs/symlink.o
  CC      kernel/locking/rtmutex_api.o
  CC      arch/x86/kernel/cpu/topology_ext.o
  CC      lib/crypto/mpi/mpi-cmp.o
  CC      arch/x86/events/utils.o
  CC      sound/pci/hda/hda_hwdep.o
  CC      fs/ramfs/inode.o
  CC      arch/x86/pci/early.o
  CC      drivers/acpi/acpica/dsinit.o
  AS      arch/x86/kernel/head_32.o
  CC      block/blk-mq.o
  AR      fs/sysfs/built-in.a
  CC      fs/ramfs/file-mmu.o
  CC      net/core/gen_stats.o
  AR      drivers/video/built-in.a
  CC      arch/x86/mm/pgprot.o
  CC      net/ethtool/ioctl.o
  CC      net/ethtool/common.o
  CC      fs/proc/meminfo.o
  CC      arch/x86/kernel/apic/ipi.o
  CC      net/netfilter/core.o
  CC      arch/x86/events/intel/lbr.o
  CC      mm/swap.o
  CC      fs/hugetlbfs/inode.o
  CC      crypto/lskcipher.o
  CC      net/netfilter/nf_log.o
  CC      arch/x86/kernel/cpu/topology_amd.o
  CC      arch/x86/events/intel/p4.o
  CC      io_uring/eventfd.o
  CC      fs/fat/cache.o
  CC      security/selinux/status.o
  CC      sound/core/isadma.o
  CC      sound/pci/hda/hda_intel.o
  CC      drivers/acpi/acpica/dsmethod.o
  AR      arch/x86/kernel/kprobes/built-in.a
  CC      fs/jbd2/recovery.o
  CC      drivers/acpi/dptf/int340x_thermal.o
  AR      security/keys/built-in.a
  CC      drivers/acpi/x86/apple.o
  CC      arch/x86/events/rapl.o
  CC      lib/crypto/mpi/mpi-sub-ui.o
  CC      kernel/power/process.o
  CC      drivers/pnp/pnpacpi/core.o
  CC      arch/x86/events/intel/p6.o
  CC      fs/netfs/direct_write.o
  AR      fs/kernfs/built-in.a
  CC      drivers/pnp/core.o
  CC      crypto/skcipher.o
  CC      arch/x86/pci/bus_numa.o
  CC      net/ethtool/netlink.o
  CC      arch/x86/events/intel/pt.o
  CC      arch/x86/mm/pgtable_32.o
  CC      arch/x86/kernel/apic/vector.o
  AR      net/netlink/built-in.a
  CC      arch/x86/kernel/apic/init.o
  CC      mm/truncate.o
  CC      fs/ext4/dir.o
  AR      drivers/amba/built-in.a
  AR      fs/ramfs/built-in.a
  CC      block/blk-mq-tag.o
  CC      lib/crypto/aes.o
  CC      arch/x86/kernel/cpu/common.o
  CC      arch/x86/pci/amd_bus.o
  CC      sound/core/vmaster.o
  CC      fs/proc/stat.o
  CC      drivers/acpi/acpica/dsmthdat.o
  CC      kernel/locking/qrwlock.o
  AR      drivers/acpi/dptf/built-in.a
  CC      net/ipv4/netfilter/nf_defrag_ipv4.o
  CC      arch/x86/kernel/head32.o
  CC      drivers/pnp/pnpacpi/rsparser.o
  CC      drivers/acpi/x86/cmos_rtc.o
  CC      net/sched/sch_api.o
  CC      crypto/seqiv.o
  CC      sound/core/ctljack.o
  CC      lib/crypto/mpi/mpi-div.o
  CC      drivers/pci/host-bridge.o
  CC      net/core/gen_estimator.o
  AR      sound/pci/oxygen/built-in.a
  CC      fs/fat/dir.o
  CC      drivers/pci/remove.o
  CC      lib/crypto/arc4.o
  CC      drivers/acpi/acpica/dsobject.o
  CC      fs/proc/uptime.o
  CC      mm/vmscan.o
  CC      kernel/power/suspend.o
  CC      arch/x86/mm/iomap_32.o
  CC      fs/ext4/ext4_jbd2.o
  AR      kernel/locking/built-in.a
  CC      kernel/printk/printk.o
  AR      drivers/clk/actions/built-in.a
  CC      io_uring/uring_cmd.o
  AR      drivers/clk/analogbits/built-in.a
  CC      lib/crypto/gf128mul.o
  CC      fs/jbd2/checkpoint.o
  AR      drivers/clk/bcm/built-in.a
  AR      drivers/clk/imgtec/built-in.a
  CC      io_uring/openclose.o
  AR      drivers/clk/imx/built-in.a
  AR      drivers/clk/ingenic/built-in.a
  AR      drivers/clk/mediatek/built-in.a
  CC      sound/core/jack.o
  CC      security/selinux/ss/ebitmap.o
  AR      drivers/clk/microchip/built-in.a
  CC      arch/x86/mm/hugetlbpage.o
  CC      fs/netfs/iterator.o
  AR      drivers/clk/mstar/built-in.a
  CC      fs/netfs/locking.o
  CC      security/selinux/ss/hashtab.o
  AR      drivers/clk/mvebu/built-in.a
  CC      lib/crypto/mpi/mpi-mod.o
  AR      drivers/clk/ralink/built-in.a
  AR      drivers/clk/renesas/built-in.a
  AR      drivers/clk/socfpga/built-in.a
  CC      net/netfilter/nf_queue.o
  AR      drivers/clk/sophgo/built-in.a
  AR      drivers/clk/sprd/built-in.a
  CC      crypto/echainiv.o
  AR      drivers/clk/starfive/built-in.a
  AR      sound/pci/pcxhr/built-in.a
  AR      arch/x86/pci/built-in.a
  AR      drivers/clk/sunxi-ng/built-in.a
  CC      net/ipv4/route.o
  CC      lib/crypto/blake2s.o
  CC      fs/fat/fatent.o
  AR      drivers/clk/ti/built-in.a
  CC      drivers/pnp/card.o
  AR      drivers/clk/versatile/built-in.a
  AR      drivers/clk/xilinx/built-in.a
  AR      drivers/clk/built-in.a
  CC      net/sched/sch_blackhole.o
  CC      drivers/acpi/x86/lpss.o
  CC      fs/ext4/extents.o
  CC      arch/x86/events/msr.o
  CC      drivers/acpi/acpica/dsopcode.o
  CC      block/blk-stat.o
  CC      kernel/irq/irqdesc.o
  CC      kernel/rcu/update.o
  AR      kernel/livepatch/built-in.a
  CC      net/ethtool/bitset.o
  CC      net/ethtool/strset.o
  AR      fs/hugetlbfs/built-in.a
  CC      fs/netfs/main.o
  CC      lib/lz4/lz4_decompress.o
  CC      fs/proc/util.o
  AR      sound/sparc/built-in.a
  CC      drivers/pci/pci.o
  CC      net/ipv4/inetpeer.o
  CC      drivers/acpi/tables.o
  AR      sound/spi/built-in.a
  CC      arch/x86/mm/dump_pagetables.o
  AR      drivers/pnp/pnpacpi/built-in.a
  AR      sound/pci/hda/built-in.a
  CC      lib/crypto/blake2s-generic.o
  AR      sound/pci/riptide/built-in.a
  AR      sound/pci/rme9652/built-in.a
  CC      sound/core/hwdep.o
  CC      kernel/power/hibernate.o
  AR      sound/pci/trident/built-in.a
  CC      arch/x86/events/intel/uncore.o
  AR      sound/pci/ymfpci/built-in.a
  AR      sound/pci/vx222/built-in.a
  CC      net/ipv4/netfilter/nf_reject_ipv4.o
  AR      sound/pci/built-in.a
  CC      arch/x86/kernel/cpu/rdrand.o
  CC      lib/crypto/mpi/mpi-mul.o
  CC      fs/jbd2/revoke.o
  CC      arch/x86/kernel/ebda.o
  CC      net/core/net_namespace.o
  CC      drivers/acpi/acpica/dspkginit.o
  CC      crypto/ahash.o
  CC      arch/x86/kernel/apic/hw_nmi.o
  CC      io_uring/sqpoll.o
  CC      lib/crypto/mpi/mpih-cmp.o
  CC      drivers/pnp/driver.o
  CC      arch/x86/kernel/cpu/match.o
  CC      drivers/pci/pci-driver.o
  CC      security/selinux/ss/symtab.o
  CC      kernel/dma/mapping.o
  CC      drivers/acpi/x86/s2idle.o
  CC      sound/core/timer.o
  CC      drivers/acpi/acpica/dsutils.o
  CC      fs/proc/version.o
  CC      kernel/entry/common.o
  CC      kernel/irq/handle.o
  CC      kernel/module/main.o
  CC      kernel/time/time.o
  CC      kernel/futex/core.o
  CC      kernel/futex/syscalls.o
  CC      arch/x86/kernel/cpu/bugs.o
  CC      security/selinux/ss/sidtab.o
  CC      security/selinux/ss/avtab.o
  CC      drivers/pnp/resource.o
  CC      kernel/entry/syscall_user_dispatch.o
  CC      fs/isofs/namei.o
  CC      arch/x86/mm/highmem_32.o
  CC      drivers/pnp/manager.o
  CC      fs/nfs/client.o
  CC      net/netfilter/nf_sockopt.o
  CC      arch/x86/kernel/apic/io_apic.o
  CC      fs/fat/file.o
  CC      lib/crypto/sha1.o
  CC      fs/nfs/dir.o
  CC      drivers/acpi/acpica/dswexec.o
  CC      lib/crypto/mpi/mpih-div.o
  CC      drivers/acpi/acpica/dswload.o
  CC      fs/jbd2/journal.o
  CC      fs/proc/softirqs.o
  CC      drivers/acpi/x86/utils.o
  CC      kernel/irq/manage.o
  CC      fs/isofs/inode.o
  CC      net/sched/cls_api.o
  CC      net/ethtool/linkinfo.o
  AR      lib/lz4/built-in.a
  CC      lib/crypto/mpi/mpih-mul.o
  CC      crypto/shash.o
  CC      kernel/printk/printk_safe.o
  CC      kernel/power/snapshot.o
  CC      kernel/dma/direct.o
  CC      net/ipv4/netfilter/ip_tables.o
  CC      fs/exportfs/expfs.o
  CC      drivers/acpi/acpica/dswload2.o
  CC      net/ethtool/linkmodes.o
  CC      lib/crypto/mpi/mpi-pow.o
  AR      arch/x86/mm/built-in.a
  CC      kernel/time/timer.o
  CC      block/blk-mq-sysfs.o
  CC      net/ipv4/netfilter/iptable_filter.o
  CC      fs/netfs/misc.o
  AR      sound/parisc/built-in.a
  CC      kernel/dma/ops_helpers.o
  AR      kernel/entry/built-in.a
  CC      io_uring/xattr.o
  CC      kernel/futex/pi.o
  CC      fs/proc/namespaces.o
  CC      kernel/futex/requeue.o
  CC      arch/x86/events/intel/uncore_nhmex.o
  CC      net/core/secure_seq.o
  CC      drivers/acpi/acpica/dswscope.o
  AR      sound/pcmcia/vx/built-in.a
  AR      sound/pcmcia/pdaudiocf/built-in.a
  AR      sound/pcmcia/built-in.a
  CC      kernel/irq/spurious.o
  CC      drivers/acpi/x86/blacklist.o
  CC      drivers/pnp/support.o
  CC      net/netfilter/utils.o
  AR      sound/mips/built-in.a
  CC      drivers/pnp/interface.o
  CC      io_uring/nop.o
  CC      fs/netfs/objects.o
  CC      fs/fat/inode.o
  CC      kernel/printk/nbcon.o
  CC      crypto/akcipher.o
  CC      io_uring/fs.o
  CC      sound/core/hrtimer.o
  CC      security/selinux/ss/policydb.o
  AR      fs/exportfs/built-in.a
  CC      fs/ext4/extents_status.o
  CC      drivers/acpi/acpica/dswstate.o
  CC      kernel/futex/waitwake.o
  CC      lib/crypto/mpi/mpiutil.o
  CC      mm/shrinker.o
  CC      block/blk-mq-cpumap.o
  AR      drivers/acpi/x86/built-in.a
  CC      net/ipv4/netfilter/iptable_mangle.o
  CC      net/xfrm/xfrm_policy.o
  CC      drivers/acpi/osi.o
  CC      arch/x86/events/intel/uncore_snb.o
  CC      fs/isofs/dir.o
  CC      arch/x86/kernel/cpu/aperfmperf.o
  CC      net/ethtool/rss.o
  CC      arch/x86/events/intel/uncore_snbep.o
  CC      arch/x86/events/intel/uncore_discovery.o
  CC      fs/proc/self.o
  CC      kernel/rcu/sync.o
  CC      kernel/dma/remap.o
  CC      net/netfilter/nfnetlink.o
  CC      drivers/pnp/quirks.o
  CC      fs/proc/thread_self.o
  CC      net/netfilter/nfnetlink_log.o
  CC      kernel/irq/resend.o
  CC      kernel/printk/printk_ringbuffer.o
  CC      arch/x86/events/intel/cstate.o
  CC      drivers/acpi/acpica/evevent.o
  CC      drivers/pci/search.o
  CC      sound/core/pcm.o
  CC      arch/x86/kernel/apic/msi.o
  CC      drivers/pci/rom.o
  CC      kernel/time/hrtimer.o
  CC      drivers/acpi/acpica/evgpe.o
  CC      kernel/rcu/srcutree.o
  CC      fs/netfs/read_collect.o
  CC      drivers/acpi/osl.o
  CC      net/core/flow_dissector.o
  CC      crypto/sig.o
  AR      lib/crypto/mpi/built-in.a
  CC      drivers/acpi/acpica/evgpeblk.o
  CC      io_uring/splice.o
  CC      lib/crypto/sha256.o
  CC      kernel/module/strict_rwx.o
  CC      net/netfilter/nf_conntrack_core.o
  AR      kernel/futex/built-in.a
  CC      kernel/power/swap.o
  CC      net/xfrm/xfrm_state.o
  CC      block/blk-mq-sched.o
  CC      kernel/irq/chip.o
  CC      arch/x86/kernel/cpu/cpuid-deps.o
  CC      block/ioctl.o
  CC      block/genhd.o
  CC      arch/x86/kernel/apic/probe_32.o
  CC      mm/shmem.o
  AR      kernel/dma/built-in.a
  CC      kernel/printk/sysctl.o
  CC      fs/isofs/util.o
  CC      fs/isofs/rock.o
  CC      fs/proc/proc_sysctl.o
  CC      sound/core/pcm_native.o
  CC      drivers/acpi/utils.o
  CC      drivers/dma/dw/core.o
  CC      net/ipv4/netfilter/ipt_REJECT.o
  CC      drivers/acpi/acpica/evgpeinit.o
  CC      drivers/dma/dw/dw.o
  CC      fs/netfs/read_pgpriv2.o
  CC      fs/ext4/file.o
  CC      drivers/pnp/system.o
  CC      drivers/pci/setup-res.o
  CC [M]  net/ipv4/netfilter/iptable_nat.o
  CC      crypto/kpp.o
  CC      net/ethtool/linkstate.o
  CC      arch/x86/kernel/cpu/umwait.o
  AR      kernel/printk/built-in.a
  CC      fs/fat/misc.o
  ASN.1   crypto/rsapubkey.asn1.[ch]
  ASN.1   crypto/rsaprivkey.asn1.[ch]
  CC      kernel/irq/dummychip.o
  CC      kernel/module/kmod.o
  AR      sound/soc/built-in.a
  CC      net/xfrm/xfrm_hash.o
  AR      arch/x86/kernel/apic/built-in.a
  AR      lib/crypto/built-in.a
  CC      block/ioprio.o
  CC      kernel/power/user.o
  CC      lib/zstd/zstd_decompress_module.o
  AR      fs/jbd2/built-in.a
  CC      net/netfilter/nf_conntrack_standalone.o
  MKCAP   arch/x86/kernel/cpu/capflags.c
  CC      arch/x86/kernel/cpu/powerflags.o
  CC      net/sched/act_api.o
  CC      io_uring/sync.o
  CC      security/selinux/ss/services.o
  CC      drivers/acpi/acpica/evgpeutil.o
  CC      fs/netfs/read_retry.o
  AR      drivers/pnp/built-in.a
  CC      fs/proc/proc_net.o
  CC      kernel/rcu/tree.o
  CC      fs/nfs/file.o
  CC      kernel/irq/devres.o
  CC      lib/zstd/decompress/huf_decompress.o
  CC      kernel/irq/kexec.o
  CC      arch/x86/kernel/cpu/topology.o
  CC      arch/x86/kernel/cpu/proc.o
  CC      fs/lockd/clntlock.o
  CC      security/selinux/ss/conditional.o
  CC      fs/nls/nls_base.o
  CC      fs/isofs/export.o
  CC      net/netfilter/nf_conntrack_expect.o
  CC      net/netfilter/nf_conntrack_helper.o
  CC      fs/lockd/clntproc.o
  CC      block/badblocks.o
  CC      drivers/acpi/acpica/evglock.o
  AR      sound/atmel/built-in.a
  CC      drivers/pci/irq.o
  CC      fs/nls/nls_cp437.o
  CC      kernel/time/sleep_timeout.o
  CC      fs/ext4/fsmap.o
  CC      crypto/rsa.o
  CC      net/core/sysctl_net_core.o
  CC      kernel/power/poweroff.o
  CC      net/unix/af_unix.o
  CC      kernel/module/tree_lookup.o
  CC      fs/fat/nfs.o
  CC      net/ipv4/protocol.o
  AR      drivers/soc/apple/built-in.a
  AR      drivers/soc/aspeed/built-in.a
  CC      arch/x86/kernel/platform-quirks.o
  AR      drivers/soc/bcm/built-in.a
  CC      kernel/irq/autoprobe.o
  AR      drivers/soc/fsl/built-in.a
  AR      drivers/soc/fujitsu/built-in.a
  CC      drivers/dma/dw/idma32.o
  CC      lib/xz/xz_dec_syms.o
  AR      drivers/soc/hisilicon/built-in.a
  AR      drivers/soc/imx/built-in.a
  AR      drivers/soc/ixp4xx/built-in.a
  AR      drivers/soc/loongson/built-in.a
  AR      drivers/soc/mediatek/built-in.a
  CC      net/ethtool/debug.o
  AR      drivers/soc/microchip/built-in.a
  AR      kernel/power/built-in.a
  AR      drivers/soc/nuvoton/built-in.a
  CC      fs/netfs/read_single.o
  AR      drivers/soc/pxa/built-in.a
  CC      fs/netfs/rolling_buffer.o
  AR      drivers/soc/amlogic/built-in.a
  CC      io_uring/msg_ring.o
  AR      net/ipv4/netfilter/built-in.a
  CC      drivers/acpi/acpica/evhandler.o
  AR      arch/x86/events/intel/built-in.a
  AR      drivers/soc/qcom/built-in.a
  CC      net/core/dev.o
  AR      arch/x86/events/built-in.a
  AR      drivers/soc/renesas/built-in.a
  CC      fs/nls/nls_ascii.o
  CC      fs/netfs/write_collect.o
  CC      drivers/acpi/reboot.o
  AR      drivers/soc/rockchip/built-in.a
  AR      drivers/soc/sunxi/built-in.a
  AR      drivers/soc/ti/built-in.a
  AR      drivers/soc/versatile/built-in.a
  AR      drivers/soc/xilinx/built-in.a
  AR      drivers/soc/built-in.a
  CC      block/blk-rq-qos.o
  CC      lib/zstd/decompress/zstd_ddict.o
  CC      fs/fat/namei_vfat.o
  CC      drivers/dma/dw/acpi.o
  CC      kernel/time/timekeeping.o
  CC      fs/isofs/joliet.o
  CC      net/ipv6/netfilter/ip6_tables.o
  CC      net/core/dev_addr_lists.o
  CC      lib/xz/xz_dec_stream.o
  CC      fs/proc/kcore.o
  CC      fs/fat/namei_msdos.o
  CC      drivers/pci/vpd.o
  CC      kernel/cgroup/cgroup.o
  CC      crypto/rsa_helper.o
  CC      kernel/irq/irqdomain.o
  CC      kernel/module/kallsyms.o
  CC      fs/nls/nls_iso8859-1.o
  CC      lib/dim/dim.o
  CC      drivers/acpi/acpica/evmisc.o
  CC      lib/dim/net_dim.o
  CC      lib/dim/rdma_dim.o
  CC      lib/fonts/fonts.o
  CC      crypto/rsa-pkcs1pad.o
  CC      lib/argv_split.o
  CC      drivers/acpi/nvs.o
  CC      drivers/acpi/wakeup.o
  CC      lib/xz/xz_dec_lzma2.o
  CC      fs/nls/nls_utf8.o
  CC      lib/zstd/decompress/zstd_decompress.o
  CC      drivers/virtio/virtio.o
  CC      net/ipv4/ip_input.o
  CC      kernel/time/ntp.o
  AR      drivers/dma/dw/built-in.a
  CC      drivers/acpi/acpica/evregion.o
  CC      sound/hda/hda_bus_type.o
  CC      drivers/dma/hsu/hsu.o
  CC      drivers/pci/setup-bus.o
  CC      fs/isofs/compress.o
  CC      io_uring/advise.o
  CC      net/netfilter/nf_conntrack_proto.o
  CC      net/ethtool/wol.o
  CC      block/disk-events.o
  CC      block/blk-ia-ranges.o
  CC      lib/fonts/font_8x16.o
  CC      drivers/virtio/virtio_ring.o
  CC      fs/lockd/clntxdr.o
  CC      net/sched/sch_fifo.o
  CC      lib/zstd/decompress/zstd_decompress_block.o
  CC      kernel/rcu/rcu_segcblist.o
  CC      mm/util.o
  CC      sound/core/pcm_lib.o
  CC      fs/netfs/write_issue.o
  CC      kernel/module/procfs.o
  CC      fs/proc/vmcore.o
  CC      arch/x86/kernel/cpu/feat_ctl.o
  CC      kernel/time/clocksource.o
  AR      fs/nls/built-in.a
  CC      fs/lockd/host.o
  CC      fs/nfs/getroot.o
  CC      net/unix/garbage.o
  CC      lib/xz/xz_dec_bcj.o
  CC      drivers/acpi/acpica/evrgnini.o
  AR      lib/fonts/built-in.a
  CC      crypto/rsassa-pkcs1.o
  CC      fs/ext4/fsync.o
  CC      net/ipv6/af_inet6.o
  AR      fs/fat/built-in.a
  AR      sound/x86/built-in.a
  CC      kernel/cgroup/rstat.o
  CC      net/xfrm/xfrm_input.o
  CC      net/packet/af_packet.o
  CC      sound/hda/hdac_bus.o
  CC      drivers/acpi/acpica/evsci.o
  CC      net/ethtool/features.o
  CC      kernel/irq/proc.o
  AR      lib/dim/built-in.a
  CC      net/sched/cls_cgroup.o
  CC      fs/lockd/svc.o
  CC      fs/lockd/svclock.o
  CC      drivers/tty/vt/vt_ioctl.o
  AR      drivers/dma/hsu/built-in.a
  CC      net/ipv6/netfilter/ip6table_filter.o
  CC      io_uring/epoll.o
  AR      drivers/dma/idxd/built-in.a
  CC      sound/core/pcm_misc.o
  AR      drivers/dma/amd/built-in.a
  CC      block/early-lookup.o
  CC      block/bounce.o
  AR      drivers/dma/mediatek/built-in.a
  AR      drivers/dma/qcom/built-in.a
  AR      fs/isofs/built-in.a
  CC      kernel/trace/trace_clock.o
  AR      drivers/dma/stm32/built-in.a
  CC      io_uring/statx.o
  CC      kernel/bpf/core.o
  AR      drivers/dma/ti/built-in.a
  CC      kernel/module/sysfs.o
  AR      drivers/dma/xilinx/built-in.a
  CC      security/selinux/ss/mls.o
  CC      drivers/dma/dmaengine.o
  AR      lib/xz/built-in.a
  CC      kernel/events/core.o
  CC      drivers/acpi/acpica/evxface.o
  CC      lib/zstd/zstd_common_module.o
  CC      net/core/dst.o
  CC      crypto/acompress.o
  CC      block/bsg.o
  CC      kernel/time/jiffies.o
  CC      sound/core/pcm_memory.o
  CC      kernel/trace/ring_buffer.o
  CC      net/ipv4/ip_fragment.o
  CC      mm/mmzone.o
  CC      fs/proc/kmsg.o
  CC      sound/hda/hdac_device.o
  CC      net/core/netevent.o
  CC      io_uring/timeout.o
  CC      kernel/irq/migration.o
  CC      fs/nfs/inode.o
  CC      net/netfilter/nf_conntrack_proto_generic.o
  CC      net/unix/sysctl_net_unix.o
  CC      fs/netfs/write_retry.o
  CC      drivers/acpi/acpica/evxfevnt.o
  CC      drivers/acpi/acpica/evxfgpe.o
  CC      kernel/irq/cpuhotplug.o
  CC      net/ipv6/anycast.o
  CC      net/ipv4/ip_forward.o
  CC      net/netfilter/nf_conntrack_proto_tcp.o
  CC      net/ethtool/privflags.o
  AR      kernel/module/built-in.a
  CC      drivers/pci/vc.o
  CC      kernel/time/timer_list.o
  CC      drivers/tty/vt/vc_screen.o
  CC      net/ipv4/ip_options.o
  CC      fs/ext4/hash.o
  CC      net/sched/ematch.o
  CC      fs/proc/page.o
  CC      net/ipv4/ip_output.o
  CC      net/ipv4/ip_sockglue.o
  CC      net/ipv4/inet_hashtables.o
  CC      mm/vmstat.o
  CC      drivers/dma/virt-dma.o
  CC      block/blk-cgroup.o
  CC      drivers/virtio/virtio_anchor.o
  CC      net/core/neighbour.o
  CC      sound/hda/hdac_sysfs.o
  CC      crypto/scompress.o
  CC      net/ipv6/netfilter/ip6table_mangle.o
  CC      drivers/acpi/acpica/evxfregn.o
  CC      sound/core/memalloc.o
  CC      fs/lockd/svcshare.o
  CC      net/xfrm/xfrm_output.o
  CC      security/selinux/ss/context.o
  CC      arch/x86/kernel/cpu/intel.o
  CC      drivers/dma/acpi-dma.o
  CC      arch/x86/kernel/cpu/tsx.o
  AR      kernel/rcu/built-in.a
  CC      net/xfrm/xfrm_sysctl.o
  CC      kernel/irq/pm.o
  CC      net/netfilter/nf_conntrack_proto_udp.o
  CC      drivers/acpi/sleep.o
  CC      drivers/acpi/acpica/exconcat.o
  CC      lib/zstd/common/debug.o
  CC      kernel/time/timeconv.o
  CC      lib/zstd/common/entropy_common.o
  AR      net/unix/built-in.a
  CC      kernel/time/timecounter.o
  CC      drivers/pci/mmap.o
  AR      fs/netfs/built-in.a
  CC      kernel/trace/trace.o
  CC      drivers/acpi/device_sysfs.o
  CC      drivers/virtio/virtio_pci_modern_dev.o
  CC      io_uring/fdinfo.o
  CC      lib/bug.o
  AR      sound/xen/built-in.a
  CC      fs/nfs/super.o
  CC      fs/ext4/ialloc.o
  CC      drivers/tty/vt/selection.o
  CC      mm/backing-dev.o
  CC      lib/zstd/common/error_private.o
  AR      fs/proc/built-in.a
  CC      sound/hda/hdac_regmap.o
  CC      net/ethtool/rings.o
  CC      lib/zstd/common/fse_decompress.o
  CC      lib/zstd/common/zstd_common.o
  CC      fs/lockd/svcproc.o
  CC      crypto/algboss.o
  CC      kernel/time/alarmtimer.o
  CC      drivers/acpi/acpica/exconfig.o
  CC      net/ipv4/inet_timewait_sock.o
  CC      arch/x86/kernel/process_32.o
  CC      drivers/virtio/virtio_pci_legacy_dev.o
  AR      net/sched/built-in.a
  CC      drivers/virtio/virtio_pci_modern.o
  AR      drivers/dma/built-in.a
  CC      drivers/pci/devres.o
  CC      net/netfilter/nf_conntrack_proto_icmp.o
  CC      sound/core/pcm_timer.o
  CC      arch/x86/kernel/cpu/intel_epb.o
  CC      kernel/irq/msi.o
  CC      fs/nfs/io.o
  AR      net/dsa/built-in.a
  CC      fs/ext4/indirect.o
  CC      security/selinux/netlabel.o
  CC      mm/mm_init.o
  CC      net/ipv6/netfilter/nf_defrag_ipv6_hooks.o
  AR      lib/zstd/built-in.a
  CC      block/blk-ioprio.o
  CC      lib/buildid.o
  CC      drivers/tty/hvc/hvc_console.o
  CC      drivers/acpi/acpica/exconvrt.o
  CC      sound/hda/hdac_controller.o
  CC      drivers/char/hw_random/core.o
  CC      net/netfilter/nf_conntrack_extend.o
  CC      drivers/char/agp/backend.o
  CC      drivers/tty/vt/keyboard.o
  CC      io_uring/cancel.o
  CC      arch/x86/kernel/cpu/amd.o
  CC      arch/x86/kernel/signal.o
  CC      drivers/tty/serial/8250/8250_core.o
  CC      kernel/fork.o
  CC      drivers/char/mem.o
  CC      net/core/rtnetlink.o
  AR      kernel/bpf/built-in.a
  CC      net/sunrpc/auth_gss/auth_gss.o
  CC      sound/core/seq_device.o
  CC      net/xfrm/xfrm_replay.o
  CC      net/ethtool/channels.o
  CC      drivers/acpi/acpica/excreate.o
  CC      net/sunrpc/clnt.o
  CC      crypto/testmgr.o
  AR      net/packet/built-in.a
  CC      kernel/cgroup/namespace.o
  CC      net/ipv6/netfilter/nf_conntrack_reasm.o
  CC      net/core/utils.o
  CC      drivers/pci/proc.o
  CC      kernel/irq/affinity.o
  CC      block/blk-iolatency.o
  CC      drivers/virtio/virtio_pci_common.o
  CC      net/ipv6/ip6_output.o
  CC      lib/clz_tab.o
  CC      lib/cmdline.o
  CC      kernel/time/posix-timers.o
  CC      fs/lockd/svcsubs.o
  CC      arch/x86/kernel/cpu/hygon.o
  CC      io_uring/waitid.o
  CC      drivers/tty/vt/vt.o
  CC      net/ipv4/inet_connection_sock.o
  CC      lib/cpumask.o
  CC      drivers/char/agp/generic.o
  CC      drivers/acpi/device_pm.o
  AR      drivers/tty/hvc/built-in.a
  CC      drivers/char/random.o
  CC      drivers/char/hw_random/intel-rng.o
  CC      fs/nfs/direct.o
  CC      drivers/tty/serial/serial_core.o
  CC      drivers/acpi/acpica/exdebug.o
  CC      mm/percpu.o
  CC      sound/hda/hdac_stream.o
  AR      sound/core/built-in.a
  CC      kernel/irq/matrix.o
  CC      drivers/char/agp/isoch.o
  CC      fs/ext4/inline.o
  CC      crypto/cmac.o
  AR      fs/unicode/built-in.a
  CC      arch/x86/kernel/signal_32.o
  CC      net/netfilter/nf_conntrack_acct.o
  CC      drivers/tty/serial/8250/8250_platform.o
  CC      net/sunrpc/xprt.o
  AR      net/wireless/tests/built-in.a
  CC      net/wireless/core.o
  CC      kernel/cgroup/cgroup-v1.o
  CC      arch/x86/kernel/cpu/centaur.o
  AR      security/selinux/built-in.a
  AR      security/built-in.a
  CC      net/core/link_watch.o
  CC      fs/lockd/mon.o
  CC      fs/nfs/pagelist.o
  CC      drivers/acpi/acpica/exdump.o
  CC      net/wireless/sysfs.o
  CC      drivers/pci/pci-sysfs.o
  CC      lib/ctype.o
  CC      lib/dec_and_lock.o
  CC      net/ipv6/ip6_input.o
  CC      drivers/tty/serial/8250/8250_pnp.o
  CC      crypto/hmac.o
  CC      drivers/char/hw_random/amd-rng.o
  CC      net/ethtool/coalesce.o
  CC      drivers/virtio/virtio_pci_legacy.o
  CC      net/ipv4/tcp.o
  CC      net/xfrm/xfrm_device.o
  CC      drivers/acpi/acpica/exfield.o
  CC      arch/x86/kernel/cpu/transmeta.o
  AR      drivers/tty/ipwireless/built-in.a
  CC      lib/decompress.o
  CC      sound/hda/array.o
  CC      io_uring/register.o
  CC      lib/decompress_bunzip2.o
  CC      block/blk-iocost.o
  CC      drivers/pci/slot.o
  CC      kernel/trace/trace_output.o
  CC      net/ipv6/netfilter/nf_reject_ipv6.o
  CC      net/xfrm/xfrm_nat_keepalive.o
  CC      drivers/char/agp/amd64-agp.o
  CC      kernel/events/ring_buffer.o
  CC      net/wireless/radiotap.o
  CC      crypto/crypto_null.o
  CC      kernel/time/posix-cpu-timers.o
  CC      drivers/acpi/acpica/exfldio.o
  CC      drivers/char/hw_random/geode-rng.o
  CC      net/netfilter/nf_conntrack_seqadj.o
  CC      drivers/char/misc.o
  CC      net/core/filter.o
  CC      drivers/virtio/virtio_pci_admin_legacy_io.o
  AR      kernel/irq/built-in.a
  CC      drivers/tty/serial/8250/8250_rsa.o
  CC      fs/autofs/init.o
  CC      arch/x86/kernel/cpu/zhaoxin.o
  CC      sound/hda/hdmi_chmap.o
  AR      sound/virtio/built-in.a
  CC      kernel/events/callchain.o
  CC      fs/lockd/trace.o
  CC      lib/decompress_inflate.o
  CC      net/sunrpc/auth_gss/gss_mech_switch.o
  CC      kernel/cgroup/freezer.o
  CC      drivers/acpi/acpica/exmisc.o
  CC      crypto/md5.o
  CC      net/ipv4/tcp_input.o
  CC      kernel/trace/trace_seq.o
  CC      fs/ext4/inode.o
  CC      net/ipv6/addrconf.o
  CC      drivers/pci/pci-acpi.o
  CC      drivers/char/agp/intel-agp.o
  CC      net/ethtool/pause.o
  CC      arch/x86/kernel/cpu/vortex.o
  CC      drivers/char/hw_random/via-rng.o
  CC      arch/x86/kernel/cpu/perfctr-watchdog.o
  AR      net/mac80211/tests/built-in.a
  CC      net/mac80211/main.o
  CC      drivers/tty/serial/8250/8250_port.o
  CC      drivers/virtio/virtio_input.o
  CC      net/ipv6/netfilter/ip6t_ipv6header.o
  CC      net/netfilter/nf_conntrack_proto_icmpv6.o
  CC      drivers/acpi/acpica/exmutex.o
  CC      fs/autofs/inode.o
  CC      lib/decompress_unlz4.o
  CC      kernel/cgroup/legacy_freezer.o
  CC      fs/ext4/ioctl.o
  CC      drivers/acpi/acpica/exnames.o
  CC      net/wireless/util.o
  CC      kernel/exec_domain.o
  CC      kernel/time/posix-clock.o
  CC      net/xfrm/xfrm_algo.o
  CC      mm/slab_common.o
  CC      crypto/sha256_generic.o
  AR      drivers/iommu/amd/built-in.a
  CC      fs/nfs/read.o
  AR      drivers/iommu/intel/built-in.a
  CC      fs/9p/vfs_super.o
  AR      drivers/char/hw_random/built-in.a
  AR      drivers/iommu/arm/arm-smmu/built-in.a
  CC      fs/lockd/xdr.o
  AR      drivers/iommu/arm/arm-smmu-v3/built-in.a
  CC      fs/9p/vfs_inode.o
  AR      drivers/iommu/arm/built-in.a
  COPY    drivers/tty/vt/defkeymap.c
  CC      fs/9p/vfs_inode_dotl.o
  CC      drivers/tty/vt/consolemap.o
  CC      sound/hda/trace.o
  AR      drivers/iommu/iommufd/built-in.a
  CC      sound/hda/hdac_component.o
  AR      drivers/iommu/riscv/built-in.a
  CC      drivers/iommu/iommu.o
  CC      io_uring/truncate.o
  CC      fs/9p/vfs_addr.o
  CC      kernel/trace/trace_stat.o
  CC      crypto/sha512_generic.o
  CC      lib/decompress_unlzma.o
  CC      drivers/char/virtio_console.o
  CC      drivers/pci/iomap.o
  CC      arch/x86/kernel/cpu/vmware.o
  CC      drivers/acpi/acpica/exoparg1.o
  CC      drivers/char/agp/intel-gtt.o
  CC      crypto/sha3_generic.o
  CC      net/sunrpc/auth_gss/svcauth_gss.o
  CC      drivers/virtio/virtio_dma_buf.o
  CC      kernel/events/hw_breakpoint.o
  CC      net/wireless/reg.o
  CC      kernel/cgroup/pids.o
  CC      kernel/panic.o
  CC      fs/autofs/root.o
  CC      net/ethtool/eee.o
  CC      drivers/tty/serial/serial_base_bus.o
  CC      net/ipv4/tcp_output.o
  CC      kernel/time/itimer.o
  CC      net/xfrm/xfrm_user.o
  CC      drivers/char/hpet.o
  CC      net/core/sock_diag.o
  CC      drivers/acpi/acpica/exoparg2.o
  CC      drivers/acpi/proc.o
  CC      drivers/pci/quirks.o
  CC      arch/x86/kernel/cpu/hypervisor.o
  CC      drivers/tty/tty_io.o
  CC      kernel/trace/trace_printk.o
  CC      crypto/ecb.o
  HOSTCC  drivers/tty/vt/conmakehash
  CC      io_uring/memmap.o
  CC      net/ipv6/netfilter/ip6t_REJECT.o
  CC      fs/ext4/mballoc.o
  CC      net/ipv6/addrlabel.o
  CC      lib/decompress_unlzo.o
  CC      net/netfilter/nf_conntrack_netlink.o
  CC      drivers/iommu/iommu-traces.o
  CC      sound/hda/hdac_i915.o
  AR      drivers/virtio/built-in.a
  CC      block/mq-deadline.o
  CC      drivers/tty/n_tty.o
  CC      net/wireless/scan.o
  CC      kernel/cgroup/rdma.o
  CC      fs/9p/vfs_file.o
  CC      drivers/tty/vt/defkeymap.o
  CC      arch/x86/kernel/cpu/mshyperv.o
  CC      fs/lockd/clnt4xdr.o
  CC      drivers/acpi/acpica/exoparg3.o
  CONMK   drivers/tty/vt/consolemap_deftbl.c
  CC      block/kyber-iosched.o
  AR      drivers/char/agp/built-in.a
  CC      kernel/time/clockevents.o
  CC      drivers/tty/vt/consolemap_deftbl.o
  AR      drivers/tty/vt/built-in.a
  CC      crypto/cbc.o
  CC      net/core/dev_ioctl.o
  CC      drivers/tty/serial/8250/8250_dma.o
  CC      fs/autofs/symlink.o
  CC      net/ethtool/tsinfo.o
  CC      net/ipv4/tcp_timer.o
  CC      net/sunrpc/socklib.o
  CC      lib/decompress_unxz.o
  CC      lib/decompress_unzstd.o
  CC      lib/dump_stack.o
  CC      drivers/acpi/acpica/exoparg6.o
  CC      kernel/events/uprobes.o
  CC      drivers/char/nvram.o
  CC      sound/hda/intel-dsp-config.o
  CC      fs/nfs/symlink.o
  AR      fs/hostfs/built-in.a
  CC      mm/compaction.o
  CC      io_uring/alloc_cache.o
  CC      kernel/trace/pid_list.o
  CC      kernel/cgroup/cpuset.o
  CC      crypto/ctr.o
  CC      fs/9p/vfs_dir.o
  CC      drivers/pci/pci-label.o
  CC      kernel/time/tick-common.o
  CC      drivers/acpi/bus.o
  CC      drivers/acpi/acpica/exprep.o
  CC      net/ipv6/route.o
  CC      drivers/iommu/iommu-sysfs.o
  CC      arch/x86/kernel/cpu/debugfs.o
  CC      net/sunrpc/xprtsock.o
  CC      fs/autofs/waitq.o
  CC      fs/9p/vfs_dentry.o
  AR      net/ipv6/netfilter/built-in.a
  CC      drivers/acpi/acpica/exregion.o
  CC      drivers/acpi/acpica/exresnte.o
  CC      drivers/acpi/glue.o
  CC      drivers/tty/serial/8250/8250_dwlib.o
  CC      lib/earlycpio.o
  CC      net/mac80211/status.o
  CC      net/sunrpc/auth_gss/gss_rpc_upcall.o
  CC      fs/lockd/xdr4.o
  CC      crypto/gcm.o
  CC      lib/extable.o
  CC      fs/ext4/migrate.o
  CC      kernel/cgroup/misc.o
  CC      io_uring/io-wq.o
  CC      sound/hda/intel-nhlt.o
  AR      drivers/char/built-in.a
  CC      fs/9p/v9fs.o
  CC      net/core/tso.o
  CC      drivers/acpi/scan.o
  CC      drivers/acpi/acpica/exresolv.o
  CC      drivers/tty/serial/8250/8250_pcilib.o
  CC      kernel/trace/trace_sched_switch.o
  CC      fs/nfs/unlink.o
  CC      drivers/iommu/dma-iommu.o
  CC      net/ipv6/ip6_fib.o
  CC      lib/flex_proportions.o
  CC      arch/x86/kernel/cpu/bus_lock.o
  CC      net/ethtool/cabletest.o
  CC      block/blk-mq-debugfs.o
  CC      sound/sound_core.o
  CC      crypto/ccm.o
  CC      net/wireless/nl80211.o
  CC      lib/idr.o
  CC      mm/show_mem.o
  CC      net/ipv4/tcp_ipv4.o
  CC      drivers/acpi/acpica/exresop.o
  CC      drivers/pci/vgaarb.o
  CC      kernel/time/tick-broadcast.o
  CC      fs/autofs/expire.o
  CC      sound/hda/intel-sdw-acpi.o
  CC      fs/autofs/dev-ioctl.o
  CC      kernel/cpu.o
  CC      drivers/acpi/mipi-disco-img.o
  CC      fs/debugfs/inode.o
  CC      fs/9p/fid.o
  CC      net/netfilter/nf_conntrack_ftp.o
  CC      drivers/tty/serial/8250/8250_early.o
  AR      net/xfrm/built-in.a
  CC      net/ethtool/tunnels.o
  CC      kernel/trace/trace_nop.o
  CC      drivers/acpi/acpica/exserial.o
  CC      kernel/cgroup/debug.o
  CC      fs/lockd/svc4proc.o
  CC      lib/iomem_copy.o
  CC      io_uring/futex.o
  CC      net/sunrpc/auth_gss/gss_rpc_xdr.o
  CC      arch/x86/kernel/traps.o
  AR      kernel/events/built-in.a
  CC      net/sunrpc/sched.o
  CC      drivers/tty/serial/serial_ctrl.o
  AR      sound/hda/built-in.a
  CC      sound/last.o
  CC      lib/irq_regs.o
  CC      arch/x86/kernel/cpu/capflags.o
  AR      drivers/gpu/host1x/built-in.a
  AR      arch/x86/kernel/cpu/built-in.a
  CC      io_uring/napi.o
  CC      drivers/acpi/resource.o
  CC      kernel/time/tick-broadcast-hrtimer.o
  CC      drivers/acpi/acpica/exstore.o
  CC      block/blk-pm.o
  CC      lib/is_single_threaded.o
  CC      crypto/aes_generic.o
  AR      drivers/gpu/drm/tests/built-in.a
  CC      fs/nfs/write.o
  CC      net/wireless/mlme.o
  AR      drivers/gpu/drm/arm/built-in.a
  CC      fs/9p/xattr.o
  CC      kernel/exit.o
  AR      drivers/gpu/drm/clients/built-in.a
  CC      drivers/gpu/drm/display/drm_display_helper_mod.o
  CC      crypto/authenc.o
  CC      drivers/tty/serial/8250/8250_exar.o
  CC      kernel/softirq.o
  CC      net/wireless/ibss.o
  AR      fs/autofs/built-in.a
  CC      net/ipv4/tcp_minisocks.o
  CC      lib/klist.o
  CC      fs/nfs/namespace.o
  AR      sound/built-in.a
  CC      net/netfilter/nf_conntrack_irc.o
  CC      crypto/authencesn.o
  CC      net/sunrpc/auth.o
  CC      kernel/trace/blktrace.o
  CC      drivers/tty/serial/8250/8250_lpss.o
  AR      drivers/pci/built-in.a
  CC      fs/lockd/procfs.o
  CC      fs/nfs/mount_clnt.o
  CC      drivers/iommu/iova.o
  CC      fs/debugfs/file.o
  CC      drivers/acpi/acpica/exstoren.o
  CC      kernel/time/tick-oneshot.o
  AR      kernel/cgroup/built-in.a
  CC      drivers/acpi/acpica/exstorob.o
  CC      drivers/gpu/drm/ttm/ttm_tt.o
  CC      drivers/gpu/drm/display/drm_dp_dual_mode_helper.o
  CC      lib/kobject.o
  CC      mm/interval_tree.o
  CC      drivers/gpu/drm/display/drm_dp_helper.o
  CC      drivers/gpu/drm/i915/i915_config.o
  CC      block/holder.o
  AR      drivers/gpu/drm/renesas/rcar-du/built-in.a
  AR      drivers/gpu/drm/renesas/rz-du/built-in.a
  AR      drivers/gpu/drm/renesas/built-in.a
  AR      drivers/gpu/drm/omapdrm/built-in.a
  CC      drivers/tty/serial/8250/8250_mid.o
  CC      net/mac80211/driver-ops.o
  CC      net/ethtool/fec.o
  AR      fs/9p/built-in.a
  CC      arch/x86/kernel/idt.o
  CC      kernel/resource.o
  CC      kernel/time/tick-sched.o
  CC      drivers/acpi/acpica/exsystem.o
  CC      drivers/gpu/drm/ttm/ttm_bo.o
  CC      net/netfilter/nf_conntrack_sip.o
  CC      net/ipv4/tcp_cong.o
  CC      fs/nfs/nfstrace.o
  CC      net/sunrpc/auth_gss/trace.o
  CC      drivers/gpu/drm/i915/i915_driver.o
  CC      lib/kobject_uevent.o
  CC      drivers/tty/serial/serial_port.o
  AR      fs/lockd/built-in.a
  CC      kernel/time/timer_migration.o
  AR      drivers/gpu/drm/tilcdc/built-in.a
  CC      drivers/gpu/drm/ttm/ttm_bo_util.o
  CC      drivers/tty/tty_ioctl.o
  CC      fs/ext4/mmp.o
  CC      fs/nfs/export.o
  CC      drivers/acpi/acpica/extrace.o
  AR      drivers/iommu/built-in.a
  CC      crypto/lzo.o
  CC      kernel/time/vsyscall.o
  CC      fs/ext4/move_extent.o
  AR      block/built-in.a
  CC      fs/nfs/sysfs.o
  CC      drivers/acpi/acpica/exutils.o
  CC      net/ipv6/ipv6_sockglue.o
  CC      drivers/gpu/drm/i915/i915_drm_client.o
  AR      drivers/gpu/vga/built-in.a
  CC      fs/nfs/fs_context.o
  CC      drivers/gpu/drm/i915/i915_getparam.o
  AR      io_uring/built-in.a
  CC      fs/ext4/namei.o
  CC      mm/list_lru.o
  CC      net/netlabel/netlabel_user.o
  CC      mm/workingset.o
  CC      drivers/connector/cn_queue.o
  AR      fs/debugfs/built-in.a
  CC      drivers/tty/serial/8250/8250_pci.o
  CC      drivers/base/power/sysfs.o
  CC      arch/x86/kernel/irq.o
  CC      arch/x86/kernel/irq_32.o
  CC      drivers/base/power/generic_ops.o
  CC      drivers/acpi/acpica/hwacpi.o
  CC      drivers/tty/serial/8250/8250_pericom.o
  CC      drivers/tty/tty_ldisc.o
  CC      net/ethtool/eeprom.o
  CC      net/ethtool/stats.o
  CC      kernel/trace/trace_events.o
  CC      crypto/lzo-rle.o
  CC      crypto/rng.o
  CC      drivers/acpi/acpica/hwesleep.o
  CC      net/sunrpc/auth_gss/gss_krb5_mech.o
  CC      net/core/sock_reuseport.o
  CC      drivers/gpu/drm/ttm/ttm_bo_vm.o
  CC      drivers/base/firmware_loader/builtin/main.o
  CC      lib/logic_pio.o
  CC      lib/maple_tree.o
  CC      net/rfkill/core.o
  CC      drivers/gpu/drm/i915/i915_ioctl.o
  CC      drivers/base/power/common.o
  CC      net/sunrpc/auth_null.o
  CC      drivers/connector/connector.o
  CC      net/rfkill/input.o
  CC      drivers/base/regmap/regmap.o
  CC      drivers/acpi/acpica/hwgpe.o
  CC      mm/debug.o
  CC      drivers/acpi/acpi_processor.o
  CC      net/ipv4/tcp_metrics.o
  CC      net/netfilter/nf_nat_core.o
  AR      drivers/base/firmware_loader/builtin/built-in.a
  AR      drivers/base/test/built-in.a
  CC      drivers/base/regmap/regcache.o
  CC      drivers/base/firmware_loader/main.o
  CC      drivers/base/regmap/regcache-rbtree.o
  CC      net/netlabel/netlabel_kapi.o
  CC      drivers/base/regmap/regcache-flat.o
  CC      drivers/gpu/drm/ttm/ttm_module.o
  CC      drivers/base/power/qos.o
  CC      drivers/block/loop.o
  CC      drivers/misc/eeprom/eeprom_93cx6.o
  CC      drivers/block/virtio_blk.o
  CC      net/ipv6/ndisc.o
  CC      drivers/gpu/drm/display/drm_dp_mst_topology.o
  CC      drivers/base/regmap/regcache-maple.o
  CC      drivers/acpi/acpica/hwregs.o
  CC      crypto/drbg.o
  CC      net/netfilter/nf_nat_proto.o
  CC      arch/x86/kernel/dumpstack_32.o
  CC      kernel/sysctl.o
  CC      drivers/tty/serial/earlycon.o
  CC      kernel/time/timekeeping_debug.o
  CC      drivers/connector/cn_proc.o
  CC      kernel/trace/trace_export.o
  CC      drivers/acpi/acpica/hwsleep.o
  AR      drivers/misc/eeprom/built-in.a
  CC      fs/ext4/page-io.o
  AR      drivers/misc/cb710/built-in.a
  AR      drivers/misc/lis3lv02d/built-in.a
  AR      drivers/misc/cardreader/built-in.a
  AR      drivers/misc/keba/built-in.a
  AR      drivers/misc/built-in.a
  CC      drivers/gpu/drm/ttm/ttm_execbuf_util.o
  CC      net/mac80211/sta_info.o
  CC      drivers/gpu/drm/display/drm_dsc_helper.o
  CC      drivers/gpu/drm/virtio/virtgpu_drv.o
  AR      drivers/tty/serial/8250/built-in.a
  CC      lib/memcat_p.o
  AR      net/rfkill/built-in.a
  CC      drivers/base/power/runtime.o
  CC      net/ethtool/phc_vclocks.o
  CC      net/sunrpc/auth_gss/gss_krb5_seal.o
  CC      mm/gup.o
  CC      drivers/acpi/acpica/hwvalid.o
  CC      drivers/gpu/drm/i915/i915_irq.o
  CC      net/ipv6/udp.o
  CC      fs/ext4/readpage.o
  CC      net/netfilter/nf_nat_helper.o
  CC      net/sunrpc/auth_tls.o
  CC      drivers/base/component.o
  CC      net/core/fib_notifier.o
  CC      drivers/base/core.o
  CC      drivers/gpu/drm/virtio/virtgpu_kms.o
  CC      kernel/time/namespace.o
  CC      fs/nfs/nfsroot.o
  CC      fs/ext4/resize.o
  CC      drivers/base/bus.o
  CC      arch/x86/kernel/time.o
  AR      drivers/base/firmware_loader/built-in.a
  CC      net/ethtool/mm.o
  CC      drivers/base/power/wakeirq.o
  AR      drivers/tty/serial/built-in.a
  CC      drivers/tty/tty_buffer.o
  CC      drivers/tty/tty_port.o
  CC      drivers/acpi/acpica/hwxface.o
  CC      net/sunrpc/auth_unix.o
  CC      drivers/acpi/processor_core.o
  CC      crypto/jitterentropy.o
  CC      crypto/jitterentropy-kcapi.o
  CC      fs/tracefs/inode.o
  CC      net/netlabel/netlabel_domainhash.o
  CC      drivers/gpu/drm/ttm/ttm_range_manager.o
  CC [M]  fs/efivarfs/inode.o
  CC      arch/x86/kernel/ioport.o
  CC      drivers/gpu/drm/display/drm_hdcp_helper.o
  AR      drivers/connector/built-in.a
  CC      drivers/base/regmap/regmap-debugfs.o
  CC      drivers/acpi/acpica/hwxfsleep.o
  CC      net/ipv6/udplite.o
  CC      net/ipv4/tcp_fastopen.o
  CC      fs/nfs/sysctl.o
  CC      mm/mmap_lock.o
  CC      net/mac80211/wep.o
  CC      net/9p/mod.o
  AR      kernel/time/built-in.a
  AR      drivers/block/built-in.a
  CC      net/core/xdp.o
  CC      net/sunrpc/auth_gss/gss_krb5_unseal.o
  CC      net/9p/client.o
  CC      net/dns_resolver/dns_key.o
  CC      drivers/base/power/main.o
  CC      kernel/capability.o
  CC      drivers/gpu/drm/virtio/virtgpu_gem.o
  CC      net/ethtool/module.o
  CC      crypto/ghash-generic.o
  CC      kernel/trace/trace_event_perf.o
  CC      kernel/trace/trace_events_filter.o
  CC      net/ethtool/cmis_fw_update.o
  CC      drivers/tty/tty_mutex.o
  CC      kernel/ptrace.o
  CC      drivers/gpu/drm/ttm/ttm_resource.o
  CC      drivers/acpi/acpica/hwpci.o
  CC [M]  fs/efivarfs/file.o
  CC      fs/open.o
  CC      net/dns_resolver/dns_query.o
  CC      net/mac80211/aead_api.o
  CC      net/netlabel/netlabel_addrlist.o
  CC      drivers/base/dd.o
  CC      drivers/gpu/drm/i915/i915_mitigations.o
  CC      net/netfilter/nf_nat_masquerade.o
  CC      arch/x86/kernel/dumpstack.o
  CC      drivers/acpi/processor_pdc.o
  CC      crypto/hash_info.o
  CC      crypto/rsapubkey.asn1.o
  CC      fs/nfs/nfs3super.o
  CC      drivers/base/power/wakeup.o
  CC      crypto/rsaprivkey.asn1.o
  CC      fs/tracefs/event_inode.o
  AR      crypto/built-in.a
  CC      net/ipv4/tcp_rate.o
  CC      kernel/trace/trace_events_trigger.o
  CC      drivers/acpi/acpica/nsaccess.o
  AR      drivers/mfd/built-in.a
  CC      net/netfilter/nf_nat_ftp.o
  CC      drivers/base/syscore.o
  CC      drivers/tty/tty_ldsem.o
  CC      net/netlabel/netlabel_mgmt.o
  AR      drivers/base/regmap/built-in.a
  CC      arch/x86/kernel/nmi.o
  CC      net/ethtool/cmis_cdb.o
  CC [M]  fs/efivarfs/super.o
  CC      drivers/gpu/drm/virtio/virtgpu_vram.o
  CC      drivers/gpu/drm/virtio/virtgpu_display.o
  AR      drivers/nfc/built-in.a
  CC      drivers/acpi/ec.o
  AR      drivers/dax/hmem/built-in.a
  AR      drivers/dax/built-in.a
  CC      fs/read_write.o
  CC      drivers/acpi/acpica/nsalloc.o
  CC      net/9p/error.o
  CC      net/sunrpc/auth_gss/gss_krb5_wrap.o
  CC      net/ipv6/raw.o
  CC      drivers/gpu/drm/i915/i915_module.o
  CC      mm/highmem.o
  CC      fs/ext4/super.o
  AR      net/dns_resolver/built-in.a
  CC      drivers/tty/tty_baudrate.o
  CC      net/netfilter/nf_nat_irc.o
  CC      fs/nfs/nfs3client.o
  CC      drivers/gpu/drm/ttm/ttm_pool.o
  CC      drivers/gpu/drm/ttm/ttm_device.o
  CC      drivers/tty/tty_jobctrl.o
  CC      net/sunrpc/svc.o
  CC      net/netlabel/netlabel_unlabeled.o
  CC      drivers/acpi/dock.o
  CC [M]  fs/efivarfs/vars.o
  CC      drivers/acpi/acpica/nsarguments.o
  CC      mm/memory.o
  AR      drivers/gpu/drm/imx/built-in.a
  CC      drivers/base/power/wakeup_stats.o
  CC      net/sunrpc/auth_gss/gss_krb5_crypto.o
  CC      net/netlabel/netlabel_cipso_v4.o
  CC      net/core/flow_offload.o
  CC      fs/file_table.o
  CC      drivers/gpu/drm/display/drm_hdmi_helper.o
  CC      fs/nfs/nfs3proc.o
  AR      fs/tracefs/built-in.a
  CC      net/netfilter/nf_nat_sip.o
  CC      drivers/gpu/drm/ttm/ttm_sys_manager.o
  CC      net/sunrpc/auth_gss/gss_krb5_keys.o
  CC      drivers/gpu/drm/virtio/virtgpu_vq.o
  CC      fs/ext4/symlink.o
  CC      net/sunrpc/svcsock.o
  CC      drivers/gpu/drm/virtio/virtgpu_fence.o
  CC      net/ethtool/pse-pd.o
  CC      net/9p/protocol.o
  CC      drivers/acpi/acpica/nsconvert.o
  CC      fs/super.o
  CC      arch/x86/kernel/ldt.o
  CC      drivers/base/power/trace.o
  CC      kernel/trace/trace_eprobe.o
  CC      net/9p/trans_common.o
  CC      drivers/acpi/acpica/nsdump.o
  CC      drivers/gpu/drm/virtio/virtgpu_object.o
  CC      net/ipv6/icmp.o
  CC      net/ipv4/tcp_recovery.o
  CC      lib/nmi_backtrace.o
  CC      drivers/tty/n_null.o
  CC      drivers/acpi/acpica/nseval.o
  CC      fs/ext4/sysfs.o
  CC      net/mac80211/wpa.o
  CC      net/handshake/alert.o
  CC      drivers/gpu/drm/virtio/virtgpu_debugfs.o
  CC      drivers/gpu/drm/i915/i915_params.o
  CC      net/handshake/genl.o
  LD [M]  fs/efivarfs/efivarfs.o
  CC      drivers/tty/pty.o
  CC      drivers/acpi/pci_root.o
  CC      arch/x86/kernel/setup.o
  CC      net/core/gro.o
  CC      drivers/gpu/drm/ttm/ttm_agp_backend.o
  CC      drivers/gpu/drm/display/drm_scdc_helper.o
  CC      drivers/dma-buf/dma-buf.o
  AR      drivers/gpu/drm/i2c/built-in.a
  CC      drivers/dma-buf/dma-fence.o
  CC      net/sunrpc/svcauth.o
  CC      drivers/acpi/acpica/nsinit.o
  CC      mm/mincore.o
  CC      net/handshake/netlink.o
  CC      kernel/trace/trace_kprobe.o
  CC      net/wireless/sme.o
  CC      drivers/base/driver.o
  CC      mm/mlock.o
  CC      net/9p/trans_fd.o
  AR      drivers/base/power/built-in.a
  CC      drivers/gpu/drm/i915/i915_pci.o
  CC      net/ipv4/tcp_ulp.o
  CC      net/devres.o
  AR      drivers/gpu/drm/panel/built-in.a
  CC      fs/nfs/nfs3xdr.o
  CC      net/ipv6/mcast.o
  CC      kernel/user.o
  CC      net/netlabel/netlabel_calipso.o
  CC      drivers/acpi/pci_link.o
  CC      kernel/signal.o
  CC      net/ethtool/plca.o
  CC      drivers/acpi/acpica/nsload.o
  AR      net/sunrpc/auth_gss/built-in.a
  CC      kernel/sys.o
  CC      net/mac80211/scan.o
  CC      fs/char_dev.o
  AR      drivers/gpu/drm/ttm/built-in.a
  CC      kernel/umh.o
  CC      kernel/workqueue.o
  CC      drivers/gpu/drm/virtio/virtgpu_plane.o
  CC      drivers/dma-buf/dma-fence-array.o
  CC      drivers/tty/tty_audit.o
  CC      drivers/base/class.o
  CC      net/netfilter/x_tables.o
  CC      kernel/trace/error_report-traces.o
  CC      drivers/gpu/drm/i915/i915_scatterlist.o
  AR      drivers/gpu/drm/display/built-in.a
  CC      mm/mmap.o
  CC      net/sunrpc/svcauth_unix.o
  CC      net/wireless/chan.o
  CC      net/ethtool/phy.o
  CC      drivers/acpi/acpica/nsnames.o
  CC      fs/ext4/xattr.o
  CC      drivers/dma-buf/dma-fence-chain.o
  CC      arch/x86/kernel/x86_init.o
  CC      drivers/gpu/drm/virtio/virtgpu_ioctl.o
  CC      kernel/trace/power-traces.o
  CC      net/9p/trans_virtio.o
  CC      net/mac80211/offchannel.o
  AR      drivers/cxl/core/built-in.a
  AR      drivers/cxl/built-in.a
  CC      net/socket.o
  CC      lib/objpool.o
  CC      net/ethtool/tsconfig.o
  CC      drivers/acpi/acpica/nsobject.o
  CC      net/handshake/request.o
  CC      net/wireless/ethtool.o
  CC      fs/ext4/xattr_hurd.o
  CC      drivers/gpu/drm/virtio/virtgpu_prime.o
  CC      net/sunrpc/addr.o
  CC      kernel/trace/rpm-traces.o
  CC      drivers/tty/sysrq.o
  CC      mm/mmu_gather.o
  CC      drivers/dma-buf/dma-fence-unwrap.o
  CC      net/sysctl_net.o
  CC      drivers/gpu/drm/i915/i915_switcheroo.o
  CC      fs/ext4/xattr_trusted.o
  CC      lib/plist.o
  CC      drivers/base/platform.o
  CC      drivers/acpi/acpica/nsparse.o
  AR      net/netlabel/built-in.a
  CC      net/handshake/tlshd.o
  CC      net/ipv4/tcp_offload.o
  CC      drivers/gpu/drm/i915/i915_sysfs.o
  CC      drivers/gpu/drm/virtio/virtgpu_trace_points.o
  CC      net/core/netdev-genl.o
  CC      net/ipv6/reassembly.o
  CC      arch/x86/kernel/i8259.o
  CC      lib/radix-tree.o
  CC      net/ipv4/tcp_plb.o
  CC      mm/mprotect.o
  CC      kernel/pid.o
  CC      drivers/acpi/acpica/nspredef.o
  CC      drivers/dma-buf/dma-resv.o
  CC      lib/ratelimit.o
  CC      kernel/trace/trace_dynevent.o
  CC      drivers/base/cpu.o
  CC      fs/stat.o
  CC      net/wireless/mesh.o
  CC      drivers/gpu/drm/i915/i915_utils.o
  AR      drivers/gpu/drm/bridge/analogix/built-in.a
  AR      drivers/gpu/drm/bridge/cadence/built-in.a
  CC      net/core/netdev-genl-gen.o
  AR      drivers/gpu/drm/bridge/imx/built-in.a
  AR      drivers/gpu/drm/bridge/synopsys/built-in.a
  AR      drivers/gpu/drm/bridge/built-in.a
  CC      kernel/trace/trace_probe.o
  CC      arch/x86/kernel/irqinit.o
  CC      drivers/dma-buf/sync_file.o
  CC      drivers/acpi/acpica/nsprepkg.o
  AR      net/ethtool/built-in.a
  CC      net/ipv4/datagram.o
  AR      drivers/tty/built-in.a
  CC      lib/rbtree.o
  AR      net/9p/built-in.a
  CC      fs/ext4/xattr_user.o
  CC      fs/ext4/fast_commit.o
  CC      net/wireless/ap.o
  CC      drivers/gpu/drm/virtio/virtgpu_submit.o
  CC      fs/exec.o
  CC      fs/nfs/nfs3acl.o
  CC      net/handshake/trace.o
  AR      drivers/gpu/drm/hisilicon/built-in.a
  CC      kernel/trace/trace_uprobe.o
  CC      drivers/acpi/acpica/nsrepair.o
  CC      net/netfilter/xt_tcpudp.o
  CC      drivers/macintosh/mac_hid.o
  CC      net/ipv6/tcp_ipv6.o
  CC      drivers/acpi/pci_irq.o
  CC      fs/pipe.o
  CC      drivers/base/firmware.o
  CC      drivers/gpu/drm/i915/intel_clock_gating.o
  CC      lib/seq_buf.o
  CC      arch/x86/kernel/jump_label.o
  CC      fs/nfs/nfs4proc.o
  CC      net/netfilter/xt_CONNSECMARK.o
  CC      net/netfilter/xt_NFLOG.o
  AR      drivers/gpu/drm/mxsfb/built-in.a
  CC      net/core/gso.o
  CC      mm/mremap.o
  CC      net/sunrpc/rpcb_clnt.o
  CC      lib/siphash.o
  CC      drivers/acpi/acpica/nsrepair2.o
  AR      drivers/dma-buf/built-in.a
  CC      drivers/gpu/drm/i915/intel_cpu_info.o
  CC      arch/x86/kernel/irq_work.o
  CC      mm/msync.o
  CC      net/netfilter/xt_SECMARK.o
  CC      drivers/base/init.o
  CC      mm/page_vma_mapped.o
  CC      net/sunrpc/timer.o
  CC      drivers/acpi/acpi_apd.o
  CC      arch/x86/kernel/probe_roms.o
  CC      kernel/trace/rethook.o
  CC      fs/namei.o
  AR      drivers/macintosh/built-in.a
  CC      net/ipv6/ping.o
  CC      drivers/base/map.o
  CC      lib/string.o
  AR      drivers/scsi/pcmcia/built-in.a
  CC      drivers/scsi/scsi.o
  CC      mm/pagewalk.o
  AR      drivers/gpu/drm/tiny/built-in.a
  CC      mm/pgtable-generic.o
  CC      drivers/acpi/acpica/nssearch.o
  AR      drivers/gpu/drm/virtio/built-in.a
  CC      fs/nfs/nfs4xdr.o
  CC      fs/ext4/orphan.o
  CC      mm/rmap.o
  CC      net/mac80211/ht.o
  CC      drivers/scsi/hosts.o
  CC      net/wireless/trace.o
  CC      lib/timerqueue.o
  CC      lib/union_find.o
  CC      lib/vsprintf.o
  CC      drivers/acpi/acpi_platform.o
  CC      net/ipv4/raw.o
  CC      kernel/task_work.o
  CC      drivers/base/devres.o
  CC      net/ipv6/exthdrs.o
  CC      fs/ext4/acl.o
  CC      net/mac80211/agg-tx.o
  CC      drivers/acpi/acpica/nsutils.o
  CC      drivers/scsi/scsi_ioctl.o
  CC      mm/vmalloc.o
  CC      arch/x86/kernel/sys_ia32.o
  CC      net/sunrpc/xdr.o
  CC      net/core/net-sysfs.o
  AR      drivers/gpu/drm/xlnx/built-in.a
  CC      mm/vma.o
  CC      fs/nfs/nfs4state.o
  AR      drivers/gpu/drm/gud/built-in.a
  AR      drivers/gpu/drm/solomon/built-in.a
  CC      drivers/gpu/drm/i915/intel_device_info.o
  CC      drivers/acpi/acpi_pnp.o
  CC      drivers/gpu/drm/i915/intel_memory_region.o
  CC [M]  drivers/gpu/drm/scheduler/sched_main.o
  AR      net/handshake/built-in.a
  CC      fs/ext4/xattr_security.o
  CC      net/ipv4/udp.o
  CC      drivers/acpi/power.o
  CC      net/netfilter/xt_TCPMSS.o
  CC      drivers/scsi/scsicam.o
  CC      net/ipv6/datagram.o
  CC      fs/fcntl.o
  HOSTCC  drivers/gpu/drm/xe/xe_gen_wa_oob
  CC      drivers/base/attribute_container.o
  CC      drivers/acpi/acpica/nswalk.o
  CC      arch/x86/kernel/ksysfs.o
  CC      net/mac80211/agg-rx.o
  CC      drivers/gpu/drm/i915/intel_pcode.o
  GEN     xe_wa_oob.c xe_wa_oob.h
  CC [M]  drivers/gpu/drm/xe/xe_bb.o
  CC      drivers/scsi/scsi_error.o
  AR      drivers/nvme/common/built-in.a
  AR      drivers/nvme/host/built-in.a
  AR      kernel/trace/built-in.a
  AR      drivers/nvme/target/built-in.a
  CC      lib/win_minmax.o
  CC [M]  drivers/gpu/drm/scheduler/sched_fence.o
  CC      kernel/extable.o
  AR      drivers/nvme/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_bo.o
  CC      net/netfilter/xt_conntrack.o
  CC      drivers/gpu/drm/i915/intel_region_ttm.o
  CC      net/ipv6/ip6_flowlabel.o
  CC      net/ipv4/udplite.o
  CC      net/ipv4/udp_offload.o
  CC      drivers/acpi/acpica/nsxfeval.o
  CC      net/ipv4/arp.o
  CC      fs/nfs/nfs4renewd.o
  CC      kernel/params.o
  CC      drivers/base/transport_class.o
  CC [M]  drivers/gpu/drm/scheduler/sched_entity.o
  CC      net/mac80211/vht.o
  CC      net/sunrpc/sunrpc_syms.o
  CC      net/netfilter/xt_policy.o
  CC      arch/x86/kernel/bootflag.o
  CC      drivers/gpu/drm/i915/intel_runtime_pm.o
  CC      drivers/acpi/acpica/nsxfname.o
  CC      net/wireless/ocb.o
  CC      fs/ioctl.o
  CC      net/ipv6/inet6_connection_sock.o
  CC      kernel/kthread.o
  CC      drivers/base/topology.o
  CC      net/core/hotdata.o
  CC      net/ipv4/icmp.o
  CC      mm/process_vm_access.o
  CC      fs/nfs/nfs4super.o
  CC      drivers/gpu/drm/i915/intel_sbi.o
  CC      drivers/scsi/scsi_lib.o
  CC      drivers/gpu/drm/drm_atomic.o
  CC      lib/xarray.o
  CC      drivers/acpi/acpica/nsxfobj.o
  CC      drivers/gpu/drm/i915/intel_step.o
  CC      net/sunrpc/cache.o
  LD [M]  drivers/gpu/drm/scheduler/gpu-sched.o
  CC      drivers/acpi/event.o
  CC      arch/x86/kernel/e820.o
  CC      drivers/base/container.o
  CC      fs/nfs/nfs4file.o
  CC      drivers/acpi/evged.o
  CC      drivers/scsi/constants.o
  CC      net/ipv6/udp_offload.o
  CC      drivers/ata/libata-core.o
  AR      drivers/net/phy/mediatek/built-in.a
  CC      drivers/acpi/acpica/psargs.o
  AR      drivers/net/phy/qcom/built-in.a
  CC      drivers/net/phy/realtek/realtek_main.o
  CC      drivers/net/phy/realtek/realtek_hwmon.o
  CC      drivers/acpi/acpica/psloop.o
  CC      lib/lockref.o
  CC      drivers/ata/libata-scsi.o
  CC      arch/x86/kernel/pci-dma.o
  CC [M]  drivers/gpu/drm/xe/xe_bo_evict.o
  CC      drivers/net/phy/mdio-boardinfo.o
  CC      net/netfilter/xt_state.o
  CC      drivers/base/property.o
  CC      drivers/base/cacheinfo.o
  CC [M]  drivers/gpu/drm/xe/xe_devcoredump.o
  CC      drivers/base/swnode.o
  CC      net/core/netdev_rx_queue.o
  CC      drivers/scsi/scsi_lib_dma.o
  CC      arch/x86/kernel/quirks.o
  CC      fs/nfs/delegation.o
  CC      drivers/gpu/drm/i915/intel_uncore.o
  CC      drivers/acpi/acpica/psobject.o
  CC      drivers/acpi/acpica/psopcode.o
  CC      drivers/ata/libata-eh.o
  CC      net/ipv6/seg6.o
  CC      drivers/scsi/scsi_scan.o
  CC      drivers/acpi/acpica/psopinfo.o
  CC      drivers/acpi/acpica/psparse.o
  CC      net/sunrpc/rpc_pipe.o
  CC      mm/page_alloc.o
  CC      net/core/net-procfs.o
  CC      net/sunrpc/sysfs.o
  AR      drivers/net/pse-pd/built-in.a
  CC      net/core/netpoll.o
  CC      kernel/sys_ni.o
  CC      drivers/base/auxiliary.o
  CC      drivers/gpu/drm/drm_atomic_uapi.o
  CC      drivers/acpi/acpica/psscope.o
  CC      fs/nfs/nfs4idmap.o
  CC      lib/bcd.o
  CC      mm/page_frag_cache.o
  CC      net/mac80211/he.o
  CC      lib/sort.o
  CC      drivers/gpu/drm/i915/intel_uncore_trace.o
  CC      net/ipv6/fib6_notifier.o
  CC [M]  net/netfilter/nf_log_syslog.o
  CC [M]  drivers/gpu/drm/xe/xe_device.o
  CC      fs/readdir.o
  CC      lib/parser.o
  CC      kernel/nsproxy.o
  CC      net/ipv4/devinet.o
  CC      drivers/gpu/drm/i915/intel_wakeref.o
  CC      mm/init-mm.o
  CC      drivers/acpi/acpica/pstree.o
  CC      drivers/net/phy/stubs.o
  CC      arch/x86/kernel/kdebugfs.o
  CC      drivers/gpu/drm/drm_auth.o
  CC      lib/debug_locks.o
  CC      drivers/ata/libata-transport.o
  CC      drivers/firewire/init_ohci1394_dma.o
  CC      mm/memblock.o
  CC [M]  drivers/gpu/drm/xe/xe_device_sysfs.o
  AR      drivers/net/phy/realtek/built-in.a
  CC      drivers/gpu/drm/i915/vlv_sideband.o
  CC      drivers/net/phy/mdio_devres.o
  CC      drivers/net/mdio/acpi_mdio.o
  CC      net/mac80211/s1g.o
  AR      fs/ext4/built-in.a
  CC      arch/x86/kernel/alternative.o
  CC      drivers/base/devtmpfs.o
  CC      mm/slub.o
  CC      net/sunrpc/svc_xprt.o
  CC      arch/x86/kernel/i8253.o
  CC      drivers/gpu/drm/drm_blend.o
  CC      lib/random32.o
  CC      drivers/acpi/acpica/psutils.o
  CC      drivers/gpu/drm/i915/vlv_suspend.o
  CC      drivers/ata/libata-trace.o
  CC      net/ipv6/rpl.o
  AR      drivers/net/pcs/built-in.a
  CC      net/core/fib_rules.o
  CC [M]  drivers/gpu/drm/xe/xe_dma_buf.o
  CC      drivers/net/phy/phy.o
  CC      fs/nfs/callback.o
  GEN     drivers/scsi/scsi_devinfo_tbl.c
  CC      drivers/scsi/scsi_devinfo.o
  CC      drivers/acpi/sysfs.o
  CC      lib/bust_spinlocks.o
  CC      net/mac80211/ibss.o
  CC      drivers/acpi/acpica/pswalk.o
  CC      net/ipv4/af_inet.o
  CC [M]  drivers/gpu/drm/xe/xe_drm_client.o
  AR      drivers/firewire/built-in.a
  CC      drivers/ata/libata-sata.o
  CC      fs/nfs/callback_xdr.o
  CC      drivers/acpi/property.o
  CC      net/sunrpc/xprtmultipath.o
  CC      kernel/notifier.o
  CC [M]  net/netfilter/xt_mark.o
  CC      drivers/gpu/drm/i915/soc/intel_dram.o
  CC      mm/madvise.o
  CC      drivers/net/mdio/fwnode_mdio.o
  CC      net/mac80211/iface.o
  CC      net/mac80211/link.o
  CC      net/ipv6/ioam6.o
  CC      drivers/base/module.o
  CC      drivers/gpu/drm/drm_bridge.o
  CC      drivers/acpi/acpica/psxface.o
  CC      lib/kasprintf.o
  AR      drivers/net/ethernet/3com/built-in.a
  CC      drivers/cdrom/cdrom.o
  CC      drivers/net/ethernet/8390/ne2k-pci.o
  AR      drivers/net/ethernet/adaptec/built-in.a
  AR      drivers/net/ethernet/agere/built-in.a
  CC      net/mac80211/rate.o
  CC      kernel/ksysfs.o
  CC [M]  drivers/gpu/drm/xe/xe_eu_stall.o
  CC      drivers/net/ethernet/8390/8390.o
  CC      drivers/base/auxiliary_sysfs.o
  CC      arch/x86/kernel/hw_breakpoint.o
  CC      drivers/scsi/scsi_sysctl.o
  CC      drivers/gpu/drm/i915/soc/intel_gmch.o
  CC      arch/x86/kernel/tsc.o
  CC      lib/bitmap.o
  CC      net/core/net-traces.o
  CC      net/ipv4/igmp.o
  CC      drivers/scsi/scsi_proc.o
  CC [M]  net/netfilter/xt_nat.o
  CC      drivers/acpi/acpica/rsaddr.o
  CC      fs/nfs/callback_proc.o
  AR      drivers/auxdisplay/built-in.a
  CC      net/sunrpc/stats.o
  AR      drivers/net/ethernet/alacritech/built-in.a
  CC      net/ipv4/fib_frontend.o
  CC      drivers/net/phy/phy-c45.o
  CC      drivers/base/devcoredump.o
  CC      drivers/ata/libata-sff.o
  CC      net/core/selftests.o
  CC      kernel/cred.o
  CC      drivers/scsi/scsi_debugfs.o
  AR      drivers/net/wireless/admtek/built-in.a
  CC      drivers/acpi/acpica/rscalc.o
  AR      drivers/net/wireless/ath/built-in.a
  AR      drivers/net/wireless/atmel/built-in.a
  AR      drivers/net/wireless/broadcom/built-in.a
  AR      drivers/net/mdio/built-in.a
  AR      drivers/net/wireless/intel/built-in.a
  AR      drivers/net/wireless/intersil/built-in.a
  CC      net/ipv4/fib_semantics.o
  AR      drivers/net/wireless/marvell/built-in.a
  AR      drivers/net/wireless/mediatek/built-in.a
  AR      drivers/net/ethernet/alteon/built-in.a
  AR      drivers/net/wireless/microchip/built-in.a
  CC      drivers/base/platform-msi.o
  AR      drivers/net/wireless/purelifi/built-in.a
  CC      fs/nfs/nfs4namespace.o
  AR      drivers/net/wireless/quantenna/built-in.a
  CC      kernel/reboot.o
  AR      drivers/net/wireless/ralink/built-in.a
  CC      drivers/net/phy/phy-core.o
  AR      drivers/net/wireless/realtek/built-in.a
  CC      drivers/gpu/drm/i915/soc/intel_pch.o
  CC      fs/nfs/nfs4getroot.o
  AR      drivers/net/wireless/rsi/built-in.a
  AR      drivers/net/wireless/silabs/built-in.a
  AR      drivers/net/wireless/st/built-in.a
  AR      drivers/net/wireless/ti/built-in.a
  CC      fs/nfs/nfs4client.o
  AR      drivers/net/wireless/zydas/built-in.a
  AR      drivers/net/wireless/virtual/built-in.a
  AR      drivers/net/wireless/built-in.a
  CC      net/wireless/pmsr.o
  CC      lib/scatterlist.o
  CC      drivers/pcmcia/cs.o
  AR      drivers/net/ethernet/amazon/built-in.a
  CC      drivers/acpi/debugfs.o
  CC      lib/list_sort.o
  CC      net/core/ptp_classifier.o
  CC      drivers/gpu/drm/drm_cache.o
  CC      fs/nfs/nfs4session.o
  AR      drivers/net/ethernet/amd/built-in.a
  AR      drivers/net/ethernet/aquantia/built-in.a
  AR      drivers/net/ethernet/arc/built-in.a
  AR      drivers/net/ethernet/asix/built-in.a
  CC      net/mac80211/michael.o
  CC      net/sunrpc/sysctl.o
  CC      fs/select.o
  CC      drivers/acpi/acpica/rscreate.o
  CC      kernel/async.o
  CC [M]  net/netfilter/xt_LOG.o
  CC      arch/x86/kernel/tsc_msr.o
  CC      drivers/base/physical_location.o
  AR      drivers/net/ethernet/8390/built-in.a
  AR      drivers/net/ethernet/atheros/built-in.a
  AR      drivers/net/ethernet/cadence/built-in.a
  CC      drivers/net/ethernet/broadcom/bnx2.o
  CC      fs/dcache.o
  CC      drivers/scsi/scsi_trace.o
  CC      lib/uuid.o
  CC      drivers/base/trace.o
  CC      drivers/gpu/drm/drm_color_mgmt.o
  CC      net/core/netprio_cgroup.o
  CC      net/ipv6/sysctl_net_ipv6.o
  CC [M]  drivers/gpu/drm/xe/xe_exec.o
  CC      drivers/usb/common/common.o
  CC      drivers/acpi/acpica/rsdumpinfo.o
  CC      drivers/acpi/acpica/rsinfo.o
  CC      drivers/usb/common/debug.o
  CC      fs/nfs/dns_resolve.o
  CC      arch/x86/kernel/io_delay.o
  CC      arch/x86/kernel/rtc.o
  AR      drivers/net/ethernet/brocade/built-in.a
  CC      drivers/input/serio/serio.o
  AR      drivers/cdrom/built-in.a
  CC      kernel/range.o
  CC      net/mac80211/tkip.o
  CC      drivers/input/keyboard/atkbd.o
  CC      drivers/input/serio/i8042.o
  CC      drivers/pcmcia/socket_sysfs.o
  CC      drivers/pcmcia/cardbus.o
  CC      net/core/netclassid_cgroup.o
  CC      kernel/smpboot.o
  CC      arch/x86/kernel/resource.o
  CC      drivers/acpi/acpica/rsio.o
  CC      drivers/net/phy/phy_device.o
  GEN     net/wireless/shipped-certs.c
  AS      arch/x86/kernel/irqflags.o
  CC      drivers/gpu/drm/i915/soc/intel_rom.o
  CC      drivers/ata/libata-pmp.o
  CC      fs/inode.o
  CC [M]  net/netfilter/xt_MASQUERADE.o
  CC      mm/page_io.o
  CC      drivers/net/ethernet/broadcom/tg3.o
  CC      net/ipv6/xfrm6_policy.o
  CC      drivers/acpi/acpica/rsirq.o
  CC      net/ipv6/xfrm6_state.o
  CC      drivers/gpu/drm/drm_connector.o
  CC      net/ipv4/fib_trie.o
  CC      lib/iov_iter.o
  CC      drivers/scsi/scsi_logging.o
  AR      drivers/net/ethernet/cavium/common/built-in.a
  AR      drivers/net/ethernet/cavium/thunder/built-in.a
  AR      drivers/net/ethernet/cavium/liquidio/built-in.a
  AR      drivers/net/ethernet/cavium/octeon/built-in.a
  AR      drivers/net/ethernet/cavium/built-in.a
  CC      drivers/pcmcia/ds.o
  CC      net/wireless/shipped-certs.o
  AR      drivers/usb/common/built-in.a
  CC      mm/swap_state.o
  CC      drivers/net/phy/linkmode.o
  CC      drivers/gpu/drm/i915/i915_memcpy.o
  CC      drivers/usb/core/usb.o
  AR      drivers/base/built-in.a
  CC      drivers/acpi/acpica/rslist.o
  CC      net/core/dst_cache.o
  CC      arch/x86/kernel/static_call.o
  CC      drivers/acpi/acpi_lpat.o
  AR      net/sunrpc/built-in.a
  CC      drivers/ata/libata-acpi.o
  CC      drivers/net/phy/phy_link_topology.o
  CC      drivers/rtc/lib.o
  CC [M]  drivers/gpu/drm/xe/xe_exec_queue.o
  CC      drivers/i2c/algos/i2c-algo-bit.o
  CC      kernel/ucount.o
  CC [M]  drivers/gpu/drm/xe/xe_execlist.o
  CC      drivers/rtc/class.o
  CC      mm/swapfile.o
  CC      net/ipv4/fib_notifier.o
  CC      drivers/input/serio/serport.o
  CC      fs/attr.o
  CC      drivers/input/mouse/psmouse-base.o
  CC      fs/nfs/nfs4trace.o
  CC      drivers/acpi/acpica/rsmemory.o
  CC      drivers/usb/core/hub.o
  CC      kernel/regset.o
  CC      arch/x86/kernel/process.o
  CC      lib/clz_ctz.o
  AR      drivers/input/keyboard/built-in.a
  CC      drivers/rtc/interface.o
  AR      drivers/net/ethernet/chelsio/built-in.a
  CC      drivers/gpu/drm/i915/i915_mm.o
  CC [M]  net/netfilter/xt_addrtype.o
  CC      drivers/scsi/scsi_pm.o
  CC      drivers/usb/core/hcd.o
  CC      net/ipv6/xfrm6_input.o
  AR      drivers/input/joystick/built-in.a
  CC      drivers/usb/core/urb.o
  CC      mm/swap_slots.o
  CC      drivers/acpi/acpica/rsmisc.o
  AR      drivers/net/usb/built-in.a
  CC      net/core/gro_cells.o
  CC      drivers/usb/core/message.o
  CC      drivers/gpu/drm/i915/i915_sw_fence.o
  CC      drivers/input/serio/libps2.o
  CC      net/mac80211/aes_cmac.o
  CC      drivers/scsi/scsi_bsg.o
  AR      drivers/input/tablet/built-in.a
  CC      kernel/ksyms_common.o
  CC      fs/bad_inode.o
  CC      drivers/gpu/drm/i915/i915_sw_fence_work.o
  CC [M]  drivers/gpu/drm/xe/xe_force_wake.o
  CC      drivers/i2c/busses/i2c-i801.o
  CC      drivers/net/phy/mdio_bus.o
  CC      drivers/gpu/drm/i915/i915_syncmap.o
  CC      net/core/failover.o
  CC      drivers/pcmcia/pcmcia_resource.o
  CC      net/ipv4/inet_fragment.o
  AR      drivers/i2c/algos/built-in.a
  CC      mm/dmapool.o
  CC      drivers/scsi/scsi_common.o
  AR      drivers/net/ethernet/cisco/built-in.a
  CC      drivers/input/mouse/synaptics.o
  AR      drivers/i2c/muxes/built-in.a
  CC      drivers/usb/core/driver.o
  CC      drivers/ata/libata-pata-timings.o
  CC      drivers/i2c/i2c-boardinfo.o
  CC      drivers/i2c/i2c-core-base.o
  CC      net/ipv4/ping.o
  CC      lib/bsearch.o
  CC      drivers/acpi/acpica/rsserial.o
  CC      kernel/groups.o
  CC      mm/hugetlb.o
  AR      drivers/i3c/built-in.a
  CC      lib/find_bit.o
  AR      drivers/input/touchscreen/built-in.a
  CC      net/ipv6/xfrm6_output.o
  CC      drivers/gpu/drm/i915/i915_user_extensions.o
  CC      drivers/gpu/drm/i915/i915_debugfs.o
  CC      drivers/gpu/drm/drm_crtc.o
  CC      drivers/net/phy/mdio_device.o
  AR      drivers/input/serio/built-in.a
  CC      drivers/ata/ahci.o
  CC      drivers/usb/core/config.o
  CC      drivers/scsi/scsi_transport_spi.o
  CC      drivers/acpi/acpica/rsutils.o
  CC      net/ipv6/xfrm6_protocol.o
  CC      fs/nfs/nfs4sysctl.o
  AR      drivers/net/ethernet/cortina/built-in.a
  CC      net/ipv4/ip_tunnel_core.o
  AR      drivers/input/misc/built-in.a
  CC      fs/file.o
  CC      drivers/ata/libahci.o
  CC      drivers/i2c/i2c-core-smbus.o
  CC [M]  drivers/gpu/drm/xe/xe_ggtt.o
  AR      drivers/usb/phy/built-in.a
  CC      drivers/scsi/virtio_scsi.o
  CC      drivers/usb/mon/mon_main.o
  CC      kernel/kcmp.o
  CC      net/mac80211/aes_gmac.o
  AR      drivers/media/i2c/built-in.a
  AR      drivers/media/tuners/built-in.a
  AR      drivers/media/rc/keymaps/built-in.a
  AR      drivers/media/rc/built-in.a
  AR      drivers/media/common/b2c2/built-in.a
  AR      net/netfilter/built-in.a
  AR      drivers/media/common/saa7146/built-in.a
  CC      drivers/i2c/i2c-core-acpi.o
  CC      arch/x86/kernel/ptrace.o
  AR      drivers/media/common/siano/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_gpu_scheduler.o
  AR      drivers/media/common/v4l2-tpg/built-in.a
  AR      drivers/media/common/videobuf2/built-in.a
  AR      drivers/media/common/built-in.a
  CC      drivers/gpu/drm/drm_displayid.o
  AR      drivers/media/platform/allegro-dvt/built-in.a
  AR      drivers/media/pci/ttpci/built-in.a
  AR      drivers/media/pci/b2c2/built-in.a
  CC      mm/mmu_notifier.o
  AR      drivers/media/platform/amlogic/meson-ge2d/built-in.a
  AR      drivers/media/platform/amlogic/built-in.a
  AR      drivers/media/pci/pluto2/built-in.a
  CC      lib/llist.o
  CC      drivers/rtc/nvmem.o
  AR      drivers/media/platform/amphion/built-in.a
  AR      drivers/media/pci/dm1105/built-in.a
  AR      drivers/media/platform/aspeed/built-in.a
  CC      drivers/acpi/acpica/rsxface.o
  AR      drivers/media/pci/pt1/built-in.a
  AR      drivers/media/platform/atmel/built-in.a
  AR      drivers/media/pci/pt3/built-in.a
  CC      drivers/acpi/acpica/tbdata.o
  AR      drivers/media/platform/broadcom/built-in.a
  AR      drivers/media/pci/mantis/built-in.a
  CC      drivers/pcmcia/cistpl.o
  AR      drivers/media/platform/cadence/built-in.a
  AR      drivers/media/pci/ngene/built-in.a
  AR      drivers/media/pci/ddbridge/built-in.a
  AR      drivers/media/platform/chips-media/coda/built-in.a
  AR      drivers/media/pci/saa7146/built-in.a
  AR      drivers/i2c/busses/built-in.a
  AR      drivers/media/platform/chips-media/wave5/built-in.a
  AR      drivers/media/pci/smipcie/built-in.a
  AR      drivers/media/platform/chips-media/built-in.a
  CC      drivers/acpi/acpica/tbfadt.o
  AR      drivers/media/pci/netup_unidvb/built-in.a
  CC      lib/lwq.o
  AR      drivers/media/platform/imagination/built-in.a
  AR      drivers/media/platform/intel/built-in.a
  AR      drivers/media/pci/intel/ipu3/built-in.a
  AR      drivers/media/platform/marvell/built-in.a
  CC      drivers/usb/host/pci-quirks.o
  CC      drivers/usb/class/usblp.o
  AR      drivers/media/pci/intel/ivsc/built-in.a
  AR      drivers/media/pci/intel/built-in.a
  AR      drivers/media/platform/mediatek/jpeg/built-in.a
  AR      drivers/media/pci/built-in.a
  AR      drivers/media/platform/mediatek/mdp/built-in.a
  CC      drivers/usb/host/ehci-hcd.o
  AR      drivers/media/platform/mediatek/vcodec/common/built-in.a
  AR      drivers/media/platform/mediatek/vcodec/encoder/built-in.a
  AR      drivers/media/platform/mediatek/vcodec/decoder/built-in.a
  AR      drivers/media/platform/mediatek/vcodec/built-in.a
  AR      drivers/media/platform/mediatek/vpu/built-in.a
  CC      drivers/acpi/acpica/tbfind.o
  AR      drivers/media/platform/mediatek/mdp3/built-in.a
  CC      arch/x86/kernel/tls.o
  CC      drivers/acpi/acpica/tbinstal.o
  AR      drivers/media/platform/mediatek/built-in.a
  AR      net/core/built-in.a
  AR      drivers/media/platform/microchip/built-in.a
  CC      fs/filesystems.o
  AR      drivers/media/platform/nuvoton/built-in.a
  CC      lib/memweight.o
  AR      drivers/net/ethernet/dec/tulip/built-in.a
  AR      drivers/net/ethernet/dec/built-in.a
  AR      drivers/media/platform/nvidia/tegra-vde/built-in.a
  AR      drivers/media/platform/nvidia/built-in.a
  CC      drivers/net/phy/swphy.o
  CC      drivers/net/mii.o
  AR      drivers/media/platform/nxp/dw100/built-in.a
  CC      net/ipv6/netfilter.o
  CC      drivers/gpu/drm/i915/i915_debugfs_params.o
  AR      drivers/media/platform/nxp/imx-jpeg/built-in.a
  CC      drivers/input/mouse/focaltech.o
  AR      drivers/media/platform/nxp/imx8-isi/built-in.a
  AR      drivers/media/platform/nxp/built-in.a
  CC      drivers/net/phy/fixed_phy.o
  CC      lib/kfifo.o
  AR      drivers/media/platform/qcom/camss/built-in.a
  AR      drivers/media/platform/qcom/venus/built-in.a
  AR      drivers/media/platform/qcom/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_gsc.o
  CC      drivers/usb/mon/mon_stat.o
  AR      drivers/media/platform/raspberrypi/pisp_be/built-in.a
  AR      drivers/media/platform/raspberrypi/rp1-cfe/built-in.a
  AR      drivers/media/platform/raspberrypi/built-in.a
  AR      drivers/media/platform/renesas/rcar-vin/built-in.a
  AR      drivers/media/platform/renesas/rzg2l-cru/built-in.a
  CC      drivers/rtc/dev.o
  CC      drivers/rtc/proc.o
  AR      drivers/media/platform/renesas/vsp1/built-in.a
  CC      kernel/freezer.o
  AR      drivers/media/platform/renesas/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_gsc_debugfs.o
  AR      drivers/media/platform/rockchip/rga/built-in.a
  CC      drivers/i2c/i2c-smbus.o
  AR      drivers/media/platform/rockchip/rkisp1/built-in.a
  AR      drivers/media/platform/rockchip/built-in.a
  AR      drivers/media/platform/samsung/exynos-gsc/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_gsc_proxy.o
  CC [M]  drivers/gpu/drm/xe/xe_gsc_submit.o
  AR      drivers/media/platform/samsung/exynos4-is/built-in.a
  CC      fs/namespace.o
  CC      net/ipv4/gre_offload.o
  AR      drivers/net/ethernet/dlink/built-in.a
  AR      drivers/media/platform/samsung/s3c-camif/built-in.a
  AR      drivers/media/platform/samsung/s5p-g2d/built-in.a
  AR      drivers/media/platform/samsung/s5p-jpeg/built-in.a
  CC      fs/seq_file.o
  CC      drivers/input/input.o
  AR      drivers/media/platform/samsung/s5p-mfc/built-in.a
  CC      drivers/acpi/acpica/tbprint.o
  AR      drivers/media/platform/samsung/built-in.a
  CC      drivers/ata/ata_piix.o
  CC [M]  drivers/gpu/drm/xe/xe_gt.o
  AR      drivers/media/platform/st/sti/bdisp/built-in.a
  AR      drivers/media/platform/st/sti/c8sectpfe/built-in.a
  AR      drivers/media/platform/st/sti/delta/built-in.a
  CC      fs/xattr.o
  AR      drivers/media/platform/st/sti/hva/built-in.a
  AR      drivers/media/platform/st/stm32/built-in.a
  AR      drivers/media/platform/st/built-in.a
  CC      drivers/usb/core/file.o
  AR      drivers/media/platform/sunxi/sun4i-csi/built-in.a
  CC      net/mac80211/fils_aead.o
  AR      drivers/media/platform/sunxi/sun6i-csi/built-in.a
  AR      drivers/net/ethernet/emulex/built-in.a
  AR      drivers/media/platform/sunxi/sun6i-mipi-csi2/built-in.a
  AR      drivers/media/usb/b2c2/built-in.a
  AR      drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/built-in.a
  AR      drivers/media/platform/ti/am437x/built-in.a
  AR      drivers/media/usb/dvb-usb/built-in.a
  AR      drivers/media/platform/sunxi/sun8i-di/built-in.a
  AR      drivers/media/platform/ti/cal/built-in.a
  AR      drivers/media/mmc/siano/built-in.a
  AR      drivers/media/usb/dvb-usb-v2/built-in.a
  AR      drivers/media/platform/sunxi/sun8i-rotate/built-in.a
  AR      drivers/media/mmc/built-in.a
  AR      drivers/media/platform/sunxi/built-in.a
  AR      drivers/media/platform/ti/vpe/built-in.a
  AR      drivers/media/usb/s2255/built-in.a
  AR      drivers/media/usb/siano/built-in.a
  AR      drivers/media/platform/ti/davinci/built-in.a
  CC      net/ipv6/proc.o
  CC      drivers/acpi/acpi_pcc.o
  AR      drivers/media/usb/ttusb-budget/built-in.a
  AR      drivers/media/platform/ti/j721e-csi2rx/built-in.a
  AR      drivers/media/usb/ttusb-dec/built-in.a
  AR      drivers/media/platform/ti/omap/built-in.a
  CC      drivers/scsi/sd.o
  AR      drivers/media/usb/built-in.a
  AR      drivers/media/platform/ti/omap3isp/built-in.a
  AR      drivers/media/platform/ti/built-in.a
  CC      net/mac80211/cfg.o
  CC      drivers/gpu/drm/i915/i915_pmu.o
  AR      drivers/media/platform/verisilicon/built-in.a
  AR      drivers/media/platform/via/built-in.a
  AR      drivers/media/platform/xilinx/built-in.a
  CC      drivers/input/mouse/alps.o
  CC      drivers/usb/mon/mon_text.o
  AR      drivers/media/platform/built-in.a
  AR      drivers/usb/class/built-in.a
  CC      drivers/input/input-compat.o
  AR      drivers/media/firewire/built-in.a
  CC      lib/percpu-refcount.o
  AR      drivers/media/spi/built-in.a
  CC      drivers/acpi/acpica/tbutils.o
  CC      net/ipv4/metrics.o
  AR      drivers/media/test-drivers/built-in.a
  AR      drivers/media/built-in.a
  CC      drivers/acpi/ac.o
  CC      drivers/gpu/drm/drm_drv.o
  CC      arch/x86/kernel/step.o
  CC      drivers/scsi/sr.o
  CC      drivers/usb/host/ehci-pci.o
  AR      drivers/net/ethernet/engleder/built-in.a
  CC      drivers/usb/storage/scsiglue.o
  CC      drivers/rtc/sysfs.o
  CC      net/ipv4/netlink.o
  CC      fs/libfs.o
  AR      drivers/pps/clients/built-in.a
  CC      drivers/pps/pps.o
  AR      net/wireless/built-in.a
  CC      drivers/usb/core/buffer.o
  CC      drivers/acpi/acpica/tbxface.o
  CC      drivers/gpu/drm/drm_dumb_buffers.o
  AR      drivers/usb/misc/built-in.a
  CC      kernel/profile.o
  CC      net/ipv4/nexthop.o
  CC      net/ipv6/syncookies.o
  AR      drivers/i2c/built-in.a
  CC      net/ipv6/calipso.o
  CC      drivers/pcmcia/pcmcia_cis.o
  CC      net/ipv4/udp_tunnel_stub.o
  AR      drivers/net/phy/built-in.a
  CC      drivers/scsi/sr_ioctl.o
  AR      fs/nfs/built-in.a
  CC      drivers/acpi/acpica/tbxfload.o
  CC      drivers/pps/kapi.o
  CC      drivers/acpi/button.o
  CC      drivers/acpi/acpica/tbxfroot.o
  CC      drivers/input/mouse/byd.o
  CC      drivers/pcmcia/rsrc_mgr.o
  CC      drivers/usb/host/ohci-hcd.o
  CC      drivers/pcmcia/rsrc_nonstatic.o
  CC      drivers/pcmcia/yenta_socket.o
  CC      drivers/usb/mon/mon_bin.o
  CC      drivers/scsi/sr_vendor.o
  CC      drivers/ata/pata_amd.o
  CC      arch/x86/kernel/i8237.o
  CC      drivers/rtc/rtc-mc146818-lib.o
  CC      lib/rhashtable.o
  CC      net/ipv4/ip_tunnel.o
  CC      kernel/stacktrace.o
  CC      drivers/ptp/ptp_clock.o
  CC      drivers/acpi/acpica/utaddress.o
  CC      arch/x86/kernel/stacktrace.o
  CC      lib/base64.o
  AR      drivers/net/ethernet/ezchip/built-in.a
  CC      drivers/input/mouse/logips2pp.o
  CC      drivers/usb/core/sysfs.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_ccs_mode.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_clock.o
  CC      drivers/usb/storage/protocol.o
  CC      drivers/acpi/fan_core.o
  CC      drivers/usb/host/ohci-pci.o
  CC      fs/fs-writeback.o
  CC      drivers/pps/sysfs.o
  CC      drivers/usb/core/endpoint.o
  CC      drivers/power/supply/power_supply_core.o
  CC      drivers/rtc/rtc-cmos.o
  CC      kernel/dma.o
  CC      drivers/acpi/fan_attr.o
  CC      drivers/net/loopback.o
  AR      drivers/net/ethernet/fujitsu/built-in.a
  CC      drivers/usb/core/devio.o
  CC      drivers/input/input-mt.o
  CC      drivers/usb/host/uhci-hcd.o
  CC      drivers/acpi/acpica/utalloc.o
  CC      drivers/input/mouse/lifebook.o
  CC      drivers/gpu/drm/drm_edid.o
  CC      lib/once.o
  CC      drivers/gpu/drm/i915/gt/gen2_engine_cs.o
  CC      drivers/ata/pata_oldpiix.o
  AR      drivers/pps/built-in.a
  CC      drivers/hwmon/hwmon.o
  CC      arch/x86/kernel/reboot.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_freq.o
  CC      drivers/input/input-poller.o
  CC      mm/migrate.o
  CC      lib/refcount.o
  CC      lib/rcuref.o
  CC      drivers/acpi/fan_hwmon.o
  CC      drivers/acpi/acpi_video.o
  CC      drivers/net/netconsole.o
  CC      drivers/usb/early/ehci-dbgp.o
  CC      drivers/gpu/drm/drm_eld.o
  CC      drivers/usb/storage/transport.o
  CC      drivers/usb/storage/usb.o
  CC      drivers/ptp/ptp_chardev.o
  CC      drivers/acpi/acpica/utascii.o
  CC      kernel/smp.o
  CC      drivers/usb/core/notify.o
  CC      drivers/gpu/drm/drm_encoder.o
  CC      drivers/acpi/acpica/utbuffer.o
  CC      drivers/gpu/drm/i915/gt/gen6_engine_cs.o
  AR      drivers/usb/mon/built-in.a
  CC      net/ipv6/ah6.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_idle.o
  AR      drivers/thermal/broadcom/built-in.a
  CC      drivers/gpu/drm/drm_file.o
  AR      drivers/thermal/renesas/built-in.a
  AR      drivers/thermal/samsung/built-in.a
  CC      drivers/thermal/intel/intel_tcc.o
  CC      drivers/gpu/drm/i915/gt/gen6_ppgtt.o
  CC      net/mac80211/ethtool.o
  CC      arch/x86/kernel/msr.o
  CC      lib/usercopy.o
  CC      drivers/input/mouse/trackpoint.o
  AR      drivers/pcmcia/built-in.a
  CC      drivers/input/ff-core.o
  CC      drivers/ptp/ptp_sysfs.o
  CC      drivers/ata/pata_sch.o
  CC      drivers/power/supply/power_supply_sysfs.o
  CC      drivers/thermal/intel/therm_throt.o
  CC      drivers/net/virtio_net.o
  AR      drivers/watchdog/built-in.a
  CC      net/ipv4/sysctl_net_ipv4.o
  CC      drivers/acpi/acpica/utcksum.o
  CC      drivers/usb/host/xhci.o
  CC      arch/x86/kernel/cpuid.o
  AR      drivers/rtc/built-in.a
  AR      drivers/thermal/st/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_gt_mcr.o
  CC      drivers/input/mouse/cypress_ps2.o
  CC      lib/errseq.o
  CC      kernel/uid16.o
  CC      drivers/acpi/video_detect.o
  CC [M]  drivers/thermal/intel/x86_pkg_temp_thermal.o
  CC      net/ipv6/esp6.o
  CC      drivers/scsi/sg.o
  CC      lib/bucket_locks.o
  CC      net/ipv6/sit.o
  CC      drivers/md/md.o
  CC      drivers/usb/host/xhci-mem.o
  CC      drivers/acpi/acpica/utcopy.o
  AR      drivers/usb/early/built-in.a
  CC      net/mac80211/rx.o
  CC      drivers/power/supply/power_supply_leds.o
  CC      drivers/usb/storage/initializers.o
  CC      arch/x86/kernel/early-quirks.o
  CC      lib/generic-radix-tree.o
  CC      drivers/scsi/scsi_sysfs.o
  CC      drivers/acpi/processor_driver.o
  CC      drivers/usb/core/generic.o
  CC      drivers/cpufreq/cpufreq.o
  AR      drivers/net/ethernet/fungible/built-in.a
  CC      drivers/gpu/drm/i915/gt/gen7_renderclear.o
  AR      drivers/thermal/qcom/built-in.a
  CC      drivers/net/net_failover.o
  CC      drivers/usb/host/xhci-ext-caps.o
  CC      drivers/ata/pata_mpiix.o
  CC      drivers/acpi/processor_thermal.o
  AR      drivers/hwmon/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_gt_pagefault.o
  CC      fs/pnode.o
  CC      drivers/ptp/ptp_vclock.o
  CC      drivers/gpu/drm/drm_fourcc.o
  CC      drivers/input/mouse/psmouse-smbus.o
  AR      drivers/net/ethernet/google/built-in.a
  CC      drivers/acpi/acpica/utexcep.o
  CC      drivers/usb/core/quirks.o
  CC      drivers/ptp/ptp_kvm_x86.o
  CC      drivers/acpi/acpica/utdebug.o
  CC      drivers/usb/core/devices.o
  CC      lib/bitmap-str.o
  CC      drivers/power/supply/power_supply_hwmon.o
  CC      net/ipv4/proc.o
  AR      drivers/net/ethernet/hisilicon/built-in.a
  CC      drivers/usb/storage/sierra_ms.o
  CC      drivers/usb/core/phy.o
  CC      kernel/kallsyms.o
  AR      drivers/thermal/intel/built-in.a
  CC      drivers/ata/ata_generic.o
  CC      kernel/acct.o
  CC      mm/page_counter.o
  AR      drivers/thermal/tegra/built-in.a
  AR      drivers/net/ethernet/huawei/built-in.a
  AR      drivers/thermal/mediatek/built-in.a
  CC      drivers/acpi/acpica/utdecode.o
  CC      drivers/thermal/thermal_core.o
  CC      net/ipv4/fib_rules.o
  CC      net/ipv4/ipmr.o
  CC      net/mac80211/spectmgmt.o
  CC      net/ipv4/ipmr_base.o
  CC      fs/splice.o
  CC      mm/hugetlb_cgroup.o
  CC      drivers/md/md-bitmap.o
  CC      drivers/cpufreq/freq_table.o
  CC      drivers/input/touchscreen.o
  CC      arch/x86/kernel/smp.o
  CC      drivers/net/ethernet/intel/e1000/e1000_main.o
  AR      drivers/net/ethernet/i825xx/built-in.a
  CC      drivers/thermal/thermal_sysfs.o
  CC      drivers/net/ethernet/intel/e1000e/82571.o
  AR      drivers/power/supply/built-in.a
  AR      drivers/power/built-in.a
  CC      drivers/net/ethernet/intel/e100.o
  CC      drivers/net/ethernet/intel/e1000/e1000_hw.o
  CC      drivers/acpi/acpica/utdelete.o
  CC      drivers/net/ethernet/intel/e1000e/ich8lan.o
  CC      drivers/gpu/drm/drm_framebuffer.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_sysfs.o
  AR      drivers/net/ethernet/microsoft/built-in.a
  CC      drivers/input/ff-memless.o
  CC      lib/string_helpers.o
  CC      drivers/ptp/ptp_kvm_common.o
  AR      drivers/input/mouse/built-in.a
  CC      drivers/gpu/drm/i915/gt/gen8_engine_cs.o
  CC      drivers/thermal/thermal_trip.o
  CC      drivers/usb/storage/option_ms.o
  CC      drivers/md/md-autodetect.o
  CC      drivers/usb/core/port.o
  CC      drivers/acpi/processor_idle.o
  CC      drivers/thermal/thermal_helpers.o
  CC      drivers/acpi/processor_throttling.o
  CC      drivers/gpu/drm/i915/gt/gen8_ppgtt.o
  AR      drivers/ata/built-in.a
  AR      drivers/scsi/built-in.a
  CC      drivers/input/sparse-keymap.o
  CC      drivers/net/ethernet/intel/e1000/e1000_ethtool.o
  CC      drivers/usb/host/xhci-ring.o
  CC      drivers/acpi/acpica/uterror.o
  CC      drivers/usb/host/xhci-hub.o
  CC      mm/early_ioremap.o
  CC      kernel/vmcore_info.o
  CC      fs/sync.o
  CC      drivers/gpu/drm/i915/gt/intel_breadcrumbs.o
  CC      drivers/usb/storage/usual-tables.o
  CC      drivers/md/dm.o
  CC      net/ipv6/addrconf_core.o
  CC      drivers/cpufreq/cpufreq_performance.o
  CC      net/mac80211/tx.o
  CC      drivers/acpi/acpica/uteval.o
  CC      drivers/net/ethernet/intel/e1000e/80003es2lan.o
  CC      drivers/net/ethernet/intel/e1000/e1000_param.o
  AR      drivers/ptp/built-in.a
  CC      arch/x86/kernel/smpboot.o
  CC      drivers/usb/core/hcd-pci.o
  CC      drivers/acpi/processor_perflib.o
  CC      drivers/cpufreq/cpufreq_userspace.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_throttle.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_tlb_invalidation.o
  CC      mm/secretmem.o
  CC      lib/hexdump.o
  CC      kernel/elfcorehdr.o
  CC      drivers/input/vivaldi-fmap.o
  CC      drivers/acpi/container.o
  CC      drivers/gpu/drm/i915/gt/intel_context.o
  CC      drivers/thermal/thermal_thresholds.o
  CC      lib/kstrtox.o
  AR      drivers/net/ethernet/litex/built-in.a
  CC      net/mac80211/key.o
  AR      drivers/usb/storage/built-in.a
  CC      drivers/input/input-leds.o
  CC      drivers/acpi/acpica/utglobal.o
  CC      net/mac80211/util.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_topology.o
  CC      drivers/thermal/thermal_netlink.o
  CC      drivers/acpi/thermal_lib.o
  CC      drivers/thermal/thermal_hwmon.o
  CC      arch/x86/kernel/tsc_sync.o
  CC      drivers/input/evdev.o
  CC      drivers/usb/host/xhci-dbg.o
  CC      drivers/cpufreq/cpufreq_ondemand.o
  AR      drivers/net/ethernet/marvell/octeon_ep/built-in.a
  AR      drivers/net/ethernet/marvell/octeon_ep_vf/built-in.a
  AR      drivers/net/ethernet/marvell/octeontx2/built-in.a
  CC      fs/utimes.o
  AR      drivers/net/ethernet/marvell/prestera/built-in.a
  CC      drivers/net/ethernet/marvell/sky2.o
  CC      drivers/cpufreq/cpufreq_governor.o
  CC      drivers/thermal/gov_step_wise.o
  CC [M]  drivers/gpu/drm/xe/xe_guc.o
  CC      drivers/acpi/acpica/uthex.o
  CC      net/mac80211/parse.o
  CC      kernel/crash_reserve.o
  CC      drivers/usb/core/usb-acpi.o
  CC      lib/iomap.o
  CC      drivers/md/dm-table.o
  CC      drivers/gpu/drm/drm_gem.o
  CC      mm/hmm.o
  CC      net/ipv4/syncookies.o
  CC      net/mac80211/wme.o
  CC      drivers/net/ethernet/intel/e1000e/mac.o
  CC      net/ipv6/exthdrs_core.o
  CC      drivers/acpi/thermal.o
  CC      drivers/net/ethernet/intel/e1000e/manage.o
  CC      drivers/gpu/drm/drm_ioctl.o
  CC      lib/iomap_copy.o
  CC      drivers/acpi/acpica/utids.o
  CC      drivers/md/dm-target.o
  CC      drivers/usb/host/xhci-trace.o
  CC [M]  drivers/gpu/drm/xe/xe_guc_ads.o
  CC      drivers/cpufreq/cpufreq_governor_attr_set.o
  CC      drivers/net/ethernet/intel/e1000e/nvm.o
  AR      drivers/net/ethernet/broadcom/built-in.a
  CC      kernel/kexec_core.o
  CC      net/ipv6/ip6_checksum.o
  CC      net/ipv6/ip6_icmp.o
  CC      arch/x86/kernel/setup_percpu.o
  CC      drivers/acpi/acpica/utinit.o
  CC      drivers/cpufreq/acpi-cpufreq.o
  CC      net/mac80211/chan.o
  CC      drivers/md/dm-linear.o
  AR      drivers/net/ethernet/mellanox/built-in.a
  CC      drivers/net/ethernet/intel/e1000e/phy.o
  CC      arch/x86/kernel/mpparse.o
  CC      drivers/cpufreq/amd-pstate.o
  CC      drivers/gpu/drm/drm_lease.o
  CC      fs/d_path.o
  CC      net/mac80211/trace.o
  CC      mm/memfd.o
  AR      drivers/input/built-in.a
  CC      lib/devres.o
  AR      drivers/usb/core/built-in.a
  CC      drivers/usb/host/xhci-debugfs.o
  CC      drivers/usb/host/xhci-pci.o
  CC      drivers/gpu/drm/i915/gt/intel_context_sseu.o
  CC      arch/x86/kernel/trace_clock.o
  CC      drivers/acpi/nhlt.o
  CC      drivers/acpi/acpica/utlock.o
  AR      drivers/thermal/built-in.a
  CC      drivers/cpuidle/governors/menu.o
  CC      fs/stack.o
  CC      drivers/acpi/acpica/utmath.o
  CC      drivers/acpi/acpica/utmisc.o
  CC      net/ipv6/output_core.o
  CC      net/mac80211/mlme.o
  AR      drivers/net/ethernet/meta/built-in.a
  CC      kernel/crash_core.o
  CC      net/ipv4/tunnel4.o
  CC      lib/check_signature.o
  CC      drivers/net/ethernet/intel/e1000e/param.o
  CC      drivers/gpu/drm/i915/gt/intel_engine_cs.o
  CC      net/ipv6/protocol.o
  CC      net/ipv4/ipconfig.o
  CC      drivers/acpi/acpi_memhotplug.o
  CC      fs/fs_struct.o
  AR      drivers/net/ethernet/intel/e1000/built-in.a
  CC      kernel/kexec.o
  CC      lib/interval_tree.o
  AR      drivers/net/ethernet/micrel/built-in.a
  CC      drivers/cpuidle/governors/haltpoll.o
  CC      net/mac80211/tdls.o
  CC      net/ipv6/ip6_offload.o
  CC      drivers/gpu/drm/i915/gt/intel_engine_heartbeat.o
  CC      drivers/acpi/ioapic.o
  CC      drivers/acpi/acpica/utmutex.o
  CC      kernel/utsname.o
  AR      drivers/mmc/built-in.a
  CC      lib/assoc_array.o
  CC      net/ipv6/tcpv6_offload.o
  CC      drivers/gpu/drm/drm_managed.o
  CC      drivers/acpi/acpica/utnonansi.o
  CC      net/mac80211/ocb.o
  CC      fs/statfs.o
  CC      drivers/gpu/drm/drm_mm.o
  CC      drivers/cpuidle/cpuidle.o
  CC      drivers/net/ethernet/intel/e1000e/ethtool.o
  CC      net/ipv4/netfilter.o
  CC      arch/x86/kernel/trace.o
  CC      net/mac80211/airtime.o
  AR      drivers/net/ethernet/microchip/built-in.a
  CC      mm/ptdump.o
  CC      drivers/acpi/acpica/utobject.o
  CC      drivers/gpu/drm/i915/gt/intel_engine_pm.o
  CC      drivers/acpi/battery.o
  CC      drivers/acpi/acpica/utosi.o
  CC      drivers/cpufreq/amd-pstate-trace.o
  CC      kernel/pid_namespace.o
  CC      drivers/acpi/acpica/utownerid.o
  CC      drivers/gpu/drm/drm_mode_config.o
  CC      net/ipv6/exthdrs_offload.o
  CC      fs/fs_pin.o
  CC [M]  drivers/gpu/drm/xe/xe_guc_buf.o
  CC      net/mac80211/eht.o
  CC      mm/execmem.o
  CC      drivers/cpuidle/driver.o
  CC      arch/x86/kernel/rethook.o
  CC      lib/bitrev.o
  CC      net/ipv6/inet6_hashtables.o
  CC      lib/crc-ccitt.o
  CC      drivers/md/dm-stripe.o
  AR      drivers/ufs/built-in.a
  AR      drivers/firmware/arm_ffa/built-in.a
  CC      net/ipv4/tcp_cubic.o
  AR      drivers/firmware/arm_scmi/built-in.a
  CC      drivers/acpi/acpica/utpredef.o
  AR      drivers/crypto/stm32/built-in.a
  AR      drivers/net/ethernet/mscc/built-in.a
  AR      drivers/firmware/broadcom/built-in.a
  CC      net/ipv4/tcp_sigpool.o
  AR      drivers/crypto/xilinx/built-in.a
  AR      drivers/crypto/hisilicon/built-in.a
  AR      drivers/firmware/cirrus/test/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_guc_capture.o
  AR      drivers/firmware/meson/built-in.a
  AR      drivers/firmware/cirrus/built-in.a
  AR      drivers/crypto/intel/keembay/built-in.a
  CC      drivers/gpu/drm/i915/gt/intel_engine_user.o
  AR      drivers/firmware/microchip/built-in.a
  AR      drivers/crypto/intel/ixp4xx/built-in.a
  AR      drivers/crypto/intel/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_guc_ct.o
  CC      drivers/acpi/acpica/utresdecode.o
  AR      drivers/cpuidle/governors/built-in.a
  AR      drivers/crypto/starfive/built-in.a
  CC      drivers/cpuidle/governor.o
  AR      drivers/crypto/built-in.a
  CC      drivers/acpi/bgrt.o
  CC      drivers/firmware/efi/libstub/efi-stub-helper.o
  CC      drivers/cpufreq/intel_pstate.o
  CC      lib/crc16.o
  CC      fs/nsfs.o
  CC      arch/x86/kernel/vmcore_info_32.o
  AR      drivers/firmware/imx/built-in.a
  CC      drivers/acpi/acpica/utresrc.o
  CC      drivers/firmware/efi/efi-bgrt.o
  CC      drivers/net/ethernet/intel/e1000e/netdev.o
  AR      drivers/usb/host/built-in.a
  AR      drivers/usb/built-in.a
  CC      drivers/firmware/efi/libstub/gop.o
  CC      net/ipv4/cipso_ipv4.o
  CC      kernel/stop_machine.o
  CC      drivers/gpu/drm/drm_mode_object.o
  CC [M]  drivers/gpu/drm/xe/xe_guc_db_mgr.o
  CC      net/mac80211/led.o
  HOSTCC  lib/gen_crc32table
  CC      net/ipv6/mcast_snoop.o
  CC      drivers/md/dm-ioctl.o
  CC      drivers/cpuidle/sysfs.o
  CC      drivers/net/ethernet/intel/e1000e/ptp.o
  CC      drivers/gpu/drm/i915/gt/intel_execlists_submission.o
  AR      drivers/net/ethernet/myricom/built-in.a
  CC      drivers/md/dm-io.o
  AR      mm/built-in.a
  CC      arch/x86/kernel/machine_kexec_32.o
  CC      drivers/cpuidle/poll_state.o
  CC      lib/xxhash.o
  CC      fs/fs_types.o
  CC      drivers/firmware/efi/efi.o
  AR      drivers/net/ethernet/marvell/built-in.a
  CC      kernel/audit.o
  CC      fs/fs_context.o
  CC      drivers/cpuidle/cpuidle-haltpoll.o
  CC      drivers/firmware/efi/vars.o
  CC      drivers/acpi/acpica/utstate.o
  CC      drivers/gpu/drm/drm_modes.o
  CC      drivers/md/dm-kcopyd.o
  CC      drivers/firmware/efi/libstub/secureboot.o
  CC      fs/fs_parser.o
  CC      drivers/acpi/spcr.o
  CC      kernel/auditfilter.o
  CC      drivers/gpu/drm/i915/gt/intel_ggtt.o
  CC      drivers/clocksource/acpi_pm.o
  CC      drivers/hid/usbhid/hid-core.o
  CC      drivers/acpi/acpica/utstring.o
  CC      lib/genalloc.o
  CC      drivers/clocksource/i8253.o
  CC      drivers/acpi/acpica/utstrsuppt.o
  CC      net/ipv4/xfrm4_policy.o
  AR      drivers/cpuidle/built-in.a
  CC      drivers/gpu/drm/drm_modeset_lock.o
  CC      lib/percpu_counter.o
  CC      net/mac80211/pm.o
  CC      net/ipv4/xfrm4_state.o
  AR      drivers/net/ethernet/natsemi/built-in.a
  CC      net/mac80211/rc80211_minstrel_ht.o
  CC      drivers/hid/hid-core.o
  CC      drivers/gpu/drm/i915/gt/intel_ggtt_fencing.o
  CC      drivers/hid/hid-input.o
  CC      drivers/md/dm-sysfs.o
  CC      net/ipv4/xfrm4_input.o
  CC      drivers/firmware/efi/reboot.o
  AS      arch/x86/kernel/relocate_kernel_32.o
  CC      drivers/acpi/acpica/utstrtoul64.o
  CC      fs/fsopen.o
  CC      arch/x86/kernel/crash_dump_32.o
  CC      arch/x86/kernel/crash.o
  CC      drivers/firmware/efi/libstub/tpm.o
  CC      drivers/hid/usbhid/hiddev.o
  CC      drivers/firmware/efi/memattr.o
  CC      net/ipv4/xfrm4_output.o
  AR      drivers/net/ethernet/neterion/built-in.a
  CC      drivers/gpu/drm/drm_plane.o
  CC      drivers/md/dm-stats.o
  AR      net/ipv6/built-in.a
  CC      fs/init.o
  CC      kernel/auditsc.o
  CC      lib/audit.o
  CC      drivers/firmware/efi/libstub/file.o
  CC [M]  drivers/gpu/drm/xe/xe_guc_hwconfig.o
  CC      drivers/hid/usbhid/hid-pidff.o
  CC      drivers/gpu/drm/i915/gt/intel_gt.o
  CC      lib/syscall.o
  AR      drivers/clocksource/built-in.a
  CC      fs/kernel_read_file.o
  AR      drivers/firmware/psci/built-in.a
  CC      drivers/gpu/drm/i915/gt/intel_gt_buffer_pool.o
  CC      fs/mnt_idmapping.o
  CC      drivers/acpi/acpica/utxface.o
  CC      lib/errname.o
  CC      fs/remap_range.o
  CC      fs/pidfs.o
  CC      drivers/gpu/drm/drm_prime.o
  CC      drivers/firmware/efi/tpm.o
  CC      kernel/audit_watch.o
  AR      drivers/net/ethernet/netronome/built-in.a
  AR      drivers/platform/x86/amd/built-in.a
  AR      drivers/platform/x86/intel/built-in.a
  CC      drivers/platform/x86/wmi.o
  AR      drivers/platform/surface/built-in.a
  CC      drivers/firmware/efi/libstub/mem.o
  AR      drivers/firmware/qcom/built-in.a
  CC      drivers/gpu/drm/i915/gt/intel_gt_ccs_mode.o
  CC      drivers/firmware/efi/libstub/random.o
  CC      arch/x86/kernel/module.o
  CC      drivers/acpi/acpica/utxfinit.o
  CC      drivers/gpu/drm/drm_print.o
  CC      drivers/platform/x86/wmi-bmof.o
  CC      kernel/audit_fsnotify.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_clock_utils.o
  CC      arch/x86/kernel/doublefault_32.o
  CC [M]  drivers/gpu/drm/xe/xe_guc_id_mgr.o
  AR      drivers/cpufreq/built-in.a
  CC      kernel/audit_tree.o
  CC      drivers/md/dm-rq.o
  CC      drivers/firmware/efi/libstub/randomalloc.o
  CC      lib/nlattr.o
  CC      drivers/firmware/efi/memmap.o
  AR      drivers/net/ethernet/ni/built-in.a
  CC      drivers/gpu/drm/i915/gt/intel_gt_debugfs.o
  CC      drivers/hid/hid-quirks.o
  CC      kernel/kprobes.o
  CC      arch/x86/kernel/early_printk.o
  CC      drivers/platform/x86/eeepc-laptop.o
  CC      drivers/acpi/acpica/utxferror.o
  CC [M]  drivers/gpu/drm/xe/xe_guc_klv_helpers.o
  CC      drivers/firmware/efi/capsule.o
  CC      net/mac80211/wbrf.o
  AR      drivers/firmware/smccc/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_guc_log.o
  CC      drivers/platform/x86/p2sb.o
  CC      net/ipv4/xfrm4_protocol.o
  CC      drivers/net/ethernet/nvidia/forcedeth.o
  CC      drivers/hid/hid-debug.o
  CC      drivers/gpu/drm/drm_property.o
  CC      drivers/firmware/efi/esrt.o
  CC      drivers/hid/hidraw.o
  AR      drivers/net/ethernet/oki-semi/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_guc_pc.o
  CC      fs/buffer.o
  CC      drivers/firmware/efi/runtime-wrappers.o
  CC      arch/x86/kernel/hpet.o
  CC      lib/cpu_rmap.o
  AR      drivers/firmware/tegra/built-in.a
  CC      drivers/acpi/acpica/utxfmutex.o
  CC      drivers/gpu/drm/drm_rect.o
  CC      drivers/firmware/efi/capsule-loader.o
  CC      drivers/firmware/efi/libstub/pci.o
  CC      arch/x86/kernel/amd_nb.o
  AR      drivers/hid/usbhid/built-in.a
  CC      drivers/gpu/drm/i915/gt/intel_gt_engines_debugfs.o
  AR      drivers/firmware/xilinx/built-in.a
  AR      drivers/net/ethernet/packetengines/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_guc_submit.o
  CC      lib/dynamic_queue_limits.o
  CC      drivers/firmware/dmi_scan.o
  AR      drivers/net/ethernet/qlogic/built-in.a
  CC      drivers/firmware/dmi-id.o
  CC      drivers/md/dm-io-rewind.o
  AR      drivers/net/ethernet/qualcomm/emac/built-in.a
  AR      drivers/net/ethernet/qualcomm/built-in.a
  CC      drivers/md/dm-builtin.o
  CC      drivers/firmware/memmap.o
  CC      lib/glob.o
  CC      drivers/firmware/efi/libstub/skip_spaces.o
  CC      drivers/mailbox/mailbox.o
  CC      drivers/md/dm-raid1.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_irq.o
  CC      drivers/hid/hid-generic.o
  CC      drivers/mailbox/pcc.o
  CC      drivers/net/ethernet/realtek/8139too.o
  CC      drivers/md/dm-log.o
  AR      drivers/acpi/acpica/built-in.a
  CC      drivers/hid/hid-a4tech.o
  AR      drivers/acpi/built-in.a
  AR      drivers/perf/built-in.a
  CC      drivers/gpu/drm/drm_syncobj.o
  CC      drivers/net/ethernet/realtek/r8169_main.o
  CC [M]  drivers/gpu/drm/xe/xe_heci_gsc.o
  CC      drivers/firmware/efi/libstub/lib-cmdline.o
  CC [M]  drivers/gpu/drm/xe/xe_huc.o
  CC      drivers/hid/hid-apple.o
  CC      drivers/net/ethernet/realtek/r8169_firmware.o
  CC      drivers/firmware/efi/earlycon.o
  CC      arch/x86/kernel/amd_node.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_mcr.o
  CC      drivers/hid/hid-belkin.o
  CC      kernel/seccomp.o
  CC [M]  drivers/gpu/drm/xe/xe_hw_engine.o
  CC      drivers/gpu/drm/drm_sysfs.o
  CC      drivers/md/dm-region-hash.o
  CC      drivers/firmware/efi/libstub/lib-ctype.o
  AR      drivers/platform/x86/built-in.a
  AR      drivers/net/ethernet/renesas/built-in.a
  AR      drivers/platform/built-in.a
  AR      drivers/hwtracing/intel_th/built-in.a
  AR      drivers/android/built-in.a
  CC      arch/x86/kernel/kvm.o
  CC      drivers/firmware/efi/libstub/alignedmem.o
  CC [M]  drivers/gpu/drm/xe/xe_hw_engine_class_sysfs.o
  CC      lib/strncpy_from_user.o
  CC      lib/strnlen_user.o
  CC      fs/mpage.o
  CC      drivers/net/ethernet/realtek/r8169_phy_config.o
  CC      drivers/gpu/drm/drm_trace_points.o
  CC      drivers/md/dm-zero.o
  CC [M]  drivers/gpu/drm/xe/xe_hw_engine_group.o
  CC      lib/net_utils.o
  AR      net/ipv4/built-in.a
  CC      drivers/hid/hid-cherry.o
  AR      drivers/mailbox/built-in.a
  CC      fs/proc_namespace.o
  CC      kernel/relay.o
  AR      drivers/net/ethernet/rdc/built-in.a
  AR      drivers/net/ethernet/rocker/built-in.a
  AR      drivers/net/ethernet/samsung/built-in.a
  AR      drivers/net/ethernet/seeq/built-in.a
  AR      drivers/net/ethernet/silan/built-in.a
  CC      drivers/firmware/efi/libstub/relocate.o
  AR      drivers/net/ethernet/sis/built-in.a
  CC      arch/x86/kernel/kvmclock.o
  CC      lib/sg_pool.o
  CC      fs/direct-io.o
  CC      drivers/gpu/drm/drm_vblank.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_pm.o
  CC      kernel/utsname_sysctl.o
  CC      arch/x86/kernel/paravirt.o
  AR      drivers/nvmem/layouts/built-in.a
  CC      drivers/nvmem/core.o
  AR      drivers/net/ethernet/sfc/built-in.a
  CC      drivers/gpu/drm/drm_vblank_work.o
  CC      drivers/firmware/efi/libstub/printk.o
  CC      drivers/gpu/drm/drm_vma_manager.o
  CC      fs/eventpoll.o
  CC      fs/anon_inodes.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_pm_debugfs.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_pm_irq.o
  CC      kernel/delayacct.o
  AR      drivers/firmware/efi/built-in.a
  CC      fs/signalfd.o
  CC      arch/x86/kernel/pvclock.o
  CC      kernel/taskstats.o
  CC      kernel/tsacct.o
  CC      kernel/tracepoint.o
  CC      drivers/gpu/drm/drm_writeback.o
  AR      drivers/net/ethernet/smsc/built-in.a
  CC      drivers/gpu/drm/drm_panel.o
  AR      drivers/net/ethernet/socionext/built-in.a
  AR      drivers/net/ethernet/stmicro/built-in.a
  CC      drivers/firmware/efi/libstub/vsprintf.o
  CC      fs/timerfd.o
  CC      drivers/hid/hid-chicony.o
  AR      drivers/md/built-in.a
  CC      lib/stackdepot.o
  CC      arch/x86/kernel/pcspeaker.o
  AR      drivers/net/ethernet/sun/built-in.a
  CC      fs/eventfd.o
  CC      drivers/firmware/efi/libstub/x86-stub.o
  CC [M]  drivers/gpu/drm/xe/xe_hw_fence.o
  CC [M]  drivers/gpu/drm/xe/xe_irq.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_requests.o
  CC      fs/aio.o
  CC      kernel/irq_work.o
  CC      drivers/firmware/efi/libstub/smbios.o
  CC [M]  drivers/gpu/drm/xe/xe_lrc.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_sysfs.o
  CC [M]  drivers/gpu/drm/xe/xe_migrate.o
  AR      drivers/net/ethernet/tehuti/built-in.a
  CC      lib/asn1_decoder.o
  CC      arch/x86/kernel/check.o
  CC      fs/locks.o
  GEN     lib/oid_registry_data.c
  CC      arch/x86/kernel/uprobes.o
  CC      drivers/gpu/drm/i915/gt/intel_gt_sysfs_pm.o
  CC      drivers/gpu/drm/drm_pci.o
  AR      drivers/net/ethernet/intel/e1000e/built-in.a
  AR      drivers/net/ethernet/ti/built-in.a
  CC      fs/binfmt_misc.o
  AR      drivers/net/ethernet/intel/built-in.a
  CC      kernel/static_call.o
  CC [M]  drivers/gpu/drm/xe/xe_mmio.o
  CC      fs/binfmt_script.o
  STUBCPY drivers/firmware/efi/libstub/alignedmem.stub.o
  CC      lib/ucs2_string.o
  CC      arch/x86/kernel/perf_regs.o
  CC      lib/sbitmap.o
  CC      drivers/gpu/drm/drm_debugfs.o
  CC      kernel/padata.o
  CC      drivers/gpu/drm/i915/gt/intel_gtt.o
  CC      arch/x86/kernel/tracepoint.o
  CC      lib/group_cpus.o
  CC      drivers/hid/hid-cypress.o
  STUBCPY drivers/firmware/efi/libstub/efi-stub-helper.stub.o
  STUBCPY drivers/firmware/efi/libstub/file.stub.o
  CC [M]  drivers/gpu/drm/xe/xe_mocs.o
  STUBCPY drivers/firmware/efi/libstub/gop.stub.o
  CC      lib/fw_table.o
  CC      drivers/hid/hid-ezkey.o
  CC      arch/x86/kernel/itmt.o
  AR      drivers/net/ethernet/vertexcom/built-in.a
  CC      kernel/jump_label.o
  CC      fs/binfmt_elf.o
  STUBCPY drivers/firmware/efi/libstub/lib-cmdline.stub.o
  CC      kernel/context_tracking.o
  STUBCPY drivers/firmware/efi/libstub/lib-ctype.stub.o
  CC      arch/x86/kernel/umip.o
  CC      drivers/gpu/drm/drm_debugfs_crc.o
  CC      drivers/gpu/drm/i915/gt/intel_llc.o
  CC      arch/x86/kernel/unwind_frame.o
  AR      drivers/nvmem/built-in.a
  CC      drivers/gpu/drm/i915/gt/intel_lrc.o
  CC [M]  drivers/gpu/drm/xe/xe_module.o
  CC      drivers/gpu/drm/i915/gt/intel_migrate.o
  CC      kernel/iomem.o
  STUBCPY drivers/firmware/efi/libstub/mem.stub.o
  STUBCPY drivers/firmware/efi/libstub/pci.stub.o
  CC [M]  drivers/gpu/drm/xe/xe_oa.o
  STUBCPY drivers/firmware/efi/libstub/printk.stub.o
  AR      drivers/net/ethernet/via/built-in.a
  CC      drivers/gpu/drm/i915/gt/intel_mocs.o
  STUBCPY drivers/firmware/efi/libstub/random.stub.o
  AR      drivers/net/ethernet/wangxun/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_observation.o
  CC      kernel/rseq.o
  CC      drivers/hid/hid-gyration.o
  STUBCPY drivers/firmware/efi/libstub/randomalloc.stub.o
  STUBCPY drivers/firmware/efi/libstub/relocate.stub.o
  STUBCPY drivers/firmware/efi/libstub/secureboot.stub.o
  CC      drivers/hid/hid-ite.o
  AR      drivers/net/ethernet/wiznet/built-in.a
  STUBCPY drivers/firmware/efi/libstub/skip_spaces.stub.o
  CC      drivers/gpu/drm/drm_panel_orientation_quirks.o
  STUBCPY drivers/firmware/efi/libstub/smbios.stub.o
  AR      drivers/net/ethernet/xilinx/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_pat.o
  STUBCPY drivers/firmware/efi/libstub/tpm.stub.o
  STUBCPY drivers/firmware/efi/libstub/vsprintf.stub.o
  STUBCPY drivers/firmware/efi/libstub/x86-stub.stub.o
  AR      lib/lib.a
  AR      drivers/firmware/efi/libstub/lib.a
  AR      drivers/firmware/built-in.a
  AR      drivers/net/ethernet/xircom/built-in.a
  CC      drivers/gpu/drm/i915/gt/intel_ppgtt.o
  CC      fs/mbcache.o
  AR      drivers/net/ethernet/synopsys/built-in.a
  CC      drivers/hid/hid-kensington.o
  CC      drivers/gpu/drm/drm_buddy.o
  CC [M]  drivers/gpu/drm/xe/xe_pci.o
  GEN     lib/crc32table.h
  CC      fs/posix_acl.o
  CC      drivers/gpu/drm/drm_gem_shmem_helper.o
  CC      drivers/hid/hid-lg.o
  AR      drivers/net/ethernet/nvidia/built-in.a
  AR      drivers/net/ethernet/pensando/built-in.a
  CC      lib/oid_registry.o
  CC      drivers/hid/hid-lgff.o
  CC [M]  drivers/gpu/drm/xe/xe_pcode.o
  CC      drivers/gpu/drm/i915/gt/intel_rc6.o
  CC      lib/crc32.o
  CC      drivers/gpu/drm/drm_atomic_helper.o
  CC      fs/coredump.o
  CC [M]  drivers/gpu/drm/xe/xe_pm.o
  CC      fs/drop_caches.o
  CC      drivers/gpu/drm/i915/gt/intel_region_lmem.o
  CC      drivers/hid/hid-lg4ff.o
  CC      drivers/gpu/drm/drm_atomic_state_helper.o
  CC [M]  drivers/gpu/drm/xe/xe_preempt_fence.o
  CC      fs/sysctls.o
  CC [M]  drivers/gpu/drm/xe/xe_pt.o
  CC      drivers/gpu/drm/i915/gt/intel_renderstate.o
  CC      drivers/gpu/drm/drm_crtc_helper.o
  AR      arch/x86/kernel/built-in.a
  CC      drivers/gpu/drm/drm_damage_helper.o
  CC [M]  drivers/gpu/drm/xe/xe_pt_walk.o
  AR      arch/x86/built-in.a
  CC      drivers/hid/hid-lg-g15.o
  CC      drivers/gpu/drm/i915/gt/intel_reset.o
  CC      drivers/gpu/drm/drm_flip_work.o
  CC [M]  drivers/gpu/drm/xe/xe_pxp.o
  CC      drivers/hid/hid-microsoft.o
  CC      drivers/gpu/drm/i915/gt/intel_ring.o
  CC [M]  drivers/gpu/drm/xe/xe_pxp_debugfs.o
  AR      lib/built-in.a
  CC      fs/fhandle.o
  CC      drivers/gpu/drm/drm_format_helper.o
  CC      drivers/hid/hid-monterey.o
  CC [M]  drivers/gpu/drm/xe/xe_pxp_submit.o
  CC      drivers/gpu/drm/i915/gt/intel_ring_submission.o
  AR      kernel/built-in.a
  CC      drivers/gpu/drm/drm_gem_atomic_helper.o
  CC      drivers/hid/hid-ntrig.o
  CC [M]  drivers/gpu/drm/xe/xe_query.o
  CC      drivers/hid/hid-pl.o
  CC      drivers/hid/hid-petalynx.o
  AR      drivers/net/ethernet/realtek/built-in.a
  AR      net/mac80211/built-in.a
  AR      drivers/net/ethernet/built-in.a
  CC      drivers/gpu/drm/drm_gem_framebuffer_helper.o
  AR      net/built-in.a
  CC      drivers/hid/hid-redragon.o
  CC      drivers/gpu/drm/i915/gt/intel_rps.o
  AR      drivers/net/built-in.a
  CC      drivers/gpu/drm/drm_kms_helper_common.o
  CC [M]  drivers/gpu/drm/xe/xe_range_fence.o
  CC      drivers/hid/hid-samsung.o
  CC      drivers/gpu/drm/i915/gt/intel_sa_media.o
  CC [M]  drivers/gpu/drm/xe/xe_reg_sr.o
  CC      drivers/gpu/drm/drm_modeset_helper.o
  CC      drivers/gpu/drm/i915/gt/intel_sseu.o
  CC      drivers/hid/hid-sony.o
  CC [M]  drivers/gpu/drm/xe/xe_reg_whitelist.o
  CC      drivers/gpu/drm/drm_plane_helper.o
  CC      drivers/gpu/drm/i915/gt/intel_sseu_debugfs.o
  CC      drivers/gpu/drm/drm_probe_helper.o
  CC      drivers/hid/hid-sunplus.o
  CC      drivers/gpu/drm/drm_self_refresh_helper.o
  CC      drivers/gpu/drm/i915/gt/intel_timeline.o
  CC [M]  drivers/gpu/drm/xe/xe_ring_ops.o
  CC [M]  drivers/gpu/drm/xe/xe_rtp.o
  CC      drivers/gpu/drm/drm_simple_kms_helper.o
  CC      drivers/hid/hid-topseed.o
  CC      drivers/gpu/drm/i915/gt/intel_tlb.o
  CC [M]  drivers/gpu/drm/xe/xe_sa.o
  CC      drivers/gpu/drm/i915/gt/intel_wopcm.o
  CC      drivers/gpu/drm/i915/gt/intel_workarounds.o
  CC [M]  drivers/gpu/drm/xe/xe_sched_job.o
  CC      drivers/gpu/drm/bridge/panel.o
  CC      drivers/gpu/drm/i915/gt/shmem_utils.o
  CC      drivers/gpu/drm/drm_mipi_dsi.o
  CC [M]  drivers/gpu/drm/xe/xe_step.o
  CC      drivers/gpu/drm/i915/gt/sysfs_engines.o
  CC [M]  drivers/gpu/drm/drm_exec.o
  CC [M]  drivers/gpu/drm/xe/xe_survivability_mode.o
  CC [M]  drivers/gpu/drm/xe/xe_sync.o
  CC      drivers/gpu/drm/i915/gt/intel_ggtt_gmch.o
  CC [M]  drivers/gpu/drm/drm_gpuvm.o
  CC [M]  drivers/gpu/drm/xe/xe_tile.o
  CC      drivers/gpu/drm/i915/gt/gen6_renderstate.o
  CC [M]  drivers/gpu/drm/xe/xe_tile_sysfs.o
  CC [M]  drivers/gpu/drm/drm_suballoc.o
  AR      fs/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_trace.o
  CC      drivers/gpu/drm/i915/gt/gen7_renderstate.o
  CC [M]  drivers/gpu/drm/xe/xe_trace_bo.o
  CC [M]  drivers/gpu/drm/xe/xe_trace_guc.o
  CC      drivers/gpu/drm/i915/gt/gen8_renderstate.o
  CC [M]  drivers/gpu/drm/xe/xe_trace_lrc.o
  CC [M]  drivers/gpu/drm/drm_gem_ttm_helper.o
  CC      drivers/gpu/drm/i915/gt/gen9_renderstate.o
  CC [M]  drivers/gpu/drm/xe/xe_ttm_stolen_mgr.o
  CC [M]  drivers/gpu/drm/xe/xe_ttm_sys_mgr.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_busy.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_clflush.o
  CC [M]  drivers/gpu/drm/xe/xe_ttm_vram_mgr.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_context.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_create.o
  CC [M]  drivers/gpu/drm/xe/xe_tuning.o
  CC [M]  drivers/gpu/drm/xe/xe_uc.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_dmabuf.o
  CC [M]  drivers/gpu/drm/xe/xe_uc_fw.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_domain.o
  CC [M]  drivers/gpu/drm/xe/xe_vm.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_execbuffer.o
  CC [M]  drivers/gpu/drm/xe/xe_vram.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_internal.o
  CC [M]  drivers/gpu/drm/xe/xe_vram_freq.o
  CC [M]  drivers/gpu/drm/xe/xe_vsec.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_lmem.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_mman.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_object.o
  CC [M]  drivers/gpu/drm/xe/xe_wa.o
  LD [M]  drivers/gpu/drm/drm_suballoc_helper.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_pages.o
  CC [M]  drivers/gpu/drm/xe/xe_wait_user_fence.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_phys.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_pm.o
  CC [M]  drivers/gpu/drm/xe/xe_wopcm.o
  AR      drivers/hid/built-in.a
  CC [M]  drivers/gpu/drm/xe/xe_hmm.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_region.o
  CC [M]  drivers/gpu/drm/xe/xe_hwmon.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_shmem.o
  CC [M]  drivers/gpu/drm/xe/xe_pmu.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_sriov_vf.o
  CC [M]  drivers/gpu/drm/xe/xe_guc_relay.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_shrinker.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_stolen.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_throttle.o
  CC [M]  drivers/gpu/drm/xe/xe_memirq.o
  LD [M]  drivers/gpu/drm/drm_ttm_helper.o
  CC [M]  drivers/gpu/drm/xe/xe_sriov.o
  CC [M]  drivers/gpu/drm/xe/xe_sriov_vf.o
  CC [M]  drivers/gpu/drm/xe/display/ext/i915_irq.o
  CC [M]  drivers/gpu/drm/xe/display/ext/i915_utils.o
  CC [M]  drivers/gpu/drm/xe/display/intel_bo.o
  CC [M]  drivers/gpu/drm/xe/display/intel_fb_bo.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_tiling.o
  CC [M]  drivers/gpu/drm/xe/display/intel_fbdev_fb.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_ttm.o
  CC [M]  drivers/gpu/drm/xe/display/xe_display.o
  CC [M]  drivers/gpu/drm/xe/display/xe_display_misc.o
  CC [M]  drivers/gpu/drm/xe/display/xe_display_rps.o
  CC [M]  drivers/gpu/drm/xe/display/xe_display_wa.o
  CC [M]  drivers/gpu/drm/xe/display/xe_dsb_buffer.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_ttm_move.o
  CC [M]  drivers/gpu/drm/xe/display/xe_fb_pin.o
  CC [M]  drivers/gpu/drm/xe/display/xe_hdcp_gsc.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_ttm_pm.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_userptr.o
  CC [M]  drivers/gpu/drm/xe/display/xe_plane_initial.o
  CC      drivers/gpu/drm/i915/gem/i915_gem_wait.o
  CC [M]  drivers/gpu/drm/xe/display/xe_tdf.o
  CC [M]  drivers/gpu/drm/xe/i915-soc/intel_dram.o
  CC      drivers/gpu/drm/i915/gem/i915_gemfs.o
  CC [M]  drivers/gpu/drm/xe/i915-soc/intel_pch.o
  CC      drivers/gpu/drm/i915/i915_active.o
  CC [M]  drivers/gpu/drm/xe/i915-soc/intel_rom.o
  CC [M]  drivers/gpu/drm/xe/i915-display/icl_dsi.o
  CC      drivers/gpu/drm/i915/i915_cmd_parser.o
  CC      drivers/gpu/drm/i915/i915_deps.o
  CC      drivers/gpu/drm/i915/i915_gem.o
  CC      drivers/gpu/drm/i915/i915_gem_evict.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_alpm.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_atomic.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_atomic_plane.o
  CC      drivers/gpu/drm/i915/i915_gem_gtt.o
  CC      drivers/gpu/drm/i915/i915_gem_ww.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_audio.o
  CC      drivers/gpu/drm/i915/i915_query.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_backlight.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_bios.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_bw.o
  CC      drivers/gpu/drm/i915/i915_request.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_cdclk.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_cmtg.o
  CC      drivers/gpu/drm/i915/i915_scheduler.o
  CC      drivers/gpu/drm/i915/i915_trace_points.o
  CC      drivers/gpu/drm/i915/i915_ttm_buddy_manager.o
  CC      drivers/gpu/drm/i915/i915_vma.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_color.o
  CC      drivers/gpu/drm/i915/i915_vma_resource.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_combo_phy.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_gsc_fw.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_connector.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_crtc.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_gsc_proxy.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_gsc_uc.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_crtc_state_dump.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_cursor.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_gsc_uc_debugfs.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_cx0_phy.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_ddi.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_gsc_uc_heci_cmd_submit.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_ddi_buf_trans.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_ads.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_capture.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_ct.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_conversion.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_debugfs.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_device.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_fw.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_hwconfig.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_driver.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_irq.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_log.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_params.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_log_debugfs.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_power.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_rc.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_slpc.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_power_map.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_guc_submission.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_power_well.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_huc.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_huc_debugfs.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_trace.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_huc_fw.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_wa.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dkl_phy.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_uc.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dmc.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_uc_debugfs.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dmc_wl.o
  CC      drivers/gpu/drm/i915/gt/uc/intel_uc_fw.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dp.o
  CC      drivers/gpu/drm/i915/gt/intel_gsc.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dp_aux.o
  CC      drivers/gpu/drm/i915/i915_hwmon.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dp_aux_backlight.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dp_hdcp.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dp_link_training.o
  CC      drivers/gpu/drm/i915/display/hsw_ips.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dp_mst.o
  CC      drivers/gpu/drm/i915/display/i9xx_plane.o
  CC      drivers/gpu/drm/i915/display/i9xx_display_sr.o
  CC      drivers/gpu/drm/i915/display/i9xx_wm.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dp_test.o
  CC      drivers/gpu/drm/i915/display/intel_alpm.o
  CC      drivers/gpu/drm/i915/display/intel_atomic.o
  CC      drivers/gpu/drm/i915/display/intel_atomic_plane.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dpll.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dpll_mgr.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dpt_common.o
  CC      drivers/gpu/drm/i915/display/intel_audio.o
  CC      drivers/gpu/drm/i915/display/intel_bios.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_drrs.o
  CC      drivers/gpu/drm/i915/display/intel_bo.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dsb.o
  CC      drivers/gpu/drm/i915/display/intel_bw.o
  CC      drivers/gpu/drm/i915/display/intel_cdclk.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dsi.o
  CC      drivers/gpu/drm/i915/display/intel_cmtg.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dsi_dcs_backlight.o
  CC      drivers/gpu/drm/i915/display/intel_color.o
  CC      drivers/gpu/drm/i915/display/intel_combo_phy.o
  CC      drivers/gpu/drm/i915/display/intel_connector.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_dsi_vbt.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_encoder.o
  CC      drivers/gpu/drm/i915/display/intel_crtc.o
  CC      drivers/gpu/drm/i915/display/intel_crtc_state_dump.o
  CC      drivers/gpu/drm/i915/display/intel_cursor.o
  CC      drivers/gpu/drm/i915/display/intel_display.o
  CC      drivers/gpu/drm/i915/display/intel_display_conversion.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_fb.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_fbc.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_fdi.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_fifo_underrun.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_frontbuffer.o
  CC      drivers/gpu/drm/i915/display/intel_display_driver.o
  CC      drivers/gpu/drm/i915/display/intel_display_irq.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_global_state.o
  CC      drivers/gpu/drm/i915/display/intel_display_params.o
  CC      drivers/gpu/drm/i915/display/intel_display_power.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_gmbus.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_hdcp.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_hdcp_gsc_message.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_hdmi.o
  CC      drivers/gpu/drm/i915/display/intel_display_power_map.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_hotplug.o
  CC      drivers/gpu/drm/i915/display/intel_display_power_well.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_hotplug_irq.o
  CC      drivers/gpu/drm/i915/display/intel_display_reset.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_hti.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_link_bw.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_lspcon.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_modeset_lock.o
  CC      drivers/gpu/drm/i915/display/intel_display_rps.o
  CC      drivers/gpu/drm/i915/display/intel_display_snapshot.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_modeset_setup.o
  CC      drivers/gpu/drm/i915/display/intel_display_wa.o
  CC      drivers/gpu/drm/i915/display/intel_dmc.o
  CC      drivers/gpu/drm/i915/display/intel_dmc_wl.o
  CC      drivers/gpu/drm/i915/display/intel_dpio_phy.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_modeset_verify.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_panel.o
  CC      drivers/gpu/drm/i915/display/intel_dpll.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_pfit.o
  CC      drivers/gpu/drm/i915/display/intel_dpll_mgr.o
  CC      drivers/gpu/drm/i915/display/intel_dpt.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_pmdemand.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_pps.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_psr.o
  CC      drivers/gpu/drm/i915/display/intel_dpt_common.o
  CC      drivers/gpu/drm/i915/display/intel_drrs.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_qp_tables.o
  CC      drivers/gpu/drm/i915/display/intel_dsb.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_quirks.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_snps_hdmi_pll.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_snps_phy.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_tc.o
  CC      drivers/gpu/drm/i915/display/intel_dsb_buffer.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_vblank.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_vdsc.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_vga.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_vrr.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_wm.o
  CC [M]  drivers/gpu/drm/xe/i915-display/skl_scaler.o
  CC      drivers/gpu/drm/i915/display/intel_fb.o
  CC [M]  drivers/gpu/drm/xe/i915-display/skl_universal_plane.o
  CC      drivers/gpu/drm/i915/display/intel_fb_bo.o
  CC      drivers/gpu/drm/i915/display/intel_fb_pin.o
  CC      drivers/gpu/drm/i915/display/intel_fbc.o
  CC [M]  drivers/gpu/drm/xe/i915-display/skl_watermark.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_acpi.o
  CC      drivers/gpu/drm/i915/display/intel_fdi.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_opregion.o
  CC [M]  drivers/gpu/drm/xe/xe_debugfs.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_debugfs.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_sriov_vf_debugfs.o
  CC      drivers/gpu/drm/i915/display/intel_fifo_underrun.o
  CC [M]  drivers/gpu/drm/xe/xe_gt_stats.o
  CC [M]  drivers/gpu/drm/xe/xe_guc_debugfs.o
  CC [M]  drivers/gpu/drm/xe/xe_huc_debugfs.o
  CC      drivers/gpu/drm/i915/display/intel_frontbuffer.o
  CC      drivers/gpu/drm/i915/display/intel_global_state.o
  CC      drivers/gpu/drm/i915/display/intel_hdcp.o
  CC [M]  drivers/gpu/drm/xe/xe_uc_debugfs.o
  CC      drivers/gpu/drm/i915/display/intel_hdcp_gsc.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_debugfs.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_display_debugfs_params.o
  CC      drivers/gpu/drm/i915/display/intel_hdcp_gsc_message.o
  CC      drivers/gpu/drm/i915/display/intel_hotplug.o
  CC [M]  drivers/gpu/drm/xe/i915-display/intel_pipe_crc.o
  CC      drivers/gpu/drm/i915/display/intel_hotplug_irq.o
  CC      drivers/gpu/drm/i915/display/intel_hti.o
  CC      drivers/gpu/drm/i915/display/intel_link_bw.o
  CC      drivers/gpu/drm/i915/display/intel_load_detect.o
  CC      drivers/gpu/drm/i915/display/intel_lpe_audio.o
  CC      drivers/gpu/drm/i915/display/intel_modeset_lock.o
  CC      drivers/gpu/drm/i915/display/intel_modeset_setup.o
  CC      drivers/gpu/drm/i915/display/intel_modeset_verify.o
  CC      drivers/gpu/drm/i915/display/intel_overlay.o
  CC      drivers/gpu/drm/i915/display/intel_pch_display.o
  CC      drivers/gpu/drm/i915/display/intel_pch_refclk.o
  CC      drivers/gpu/drm/i915/display/intel_plane_initial.o
  CC      drivers/gpu/drm/i915/display/intel_pmdemand.o
  CC      drivers/gpu/drm/i915/display/intel_psr.o
  CC      drivers/gpu/drm/i915/display/intel_quirks.o
  CC      drivers/gpu/drm/i915/display/intel_sprite.o
  CC      drivers/gpu/drm/i915/display/intel_sprite_uapi.o
  CC      drivers/gpu/drm/i915/display/intel_tc.o
  CC      drivers/gpu/drm/i915/display/intel_vblank.o
  CC      drivers/gpu/drm/i915/display/intel_vga.o
  CC      drivers/gpu/drm/i915/display/intel_wm.o
  CC      drivers/gpu/drm/i915/display/skl_scaler.o
  CC      drivers/gpu/drm/i915/display/skl_universal_plane.o
  CC      drivers/gpu/drm/i915/display/skl_watermark.o
  CC      drivers/gpu/drm/i915/display/intel_acpi.o
  CC      drivers/gpu/drm/i915/display/intel_opregion.o
  CC      drivers/gpu/drm/i915/display/intel_display_debugfs.o
  CC      drivers/gpu/drm/i915/display/intel_display_debugfs_params.o
  CC      drivers/gpu/drm/i915/display/intel_pipe_crc.o
  CC      drivers/gpu/drm/i915/display/dvo_ch7017.o
  CC      drivers/gpu/drm/i915/display/dvo_ch7xxx.o
  CC      drivers/gpu/drm/i915/display/dvo_ivch.o
  CC      drivers/gpu/drm/i915/display/dvo_ns2501.o
  CC      drivers/gpu/drm/i915/display/dvo_sil164.o
  CC      drivers/gpu/drm/i915/display/dvo_tfp410.o
  CC      drivers/gpu/drm/i915/display/g4x_dp.o
  CC      drivers/gpu/drm/i915/display/g4x_hdmi.o
  CC      drivers/gpu/drm/i915/display/icl_dsi.o
  CC      drivers/gpu/drm/i915/display/intel_backlight.o
  CC      drivers/gpu/drm/i915/display/intel_crt.o
  CC      drivers/gpu/drm/i915/display/intel_cx0_phy.o
  CC      drivers/gpu/drm/i915/display/intel_ddi.o
  CC      drivers/gpu/drm/i915/display/intel_ddi_buf_trans.o
  CC      drivers/gpu/drm/i915/display/intel_display_device.o
  CC      drivers/gpu/drm/i915/display/intel_display_trace.o
  CC      drivers/gpu/drm/i915/display/intel_dkl_phy.o
  CC      drivers/gpu/drm/i915/display/intel_dp.o
  CC      drivers/gpu/drm/i915/display/intel_dp_aux.o
  CC      drivers/gpu/drm/i915/display/intel_dp_aux_backlight.o
  CC      drivers/gpu/drm/i915/display/intel_dp_hdcp.o
  CC      drivers/gpu/drm/i915/display/intel_dp_link_training.o
  CC      drivers/gpu/drm/i915/display/intel_dp_mst.o
  CC      drivers/gpu/drm/i915/display/intel_dp_test.o
  CC      drivers/gpu/drm/i915/display/intel_dsi.o
  CC      drivers/gpu/drm/i915/display/intel_dsi_dcs_backlight.o
  CC      drivers/gpu/drm/i915/display/intel_dsi_vbt.o
  CC      drivers/gpu/drm/i915/display/intel_dvo.o
  CC      drivers/gpu/drm/i915/display/intel_encoder.o
  CC      drivers/gpu/drm/i915/display/intel_gmbus.o
  CC      drivers/gpu/drm/i915/display/intel_hdmi.o
  CC      drivers/gpu/drm/i915/display/intel_lspcon.o
  CC      drivers/gpu/drm/i915/display/intel_lvds.o
  CC      drivers/gpu/drm/i915/display/intel_panel.o
  CC      drivers/gpu/drm/i915/display/intel_pfit.o
  CC      drivers/gpu/drm/i915/display/intel_pps.o
  CC      drivers/gpu/drm/i915/display/intel_qp_tables.o
  CC      drivers/gpu/drm/i915/display/intel_sdvo.o
  CC      drivers/gpu/drm/i915/display/intel_snps_hdmi_pll.o
  CC      drivers/gpu/drm/i915/display/intel_snps_phy.o
  CC      drivers/gpu/drm/i915/display/intel_tv.o
  CC      drivers/gpu/drm/i915/display/intel_vdsc.o
  CC      drivers/gpu/drm/i915/display/intel_vrr.o
  CC      drivers/gpu/drm/i915/display/vlv_dsi.o
  CC      drivers/gpu/drm/i915/display/vlv_dsi_pll.o
  CC      drivers/gpu/drm/i915/i915_perf.o
  CC      drivers/gpu/drm/i915/pxp/intel_pxp.o
  CC      drivers/gpu/drm/i915/pxp/intel_pxp_huc.o
  CC      drivers/gpu/drm/i915/pxp/intel_pxp_tee.o
  CC      drivers/gpu/drm/i915/i915_gpu_error.o
  CC      drivers/gpu/drm/i915/i915_vgpu.o
  LD [M]  drivers/gpu/drm/xe/xe.o
  AR      drivers/gpu/drm/i915/built-in.a
  AR      drivers/gpu/drm/built-in.a
  AR      drivers/gpu/built-in.a
  AR      drivers/built-in.a
  AR      built-in.a
  AR      vmlinux.a
  LD      vmlinux.o
  OBJCOPY modules.builtin.modinfo
  GEN     modules.builtin
  MODPOST Module.symvers
  CC      .vmlinux.export.o
  CC [M]  fs/efivarfs/efivarfs.mod.o
  CC [M]  .module-common.o
  CC [M]  drivers/gpu/drm/drm_exec.mod.o
  CC [M]  drivers/gpu/drm/drm_gpuvm.mod.o
  CC [M]  drivers/gpu/drm/drm_suballoc_helper.mod.o
  CC [M]  drivers/gpu/drm/drm_ttm_helper.mod.o
  CC [M]  drivers/gpu/drm/scheduler/gpu-sched.mod.o
  CC [M]  drivers/gpu/drm/xe/xe.mod.o
  CC [M]  drivers/thermal/intel/x86_pkg_temp_thermal.mod.o
  CC [M]  net/netfilter/nf_log_syslog.mod.o
  CC [M]  net/netfilter/xt_mark.mod.o
  CC [M]  net/netfilter/xt_nat.mod.o
  CC [M]  net/netfilter/xt_LOG.mod.o
  CC [M]  net/netfilter/xt_MASQUERADE.mod.o
  CC [M]  net/netfilter/xt_addrtype.mod.o
  CC [M]  net/ipv4/netfilter/iptable_nat.mod.o
  LD [M]  fs/efivarfs/efivarfs.ko
  LD [M]  drivers/gpu/drm/drm_exec.ko
  LD [M]  drivers/gpu/drm/xe/xe.ko
  LD [M]  net/netfilter/xt_MASQUERADE.ko
  LD [M]  net/netfilter/nf_log_syslog.ko
  LD [M]  net/ipv4/netfilter/iptable_nat.ko
  LD [M]  drivers/gpu/drm/drm_ttm_helper.ko
  LD [M]  drivers/gpu/drm/scheduler/gpu-sched.ko
  LD [M]  drivers/thermal/intel/x86_pkg_temp_thermal.ko
  LD [M]  net/netfilter/xt_mark.ko
  LD [M]  net/netfilter/xt_nat.ko
  LD [M]  net/netfilter/xt_LOG.ko
  LD [M]  drivers/gpu/drm/drm_gpuvm.ko
  LD [M]  net/netfilter/xt_addrtype.ko
  LD [M]  drivers/gpu/drm/drm_suballoc_helper.ko
  UPD     include/generated/utsversion.h
  CC      init/version-timestamp.o
  KSYMS   .tmp_vmlinux0.kallsyms.S
  AS      .tmp_vmlinux0.kallsyms.o
  LD      .tmp_vmlinux1
  NM      .tmp_vmlinux1.syms
  KSYMS   .tmp_vmlinux1.kallsyms.S
  AS      .tmp_vmlinux1.kallsyms.o
  LD      .tmp_vmlinux2
  NM      .tmp_vmlinux2.syms
  KSYMS   .tmp_vmlinux2.kallsyms.S
  AS      .tmp_vmlinux2.kallsyms.o
  LD      vmlinux
  NM      System.map
  SORTTAB vmlinux
  RELOCS  arch/x86/boot/compressed/vmlinux.relocs
  RSTRIP  vmlinux
  CC      arch/x86/boot/a20.o
  AS      arch/x86/boot/bioscall.o
  CC      arch/x86/boot/cmdline.o
  AS      arch/x86/boot/copy.o
  HOSTCC  arch/x86/boot/mkcpustr
  CC      arch/x86/boot/cpuflags.o
  CC      arch/x86/boot/cpucheck.o
  CC      arch/x86/boot/early_serial_console.o
  CC      arch/x86/boot/edd.o
  CC      arch/x86/boot/main.o
  CC      arch/x86/boot/memory.o
  CC      arch/x86/boot/pm.o
  AS      arch/x86/boot/pmjump.o
  CC      arch/x86/boot/printf.o
  CC      arch/x86/boot/regs.o
  CC      arch/x86/boot/string.o
  CC      arch/x86/boot/tty.o
  CC      arch/x86/boot/video.o
  CC      arch/x86/boot/video-mode.o
  CC      arch/x86/boot/version.o
  CC      arch/x86/boot/video-vga.o
  CC      arch/x86/boot/video-vesa.o
  CC      arch/x86/boot/video-bios.o
  HOSTCC  arch/x86/boot/tools/build
  LDS     arch/x86/boot/compressed/vmlinux.lds
  CPUSTR  arch/x86/boot/cpustr.h
  AS      arch/x86/boot/compressed/kernel_info.o
  AS      arch/x86/boot/compressed/head_32.o
  VOFFSET arch/x86/boot/compressed/../voffset.h
  CC      arch/x86/boot/compressed/string.o
  CC      arch/x86/boot/cpu.o
  CC      arch/x86/boot/compressed/cmdline.o
  CC      arch/x86/boot/compressed/error.o
  OBJCOPY arch/x86/boot/compressed/vmlinux.bin
  HOSTCC  arch/x86/boot/compressed/mkpiggy
  CC      arch/x86/boot/compressed/cpuflags.o
  CC      arch/x86/boot/compressed/early_serial_console.o
  CC      arch/x86/boot/compressed/kaslr.o
  CC      arch/x86/boot/compressed/acpi.o
  CC      arch/x86/boot/compressed/efi.o
  GZIP    arch/x86/boot/compressed/vmlinux.bin.gz
  CC      arch/x86/boot/compressed/misc.o
  MKPIGGY arch/x86/boot/compressed/piggy.S
  AS      arch/x86/boot/compressed/piggy.o
  LD      arch/x86/boot/compressed/vmlinux
  ZOFFSET arch/x86/boot/zoffset.h
  OBJCOPY arch/x86/boot/vmlinux.bin
  AS      arch/x86/boot/header.o
  LD      arch/x86/boot/setup.elf
  OBJCOPY arch/x86/boot/setup.bin
  BUILD   arch/x86/boot/bzImage
Kernel: arch/x86/boot/bzImage is ready  (#1)
run-parts: executing /workspace/ci/hooks/20-kernel-doc
+ SRC_DIR=/workspace/kernel
+ cd /workspace/kernel
+ find drivers/gpu/drm/xe/ -name '*.[ch]' -not -path 'drivers/gpu/drm/xe/display/*'
+ xargs ./scripts/kernel-doc -Werror -none include/uapi/drm/xe_drm.h
All hooks done

✓ CI.checksparse: success for Add support for EU stall sampling

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

+ trap cleanup EXIT
+ KERNEL=/kernel
+ MT=/root/linux/maintainer-tools
+ git clone https://gitlab.freedesktop.org/drm/maintainer-tools /root/linux/maintainer-tools
Cloning into '/root/linux/maintainer-tools'...
warning: redirecting to https://gitlab.freedesktop.org/drm/maintainer-tools.git/
+ make -C /root/linux/maintainer-tools
make: Entering directory '/root/linux/maintainer-tools'
cc -O2 -g -Wextra -o remap-log remap-log.c
make: Leaving directory '/root/linux/maintainer-tools'
+ cd /kernel
+ git config --global --add safe.directory /kernel
+ /root/linux/maintainer-tools/dim sparse --fast 656e731586e568a8633c0bd16d28dcec8d67f237
Sparse version: 0.6.4 (Ubuntu: 0.6.4-4ubuntu3)
Fast mode used, each commit won't be checked separately.
Okay!

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

Re: [PATCH v9 1/8] drm/xe/topology: Add a function to find the index of the last enabled DSS in a mask

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:42 -0800, Harish Chegondi wrote:
>
> +static inline unsigned int
> +xe_gt_topology_mask_last_dss(const xe_dss_mask_t mask)
> +{
> +	return find_last_bit(mask, XE_MAX_DSS_FUSE_BITS);

I am still wondering if this function should be in the .c instead, because
we have not included linux/find.h where find_last_bit is declared, and if
this might have problems of circular depenedencies in the future. Anyway,
for now things are compiling so this is:

Reviewed-by: Ashutosh Dixit <ashutosh.dixit@intel.com>


> +}
> +
>  unsigned int
>  xe_dss_mask_group_ffs(const xe_dss_mask_t mask, int groupsize, int groupnum);
>
> --
> 2.48.1
>

Re: [PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:43 -0800, Harish Chegondi wrote:
>

Hi Harish,

> A new hardware feature first introduced in PVC gives capability to
> periodically sample EU stall state and record counts for different stall
> reasons, on a per IP basis, aggregate across all EUs in a subslice and
> record the samples in a buffer in each subslice. Eventually, the aggregated
> data is written out to a buffer in the memory. This feature is also
> supported in XE2 and later architecture GPUs.
>
> Use an existing IOCTL - DRM_IOCTL_XE_OBSERVATION as the interface into the
> driver from the user space to do initial setup and obtain a file descriptor
> for the EU stall data stream.  Input parameter to the IOCTL is a struct
> drm_xe_observation_param in which observation_type should be set to
> DRM_XE_OBSERVATION_TYPE_EU_STALL, observation_op should be
> DRM_XE_OBSERVATION_OP_STREAM_OPEN and param should point to a chain of
> drm_xe_ext_set_property structures in which each structure has a pair of
> property and value. The EU stall sampling input properties are defined in
> drm_xe_eu_stall_property_id enum.
>
> With the file descriptor obtained from DRM_IOCTL_XE_OBSERVATION, user space
> can enable and disable EU stall sampling with the IOCTLs:
> DRM_XE_OBSERVATION_IOCTL_ENABLE and DRM_XE_OBSERVATION_IOCTL_DISABLE.
> User space can also call poll() to check for availability of data in the
> buffer. The data can be read with read(). Finally, the file descriptor
> can be closed with close().
>
> v9: Changed some u32 to unsigned int.
>     Moved some code around as per review feedback from v8.
> v8: Used div_u64 instead of / to fix 32-bit build issue.
>     Changed copyright year in xe_eu_stall.c/h to 2025.
> v7: Renamed input property DRM_XE_EU_STALL_PROP_EVENT_REPORT_COUNT
>     to DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS to be consistent with
>     OA. Renamed the corresponding internal variables.
>     Fixed some commit messages based on review feedback.
> v6: Change the input sampling rate to GPU cycles instead of
>     GPU cycles multiplier.
>
> Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> ---
>  drivers/gpu/drm/xe/Makefile         |   1 +
>  drivers/gpu/drm/xe/xe_eu_stall.c    | 280 ++++++++++++++++++++++++++++
>  drivers/gpu/drm/xe/xe_eu_stall.h    |  16 ++
>  drivers/gpu/drm/xe/xe_observation.c |  14 ++
>  include/uapi/drm/xe_drm.h           |  38 ++++
>  5 files changed, 349 insertions(+)
>  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.c
>  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.h
>
> diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
> index be73362ef334..05bcb9941c38 100644
> --- a/drivers/gpu/drm/xe/Makefile
> +++ b/drivers/gpu/drm/xe/Makefile
> @@ -33,6 +33,7 @@ xe-y += xe_bb.o \
>	xe_device_sysfs.o \
>	xe_dma_buf.o \
>	xe_drm_client.o \
> +	xe_eu_stall.o \
>	xe_exec.o \
>	xe_exec_queue.o \
>	xe_execlist.o \
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> new file mode 100644
> index 000000000000..0ceb3091f81e
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> @@ -0,0 +1,280 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2025 Intel Corporation
> + */
> +
> +#include <linux/anon_inodes.h>
> +#include <linux/fs.h>
> +#include <linux/poll.h>
> +#include <linux/types.h>
> +
> +#include <uapi/drm/xe_drm.h>
> +
> +#include "xe_device.h"
> +#include "xe_eu_stall.h"
> +#include "xe_gt_printk.h"
> +#include "xe_gt_topology.h"
> +#include "xe_macros.h"
> +#include "xe_observation.h"
> +
> +static size_t per_xecore_buf_size = SZ_512K;
> +
> +/**
> + * struct eu_stall_open_properties - EU stall sampling properties received
> + *				     from user space at open.
> + * @sampling_rate_mult: EU stall sampling rate multiplier.
> + *			HW will sample every (sampling_rate_mult x 251) cycles.
> + * @wait_num_reports: Minimum number of EU stall data reports to unblock poll().
> + * @gt: GT on which EU stall data will be captured.
> + */
> +struct eu_stall_open_properties {
> +	unsigned int sampling_rate_mult;
> +	unsigned int wait_num_reports;

I already said no need to be so specific. Just use int or u32 as types for
these.

> +	struct xe_gt *gt;
> +};
> +
> +/**
> + * num_data_rows - Return the number of EU stall data rows of 64B each
> + *		   for a given data size.
> + *
> + * @data_size: EU stall data size
> + */
> +static u32 num_data_rows(u32 data_size)
> +{
> +	return (data_size >> 6);
> +}
> +
> +static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
> +					   struct eu_stall_open_properties *props)
> +{
> +	value = div_u64(value, 251);
> +	if (value == 0 || value > 7) {
> +		drm_dbg(&xe->drm, "Invalid EU stall sampling rate %llu\n", value);
> +		return -EINVAL;
> +	}
> +	props->sampling_rate_mult = value;
> +	return 0;
> +}
> +
> +static int set_prop_eu_stall_wait_num_reports(struct xe_device *xe, u64 value,
> +					      struct eu_stall_open_properties *props)
> +{
> +	unsigned int max_wait_num_reports;
> +
> +	max_wait_num_reports = num_data_rows(per_xecore_buf_size * XE_MAX_DSS_FUSE_BITS);

This seems wrong. Instead of XE_MAX_DSS_FUSE_BITS, shouldn't we use the
value returned by xe_gt_topology_mask_last_dss()?

Note that a large value can result in the poll/read never getting
unblocked!

To solve this issue I think num_xecore should be maintained in struct
xe_eu_stall_gt. Though let's see what happens to 'struct xe_device *' arg
to these functions if we do this.

> +	if (value == 0 || value > max_wait_num_reports) {
> +		drm_dbg(&xe->drm, "Invalid EU stall event report count %llu\n", value);
> +		drm_dbg(&xe->drm, "Minimum event report count is 1, maximum is %u\n",
> +			max_wait_num_reports);
> +		return -EINVAL;
> +	}
> +	props->wait_num_reports = value;
> +	return 0;
> +}
> +
> +static int set_prop_eu_stall_gt_id(struct xe_device *xe, u64 value,
> +				   struct eu_stall_open_properties *props)
> +{
> +	if (value >= xe->info.gt_count) {
> +		drm_dbg(&xe->drm, "Invalid GT ID %llu for EU stall sampling\n", value);
> +		return -EINVAL;
> +	}
> +	props->gt = xe_device_get_gt(xe, value);
> +	return 0;
> +}
> +
> +typedef int (*set_eu_stall_property_fn)(struct xe_device *xe, u64 value,
> +					struct eu_stall_open_properties *props);
> +
> +static const set_eu_stall_property_fn xe_set_eu_stall_property_funcs[] = {
> +	[DRM_XE_EU_STALL_PROP_SAMPLE_RATE] = set_prop_eu_stall_sampling_rate,
> +	[DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS] = set_prop_eu_stall_wait_num_reports,
> +	[DRM_XE_EU_STALL_PROP_GT_ID] = set_prop_eu_stall_gt_id,
> +};
> +
> +static int xe_eu_stall_user_ext_set_property(struct xe_device *xe, u64 extension,
> +					     struct eu_stall_open_properties *props)
> +{
> +	u64 __user *address = u64_to_user_ptr(extension);
> +	struct drm_xe_ext_set_property ext;
> +	int err;
> +	u32 idx;
> +
> +	err = __copy_from_user(&ext, address, sizeof(ext));
> +	if (XE_IOCTL_DBG(xe, err))
> +		return -EFAULT;
> +
> +	if (XE_IOCTL_DBG(xe, ext.property >= ARRAY_SIZE(xe_set_eu_stall_property_funcs)) ||
> +	    XE_IOCTL_DBG(xe, ext.pad))
> +		return -EINVAL;
> +
> +	idx = array_index_nospec(ext.property, ARRAY_SIZE(xe_set_eu_stall_property_funcs));
> +	return xe_set_eu_stall_property_funcs[idx](xe, ext.value, props);
> +}
> +
> +typedef int (*xe_eu_stall_user_extension_fn)(struct xe_device *xe, u64 extension,
> +					     struct eu_stall_open_properties *props);
> +static const xe_eu_stall_user_extension_fn xe_eu_stall_user_extension_funcs[] = {
> +	[DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY] = xe_eu_stall_user_ext_set_property,
> +};
> +
> +static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> +				       struct eu_stall_open_properties *props)

What is the reason for not using the ext_number argument here, which is
used in both exec_queue_user_extensions and in xe_oa_user_extensions?

The reason for ext_number is that the extensions can be chained in a loop,
which can cause an infinite loop in the kernel when parsing these
extensions. ext_number is used to break out of these potential infinite
loops.

> +{
> +	u64 __user *address = u64_to_user_ptr(extension);
> +	struct drm_xe_user_extension ext;
> +	int err;
> +	u32 idx;
> +
> +	err = __copy_from_user(&ext, address, sizeof(ext));
> +	if (XE_IOCTL_DBG(xe, err))
> +		return -EFAULT;
> +
> +	if (XE_IOCTL_DBG(xe, ext.pad) ||
> +	    XE_IOCTL_DBG(xe, ext.name >= ARRAY_SIZE(xe_eu_stall_user_extension_funcs)))
> +		return -EINVAL;
> +
> +	idx = array_index_nospec(ext.name, ARRAY_SIZE(xe_eu_stall_user_extension_funcs));
> +	err = xe_eu_stall_user_extension_funcs[idx](xe, extension, props);
> +	if (XE_IOCTL_DBG(xe, err))
> +		return err;
> +
> +	if (ext.next_extension)
> +		return xe_eu_stall_user_extensions(xe, ext.next_extension, props);
> +
> +	return 0;
> +}
> +
> +/**
> + * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> + *
> + * @file: An xe EU stall data stream file
> + * @buf: destination buffer given by userspace
> + * @count: the number of bytes userspace wants to read
> + * @ppos: (inout) file seek position (unused)
> + *
> + * Userspace must enable the EU stall stream with DRM_XE_OBSERVATION_IOCTL_ENABLE
> + * before calling read().

We can just retain these two lines of comment. See below.

> + *
> + * Returns: The number of bytes copied or a negative error code on failure.
> + */
> +static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> +				       size_t count, loff_t *ppos)
> +{
> +	ssize_t ret = 0;
> +
> +	return ret;
> +}
> +
> +/**
> + * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> + *
> + * @file: An xe EU stall data stream file
> + * @wait: Poll table
> + *
> + * Returns: Bit mask of returned events.
> + */
> +static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> +{
> +	__poll_t ret = 0;
> +
> +	return ret;
> +}
> +
> +/**
> + * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
> + *
> + * @file: An xe EU stall data stream file
> + * @cmd: the ioctl request
> + * @arg: the ioctl data
> + *
> + * Returns: zero on success or a negative error code.
> + *	    -EINVAL for an unknown ioctl request.
> + */
> +static long xe_eu_stall_stream_ioctl(struct file *file,
> +				     unsigned int cmd,
> +				     unsigned long arg)
> +{
> +	switch (cmd) {
> +	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> +		return 0;
> +	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> +		return 0;
> +	}
> +
> +	return -EINVAL;

Just return 0 or -EINVAL in this patch since you are going to add locking
in a later patch.

> +}
> +
> +/**
> + * xe_eu_stall_stream_close - handles userspace close() of a EU stall data
> + *			      stream file.
> + * @inode: anonymous inode associated with file
> + * @file: An xe EU stall data stream file
> + *
> + * Cleans up any resources associated with an open EU stall data stream file.
> + */

As I said before, these comments are completely redundant. These are
standard file_operations. There are one million instances of these in the
kernel, all of them have exactly the same arguments.

If you have anything specific to EU stall here, we can leave it. Otherwise
I'd still say get rid of them.

Or get rid them now and send a patch later to add them, we can review that
patch later, if you really think they add value. They were included in
i915_perf.c, but I don't think they should be in Xe.

If you think these comments should be there, let's get a second opinion,
from one of the maintainers.

> +static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
> +{
> +	return 0;
> +}
> +
> +static const struct file_operations fops_eu_stall = {
> +	.owner		= THIS_MODULE,
> +	.llseek		= noop_llseek,
> +	.release	= xe_eu_stall_stream_close,
> +	.poll		= xe_eu_stall_stream_poll,
> +	.read		= xe_eu_stall_stream_read,
> +	.unlocked_ioctl = xe_eu_stall_stream_ioctl,
> +	.compat_ioctl   = xe_eu_stall_stream_ioctl,
> +};
> +
> +static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
> +{
> +	return false;
> +}
> +
> +/**
> + * xe_eu_stall_stream_open - Open a xe EU stall data stream fd
> + *
> + * @dev: DRM device pointer
> + * @data: pointer to first struct @drm_xe_ext_set_property in
> + *	  the chain of input properties from the user space.
> + * @file: DRM file pointer
> + *
> + * This function opens a EU stall data stream with input properties from
> + * the user space.
> + *
> + * Returns: EU stall data stream fd on success or a negative error code.
> + */
> +int xe_eu_stall_stream_open(struct drm_device *dev,
> +			    u64 data,
> +			    struct drm_file *file)
> +{
> +	struct xe_device *xe = to_xe_device(dev);
> +	struct eu_stall_open_properties props = {};
> +	int ret, stream_fd;
> +
> +	if (xe_observation_paranoid && !perfmon_capable()) {
> +		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
> +		return -EACCES;
> +	}
> +	if (!has_eu_stall_sampling_support(xe)) {
> +		xe_gt_dbg(props.gt, "EU stall monitoring is not supported on this platform\n");
> +		return -EPERM;

I think we are using -ENODEV for this, at least in OA.

> +	}

Move this has_eu_stall_sampling_support at the top, this should be even
before the perfmon_capable check.

> +
> +	ret = xe_eu_stall_user_extensions(xe, data, &props);
> +	if (ret)
> +		return ret;
> +
> +	if (!props.gt) {
> +		drm_dbg(&xe->drm, "GT ID not provided for EU stall sampling\n");
> +		return -EINVAL;
> +	}

This check is not needed. props.gt cannot be NULL the way
set_prop_eu_stall_gt_id is implemented.

If you need it, use xe_assert(props->gt) in set_prop_eu_stall_gt_id.

> +
> +	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
> +	if (stream_fd < 0)
> +		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
> +
> +	return stream_fd;
> +}
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
> new file mode 100644
> index 000000000000..d514e78341d5
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.h
> @@ -0,0 +1,16 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2025 Intel Corporation
> + */
> +
> +#ifndef __XE_EU_STALL_H__
> +#define __XE_EU_STALL_H__
> +
> +#include <drm/drm_device.h>
> +#include <drm/drm_file.h>
> +#include <linux/types.h>

Because these lines are replaced in a future patch with '#include
"xe_gt_types.h"', just do that in this patch itself.

Also, as I said, I am not going to focus too much on the patches, only the
final code, but in general, if you are deleting lines in these initial
patches, think hard about why you need delete those lines and what you
could do differently.

> +
> +int xe_eu_stall_stream_open(struct drm_device *dev,
> +			    u64 data,
> +			    struct drm_file *file);
> +#endif
> diff --git a/drivers/gpu/drm/xe/xe_observation.c b/drivers/gpu/drm/xe/xe_observation.c
> index 8ec1b84cbb9e..cca661de60ac 100644
> --- a/drivers/gpu/drm/xe/xe_observation.c
> +++ b/drivers/gpu/drm/xe/xe_observation.c
> @@ -9,6 +9,7 @@
>  #include <uapi/drm/xe_drm.h>
>
>  #include "xe_oa.h"
> +#include "xe_eu_stall.h"
>  #include "xe_observation.h"
>
>  u32 xe_observation_paranoid = true;
> @@ -29,6 +30,17 @@ static int xe_oa_ioctl(struct drm_device *dev, struct drm_xe_observation_param *
>	}
>  }
>
> +static int xe_eu_stall_ioctl(struct drm_device *dev, struct drm_xe_observation_param *arg,
> +			     struct drm_file *file)
> +{
> +	switch (arg->observation_op) {
> +	case DRM_XE_OBSERVATION_OP_STREAM_OPEN:
> +		return xe_eu_stall_stream_open(dev, arg->param, file);
> +	default:
> +		return -EINVAL;
> +	}
> +}
> +
>  /**
>   * xe_observation_ioctl - The top level observation layer ioctl
>   * @dev: @drm_device
> @@ -51,6 +63,8 @@ int xe_observation_ioctl(struct drm_device *dev, void *data, struct drm_file *fi
>	switch (arg->observation_type) {
>	case DRM_XE_OBSERVATION_TYPE_OA:
>		return xe_oa_ioctl(dev, arg, file);
> +	case DRM_XE_OBSERVATION_TYPE_EU_STALL:
> +		return xe_eu_stall_ioctl(dev, arg, file);
>	default:
>		return -EINVAL;
>	}
> diff --git a/include/uapi/drm/xe_drm.h b/include/uapi/drm/xe_drm.h
> index 892f54d3aa09..1d79621f267b 100644
> --- a/include/uapi/drm/xe_drm.h
> +++ b/include/uapi/drm/xe_drm.h
> @@ -1496,6 +1496,8 @@ struct drm_xe_wait_user_fence {
>  enum drm_xe_observation_type {
>	/** @DRM_XE_OBSERVATION_TYPE_OA: OA observation stream type */
>	DRM_XE_OBSERVATION_TYPE_OA,
> +	/** @DRM_XE_OBSERVATION_TYPE_EU_STALL: EU stall sampling observation stream type */
> +	DRM_XE_OBSERVATION_TYPE_EU_STALL,
>  };
>
>  /**
> @@ -1848,6 +1850,42 @@ enum drm_xe_pxp_session_type {
>  /* ID of the protected content session managed by Xe when PXP is active */
>  #define DRM_XE_PXP_HWDRM_DEFAULT_SESSION 0xf
>
> +/**
> + * enum drm_xe_eu_stall_property_id - EU stall sampling input property ids.
> + *
> + * These properties are passed to the driver at open as a chain of
> + * @drm_xe_ext_set_property structures with @property set to these
> + * properties' enums and @value set to the corresponding values of these
> + * properties. @drm_xe_user_extension base.name should be set to
> + * @DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY.
> + *
> + * With the file descriptor obtained from open, user space must enable
> + * the EU stall stream fd with @DRM_XE_OBSERVATION_IOCTL_ENABLE before
> + * calling read(). EIO errno from read() indicates HW dropped data
> + * due to full buffer.
> + */
> +enum drm_xe_eu_stall_property_id {
> +#define DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY		0
> +	/**
> +	 * @DRM_XE_EU_STALL_PROP_GT_ID: @gt_id of the GT on which
> +	 * EU stall data will be captured.
> +	 */
> +	DRM_XE_EU_STALL_PROP_GT_ID = 1,
> +
> +	/**
> +	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate
> +	 * in GPU cycles.
> +	 */
> +	DRM_XE_EU_STALL_PROP_SAMPLE_RATE,
> +
> +	/**
> +	 * @DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS: Minimum number of
> +	 * EU stall data reports to be present in the kernel buffer
> +	 * before unblocking poll or read that is blocked.

before unblocking a blocked poll or read

> +	 */
> +	DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS,
> +};
> +
>  #if defined(__cplusplus)
>  }
>  #endif
> --
> 2.48.1
>

Re: [PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 15:07:51 -0800, Dixit, Ashutosh wrote:
>
> > +
> > +	ret = xe_eu_stall_user_extensions(xe, data, &props);
> > +	if (ret)
> > +		return ret;
> > +
> > +	if (!props.gt) {
> > +		drm_dbg(&xe->drm, "GT ID not provided for EU stall sampling\n");
> > +		return -EINVAL;
> > +	}
>
> This check is not needed. props.gt cannot be NULL the way
> set_prop_eu_stall_gt_id is implemented.
>
> If you need it, use xe_assert(props->gt) in set_prop_eu_stall_gt_id.

Sorry, this is needed in case gt_id is not provided by userland. Unless
default gt_id can be 0, in which case this is not needed?

✓ CI.Patch_applied: success for Add support for EU stall sampling (rev2)

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling (rev2)
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

=== Applying kernel patches on branch 'drm-tip' with base: ===
Base commit: 2fc58ab10139 drm-tip: 2025y-02m-10d-21h-24m-23s UTC integration manifest
=== git am output follows ===
Applying: drm/xe/topology: Add a function to find the index of the last enabled DSS in a mask
Applying: drm/xe/uapi: Introduce API for EU stall sampling
Applying: drm/xe/eustall: Add support to init, enable and disable EU stall sampling
Applying: drm/xe/eustall: Add support to read() and poll() EU stall data
Applying: drm/xe/eustall: Add support to handle dropped EU stall data
Applying: drm/xe/eustall: Add EU stall sampling support for Xe2
Applying: drm/xe/uapi: Add a device query to get EU stall sampling information
Applying: drm/xe/eustall: Add workaround 22016596838 which applies to PVC.

✗ CI.checkpatch: warning for Add support for EU stall sampling (rev2)

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling (rev2)
URL   : https://patchwork.freedesktop.org/series/144609/
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
22f9cda3436b4fe965b5c5f31d2f2c1bcb483189
+ cd /kernel
+ git config --global --add safe.directory /kernel
+ git log -n1
commit 36cce1f89b9a6b9f8248525479ef04ce84c2da7b
Author: Harish Chegondi <harish.chegondi@intel.com>
Date:   Mon Feb 10 05:46:49 2025 -0800

    drm/xe/eustall: Add workaround 22016596838 which applies to PVC.
    
    Add PVC workaround 22016596838 that disables EU DOP gating
    during EU stall sampling.
    
    Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
+ /mt/dim checkpatch 2fc58ab10139895686001c7e1ee247f15226abc4 drm-intel
a2b5d88c5295 drm/xe/topology: Add a function to find the index of the last enabled DSS in a mask
9b093fa0a013 drm/xe/uapi: Introduce API for EU stall sampling
-:56: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#56: 
new file mode 100644

total: 0 errors, 1 warnings, 0 checks, 385 lines checked
8c30fac8be33 drm/xe/eustall: Add support to init, enable and disable EU stall sampling
-:28: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#28: 
new file mode 100644

total: 0 errors, 1 warnings, 0 checks, 531 lines checked
1ef93367de30 drm/xe/eustall: Add support to read() and poll() EU stall data
5d571fe717a3 drm/xe/eustall: Add support to handle dropped EU stall data
e138a5bc11f5 drm/xe/eustall: Add EU stall sampling support for Xe2
e5b16a5eab2d drm/xe/uapi: Add a device query to get EU stall sampling information
36cce1f89b9a drm/xe/eustall: Add workaround 22016596838 which applies to PVC.

✓ CI.KUnit: success for Add support for EU stall sampling (rev2)

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling (rev2)
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

+ trap cleanup EXIT
+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig
[07:24:33] Configuring KUnit Kernel ...
Generating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[07:24:37] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json ARCH=um O=.kunit --jobs=48
../lib/iomap.c:156:5: warning: no previous prototype for ‘ioread64_lo_hi’ [-Wmissing-prototypes]
  156 | u64 ioread64_lo_hi(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~
../lib/iomap.c:163:5: warning: no previous prototype for ‘ioread64_hi_lo’ [-Wmissing-prototypes]
  163 | u64 ioread64_hi_lo(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~
../lib/iomap.c:170:5: warning: no previous prototype for ‘ioread64be_lo_hi’ [-Wmissing-prototypes]
  170 | u64 ioread64be_lo_hi(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~~~
../lib/iomap.c:178:5: warning: no previous prototype for ‘ioread64be_hi_lo’ [-Wmissing-prototypes]
  178 | u64 ioread64be_hi_lo(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~~~
../lib/iomap.c:264:6: warning: no previous prototype for ‘iowrite64_lo_hi’ [-Wmissing-prototypes]
  264 | void iowrite64_lo_hi(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~
../lib/iomap.c:272:6: warning: no previous prototype for ‘iowrite64_hi_lo’ [-Wmissing-prototypes]
  272 | void iowrite64_hi_lo(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~
../lib/iomap.c:280:6: warning: no previous prototype for ‘iowrite64be_lo_hi’ [-Wmissing-prototypes]
  280 | void iowrite64be_lo_hi(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~~~
../lib/iomap.c:288:6: warning: no previous prototype for ‘iowrite64be_hi_lo’ [-Wmissing-prototypes]
  288 | void iowrite64be_hi_lo(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~~~

[07:25:03] Starting KUnit Kernel (1/1)...
[07:25:03] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[07:25:03] ================== guc_buf (11 subtests) ===================
[07:25:03] [PASSED] test_smallest
[07:25:03] [PASSED] test_largest
[07:25:03] [PASSED] test_granular
[07:25:03] [PASSED] test_unique
[07:25:03] [PASSED] test_overlap
[07:25:03] [PASSED] test_reusable
[07:25:03] [PASSED] test_too_big
[07:25:03] [PASSED] test_flush
[07:25:03] [PASSED] test_lookup
[07:25:03] [PASSED] test_data
[07:25:03] [PASSED] test_class
[07:25:03] ===================== [PASSED] guc_buf =====================
[07:25:03] =================== guc_dbm (7 subtests) ===================
[07:25:03] [PASSED] test_empty
[07:25:03] [PASSED] test_default
[07:25:03] ======================== test_size  ========================
[07:25:03] [PASSED] 4
[07:25:03] [PASSED] 8
[07:25:03] [PASSED] 32
[07:25:03] [PASSED] 256
[07:25:03] ==================== [PASSED] test_size ====================
[07:25:03] ======================= test_reuse  ========================
[07:25:03] [PASSED] 4
[07:25:03] [PASSED] 8
[07:25:03] [PASSED] 32
[07:25:03] [PASSED] 256
[07:25:03] =================== [PASSED] test_reuse ====================
[07:25:03] =================== test_range_overlap  ====================
[07:25:03] [PASSED] 4
[07:25:03] [PASSED] 8
[07:25:03] [PASSED] 32
[07:25:03] [PASSED] 256
[07:25:03] =============== [PASSED] test_range_overlap ================
[07:25:03] =================== test_range_compact  ====================
[07:25:03] [PASSED] 4
[07:25:03] [PASSED] 8
[07:25:03] [PASSED] 32
[07:25:03] [PASSED] 256
[07:25:03] =============== [PASSED] test_range_compact ================
[07:25:03] ==================== test_range_spare  =====================
[07:25:03] [PASSED] 4
[07:25:03] [PASSED] 8
[07:25:03] [PASSED] 32
[07:25:03] [PASSED] 256
[07:25:03] ================ [PASSED] test_range_spare =================
[07:25:03] ===================== [PASSED] guc_dbm =====================
[07:25:03] =================== guc_idm (6 subtests) ===================
[07:25:03] [PASSED] bad_init
[07:25:03] [PASSED] no_init
[07:25:03] [PASSED] init_fini
[07:25:03] [PASSED] check_used
[07:25:03] [PASSED] check_quota
[07:25:03] [PASSED] check_all
[07:25:03] ===================== [PASSED] guc_idm =====================
[07:25:03] ================== no_relay (3 subtests) ===================
[07:25:03] [PASSED] xe_drops_guc2pf_if_not_ready
[07:25:03] [PASSED] xe_drops_guc2vf_if_not_ready
[07:25:03] [PASSED] xe_rejects_send_if_not_ready
[07:25:03] ==================== [PASSED] no_relay =====================
[07:25:03] ================== pf_relay (14 subtests) ==================
[07:25:03] [PASSED] pf_rejects_guc2pf_too_short
[07:25:03] [PASSED] pf_rejects_guc2pf_too_long
[07:25:03] [PASSED] pf_rejects_guc2pf_no_payload
[07:25:03] [PASSED] pf_fails_no_payload
[07:25:03] [PASSED] pf_fails_bad_origin
[07:25:03] [PASSED] pf_fails_bad_type
[07:25:03] [PASSED] pf_txn_reports_error
[07:25:03] [PASSED] pf_txn_sends_pf2guc
[07:25:03] [PASSED] pf_sends_pf2guc
[07:25:03] [SKIPPED] pf_loopback_nop
[07:25:03] [SKIPPED] pf_loopback_echo
[07:25:03] [SKIPPED] pf_loopback_fail
[07:25:03] [SKIPPED] pf_loopback_busy
[07:25:03] [SKIPPED] pf_loopback_retry
[07:25:03] ==================== [PASSED] pf_relay =====================
[07:25:03] ================== vf_relay (3 subtests) ===================
[07:25:03] [PASSED] vf_rejects_guc2vf_too_short
[07:25:03] [PASSED] vf_rejects_guc2vf_too_long
[07:25:03] [PASSED] vf_rejects_guc2vf_no_payload
[07:25:03] ==================== [PASSED] vf_relay =====================
[07:25:03] ================= pf_service (11 subtests) =================
[07:25:03] [PASSED] pf_negotiate_any
[07:25:03] [PASSED] pf_negotiate_base_match
[07:25:03] [PASSED] pf_negotiate_base_newer
[07:25:03] [PASSED] pf_negotiate_base_next
[07:25:03] [SKIPPED] pf_negotiate_base_older
[07:25:03] [PASSED] pf_negotiate_base_prev
[07:25:03] [PASSED] pf_negotiate_latest_match
[07:25:03] [PASSED] pf_negotiate_latest_newer
[07:25:03] [PASSED] pf_negotiate_latest_next
[07:25:03] [SKIPPED] pf_negotiate_latest_older
[07:25:03] [SKIPPED] pf_negotiate_latest_prev
[07:25:03] =================== [PASSED] pf_service ====================
[07:25:03] ===================== lmtt (1 subtest) =====================
[07:25:03] ======================== test_ops  =========================
[07:25:03] [PASSED] 2-level
[07:25:03] [PASSED] multi-level
[07:25:03] ==================== [PASSED] test_ops =====================
[07:25:03] ====================== [PASSED] lmtt =======================
[07:25:03] =================== xe_mocs (2 subtests) ===================
[07:25:03] ================ xe_live_mocs_kernel_kunit  ================
[07:25:03] =========== [SKIPPED] xe_live_mocs_kernel_kunit ============
[07:25:03] ================ xe_live_mocs_reset_kunit  =================
[07:25:03] ============ [SKIPPED] xe_live_mocs_reset_kunit ============
[07:25:03] ==================== [SKIPPED] xe_mocs =====================
[07:25:03] ================= xe_migrate (2 subtests) ==================
[07:25:03] ================= xe_migrate_sanity_kunit  =================
[07:25:03] ============ [SKIPPED] xe_migrate_sanity_kunit =============
[07:25:03] ================== xe_validate_ccs_kunit  ==================
[07:25:03] ============= [SKIPPED] xe_validate_ccs_kunit ==============
[07:25:03] =================== [SKIPPED] xe_migrate ===================
[07:25:03] ================== xe_dma_buf (1 subtest) ==================
[07:25:03] ==================== xe_dma_buf_kunit  =====================
[07:25:03] ================ [SKIPPED] xe_dma_buf_kunit ================
[07:25:03] =================== [SKIPPED] xe_dma_buf ===================
[07:25:03] ================= xe_bo_shrink (1 subtest) =================
[07:25:03] =================== xe_bo_shrink_kunit  ====================
[07:25:03] =============== [SKIPPED] xe_bo_shrink_kunit ===============
[07:25:03] ================== [SKIPPED] xe_bo_shrink ==================
[07:25:03] ==================== xe_bo (2 subtests) ====================
[07:25:03] ================== xe_ccs_migrate_kunit  ===================
[07:25:03] ============== [SKIPPED] xe_ccs_migrate_kunit ==============
stty: 'standard input': Inappropriate ioctl for device
[07:25:03] ==================== xe_bo_evict_kunit  ====================
[07:25:03] =============== [SKIPPED] xe_bo_evict_kunit ================
[07:25:03] ===================== [SKIPPED] xe_bo ======================
[07:25:03] ==================== args (11 subtests) ====================
[07:25:03] [PASSED] count_args_test
[07:25:03] [PASSED] call_args_example
[07:25:03] [PASSED] call_args_test
[07:25:03] [PASSED] drop_first_arg_example
[07:25:03] [PASSED] drop_first_arg_test
[07:25:03] [PASSED] first_arg_example
[07:25:03] [PASSED] first_arg_test
[07:25:03] [PASSED] last_arg_example
[07:25:03] [PASSED] last_arg_test
[07:25:03] [PASSED] pick_arg_example
[07:25:03] [PASSED] sep_comma_example
[07:25:03] ====================== [PASSED] args =======================
[07:25:03] =================== xe_pci (2 subtests) ====================
[07:25:03] [PASSED] xe_gmdid_graphics_ip
[07:25:03] [PASSED] xe_gmdid_media_ip
[07:25:03] ===================== [PASSED] xe_pci ======================
[07:25:03] =================== xe_rtp (2 subtests) ====================
[07:25:03] =============== xe_rtp_process_to_sr_tests  ================
[07:25:03] [PASSED] coalesce-same-reg
[07:25:03] [PASSED] no-match-no-add
[07:25:03] [PASSED] match-or
[07:25:03] [PASSED] match-or-xfail
[07:25:03] [PASSED] no-match-no-add-multiple-rules
[07:25:03] [PASSED] two-regs-two-entries
[07:25:03] [PASSED] clr-one-set-other
[07:25:03] [PASSED] set-field
[07:25:03] [PASSED] conflict-duplicate
[07:25:03] [PASSED] conflict-not-disjoint
[07:25:03] [PASSED] conflict-reg-type
[07:25:03] =========== [PASSED] xe_rtp_process_to_sr_tests ============
[07:25:03] ================== xe_rtp_process_tests  ===================
[07:25:03] [PASSED] active1
[07:25:03] [PASSED] active2
[07:25:03] [PASSED] active-inactive
[07:25:03] [PASSED] inactive-active
[07:25:03] [PASSED] inactive-1st_or_active-inactive
[07:25:03] [PASSED] inactive-2nd_or_active-inactive
[07:25:03] [PASSED] inactive-last_or_active-inactive
[07:25:03] [PASSED] inactive-no_or_active-inactive
[07:25:03] ============== [PASSED] xe_rtp_process_tests ===============
[07:25:03] ===================== [PASSED] xe_rtp ======================
[07:25:03] ==================== xe_wa (1 subtest) =====================
[07:25:03] ======================== xe_wa_gt  =========================
[07:25:03] [PASSED] TIGERLAKE (B0)
[07:25:03] [PASSED] DG1 (A0)
[07:25:03] [PASSED] DG1 (B0)
[07:25:03] [PASSED] ALDERLAKE_S (A0)
[07:25:03] [PASSED] ALDERLAKE_S (B0)
[07:25:03] [PASSED] ALDERLAKE_S (C0)
[07:25:03] [PASSED] ALDERLAKE_S (D0)
[07:25:03] [PASSED] ALDERLAKE_P (A0)
[07:25:03] [PASSED] ALDERLAKE_P (B0)
[07:25:03] [PASSED] ALDERLAKE_P (C0)
[07:25:03] [PASSED] ALDERLAKE_S_RPLS (D0)
[07:25:03] [PASSED] ALDERLAKE_P_RPLU (E0)
[07:25:03] [PASSED] DG2_G10 (C0)
[07:25:03] [PASSED] DG2_G11 (B1)
[07:25:03] [PASSED] DG2_G12 (A1)
[07:25:03] [PASSED] METEORLAKE (g:A0, m:A0)
[07:25:03] [PASSED] METEORLAKE (g:A0, m:A0)
[07:25:03] [PASSED] METEORLAKE (g:A0, m:A0)
[07:25:03] [PASSED] LUNARLAKE (g:A0, m:A0)
[07:25:03] [PASSED] LUNARLAKE (g:B0, m:A0)
[07:25:03] [PASSED] BATTLEMAGE (g:A0, m:A1)
[07:25:03] ==================== [PASSED] xe_wa_gt =====================
[07:25:03] ====================== [PASSED] xe_wa ======================
[07:25:03] ============================================================
[07:25:03] Testing complete. Ran 133 tests: passed: 117, skipped: 16
[07:25:03] Elapsed time: 30.463s total, 4.195s configuring, 26.002s building, 0.248s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/tests/.kunitconfig
[07:25:03] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[07:25:05] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json ARCH=um O=.kunit --jobs=48
../lib/iomap.c:156:5: warning: no previous prototype for ‘ioread64_lo_hi’ [-Wmissing-prototypes]
  156 | u64 ioread64_lo_hi(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~
../lib/iomap.c:163:5: warning: no previous prototype for ‘ioread64_hi_lo’ [-Wmissing-prototypes]
  163 | u64 ioread64_hi_lo(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~
../lib/iomap.c:170:5: warning: no previous prototype for ‘ioread64be_lo_hi’ [-Wmissing-prototypes]
  170 | u64 ioread64be_lo_hi(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~~~
../lib/iomap.c:178:5: warning: no previous prototype for ‘ioread64be_hi_lo’ [-Wmissing-prototypes]
  178 | u64 ioread64be_hi_lo(const void __iomem *addr)
      |     ^~~~~~~~~~~~~~~~
../lib/iomap.c:264:6: warning: no previous prototype for ‘iowrite64_lo_hi’ [-Wmissing-prototypes]
  264 | void iowrite64_lo_hi(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~
../lib/iomap.c:272:6: warning: no previous prototype for ‘iowrite64_hi_lo’ [-Wmissing-prototypes]
  272 | void iowrite64_hi_lo(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~
../lib/iomap.c:280:6: warning: no previous prototype for ‘iowrite64be_lo_hi’ [-Wmissing-prototypes]
  280 | void iowrite64be_lo_hi(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~~~
../lib/iomap.c:288:6: warning: no previous prototype for ‘iowrite64be_hi_lo’ [-Wmissing-prototypes]
  288 | void iowrite64be_hi_lo(u64 val, void __iomem *addr)
      |      ^~~~~~~~~~~~~~~~~

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

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

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

✓ CI.Build: success for Add support for EU stall sampling (rev2)

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling (rev2)
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/events/amd/
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/events/amd/amd-uncore.ko
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/events/rapl.ko
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/kvm/
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/kvm/kvm.ko
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/kvm/kvm-intel.ko
lib/modules/6.14.0-rc2-xe+/kernel/arch/x86/kvm/kvm-amd.ko
lib/modules/6.14.0-rc2-xe+/kernel/kernel/
lib/modules/6.14.0-rc2-xe+/kernel/kernel/kheaders.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/
lib/modules/6.14.0-rc2-xe+/kernel/crypto/ecrdsa_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/xcbc.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/serpent_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/aria_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/crypto_simd.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/adiantum.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/tcrypt.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/crypto_engine.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/zstd.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/asymmetric_keys/
lib/modules/6.14.0-rc2-xe+/kernel/crypto/asymmetric_keys/pkcs7_test_key.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/asymmetric_keys/pkcs8_key_parser.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/des_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/xctr.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/authenc.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/sm4_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/camellia_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/sm3.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/pcrypt.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/aegis128.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/af_alg.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/algif_aead.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cmac.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/sm3_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/aes_ti.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/chacha_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/poly1305_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/nhpoly1305.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/crc32_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/essiv.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/ccm.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/wp512.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/streebog_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/authencesn.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/echainiv.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/lrw.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cryptd.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/crypto_user.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/algif_hash.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/polyval-generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/hctr2.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/842.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/pcbc.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/ansi_cprng.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cast6_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/twofish_common.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/twofish_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/lz4hc.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/blowfish_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/md4.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/chacha20poly1305.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/curve25519-generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/lz4.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/rmd160.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/algif_skcipher.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cast5_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/fcrypt.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/ecdsa_generic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/sm4.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/cast_common.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/blowfish_common.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/michael_mic.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_xor.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_tx.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_memcpy.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_pq.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/async_tx/async_raid6_recov.ko
lib/modules/6.14.0-rc2-xe+/kernel/crypto/algif_rng.ko
lib/modules/6.14.0-rc2-xe+/kernel/block/
lib/modules/6.14.0-rc2-xe+/kernel/block/bfq.ko
lib/modules/6.14.0-rc2-xe+/kernel/block/kyber-iosched.ko
lib/modules/6.14.0-rc2-xe+/build
lib/modules/6.14.0-rc2-xe+/modules.alias.bin
lib/modules/6.14.0-rc2-xe+/modules.builtin
lib/modules/6.14.0-rc2-xe+/modules.softdep
lib/modules/6.14.0-rc2-xe+/modules.alias
lib/modules/6.14.0-rc2-xe+/modules.order
lib/modules/6.14.0-rc2-xe+/modules.symbols
lib/modules/6.14.0-rc2-xe+/modules.dep.bin
+ mv kernel-nodebug.tar.gz ..
+ cd ..
+ rm -rf archive
++ date +%s
+ echo -e '\e[0Ksection_end:1739259717:package_x86_64_nodebug\r\e[0K'
+ sync
^[[0Ksection_end:1739259717:package_x86_64_nodebug
^[[0K
+ cleanup
++ stat -c %u:%g /kernel
+ chown -R 1003:1003 /kernel

✗ CI.Hooks: failure for Add support for EU stall sampling (rev2)

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling (rev2)
URL   : https://patchwork.freedesktop.org/series/144609/
State : failure

== Summary ==

run-parts: executing /workspace/ci/hooks/00-showenv
+ export
+ grep -Ei '(^|\W)CI_'
declare -x CI_KERNEL_BUILD_DIR="/workspace/kernel/build64-default"
declare -x CI_KERNEL_SRC_DIR="/workspace/kernel"
declare -x CI_TOOLS_SRC_DIR="/workspace/ci"
declare -x CI_WORKSPACE_DIR="/workspace"
run-parts: executing /workspace/ci/hooks/10-build-W1
+ SRC_DIR=/workspace/kernel
+ RESTORE_DISPLAY_CONFIG=0
+ '[' -n /workspace/kernel/build64-default ']'
+ BUILD_DIR=/workspace/kernel/build64-default
+ cd /workspace/kernel
++ nproc
+ make -j48 O=/workspace/kernel/build64-default modules_prepare
make[1]: Entering directory '/workspace/kernel/build64-default'
  GEN     Makefile
mkdir -p /workspace/kernel/build64-default/tools/objtool && make O=/workspace/kernel/build64-default subdir=tools/objtool --no-print-directory -C objtool 
  CALL    ../scripts/checksyscalls.sh
  INSTALL libsubcmd_headers
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/exec-cmd.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/help.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/pager.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/parse-options.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/run-command.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/sigchain.o
  CC      /workspace/kernel/build64-default/tools/objtool/libsubcmd/subcmd-config.o
  LD      /workspace/kernel/build64-default/tools/objtool/libsubcmd/libsubcmd-in.o
  AR      /workspace/kernel/build64-default/tools/objtool/libsubcmd/libsubcmd.a
  CC      /workspace/kernel/build64-default/tools/objtool/weak.o
  CC      /workspace/kernel/build64-default/tools/objtool/check.o
  CC      /workspace/kernel/build64-default/tools/objtool/special.o
  CC      /workspace/kernel/build64-default/tools/objtool/builtin-check.o
  CC      /workspace/kernel/build64-default/tools/objtool/elf.o
  CC      /workspace/kernel/build64-default/tools/objtool/orc_gen.o
  CC      /workspace/kernel/build64-default/tools/objtool/objtool.o
  CC      /workspace/kernel/build64-default/tools/objtool/orc_dump.o
  CC      /workspace/kernel/build64-default/tools/objtool/libstring.o
  CC      /workspace/kernel/build64-default/tools/objtool/arch/x86/special.o
  CC      /workspace/kernel/build64-default/tools/objtool/libctype.o
  CC      /workspace/kernel/build64-default/tools/objtool/str_error_r.o
  CC      /workspace/kernel/build64-default/tools/objtool/librbtree.o
  CC      /workspace/kernel/build64-default/tools/objtool/arch/x86/decode.o
  CC      /workspace/kernel/build64-default/tools/objtool/arch/x86/orc.o
  LD      /workspace/kernel/build64-default/tools/objtool/arch/x86/objtool-in.o
  LD      /workspace/kernel/build64-default/tools/objtool/objtool-in.o
  LINK    /workspace/kernel/build64-default/tools/objtool/objtool
make[1]: Leaving directory '/workspace/kernel/build64-default'
++ nproc
+ make -j48 O=/workspace/kernel/build64-default W=1 drivers/gpu/drm/xe
make[1]: Entering directory '/workspace/kernel/build64-default'
make[2]: Nothing to be done for 'drivers/gpu/drm/xe'.
make[1]: Leaving directory '/workspace/kernel/build64-default'
run-parts: executing /workspace/ci/hooks/11-build-32b
+++ realpath /workspace/ci/hooks/11-build-32b
++ dirname /workspace/ci/hooks/11-build-32b
+ THIS_SCRIPT_DIR=/workspace/ci/hooks
+ SRC_DIR=/workspace/kernel
+ TOOLS_SRC_DIR=/workspace/ci
+ '[' -n /workspace/kernel/build64-default ']'
+ BUILD_DIR=/workspace/kernel/build64-default
+ BUILD_DIR=/workspace/kernel/build64-default/build32
+ cd /workspace/kernel
+ mkdir -p /workspace/kernel/build64-default/build32
++ nproc
+ make -j48 ARCH=i386 O=/workspace/kernel/build64-default/build32 defconfig
make[1]: Entering directory '/workspace/kernel/build64-default/build32'
  GEN     Makefile
  HOSTCC  scripts/basic/fixdep
  HOSTCC  scripts/kconfig/conf.o
  HOSTCC  scripts/kconfig/confdata.o
  HOSTCC  scripts/kconfig/expr.o
  LEX     scripts/kconfig/lexer.lex.c
  HOSTCC  scripts/kconfig/menu.o
  YACC    scripts/kconfig/parser.tab.[ch]
  HOSTCC  scripts/kconfig/preprocess.o
  HOSTCC  scripts/kconfig/symbol.o
  HOSTCC  scripts/kconfig/util.o
  HOSTCC  scripts/kconfig/lexer.lex.o
  HOSTCC  scripts/kconfig/parser.tab.o
  HOSTLD  scripts/kconfig/conf
*** Default configuration is based on 'i386_defconfig'
#
# configuration written to .config
#
make[1]: Leaving directory '/workspace/kernel/build64-default/build32'
+ cd /workspace/kernel/build64-default/build32
+ /workspace/kernel/scripts/kconfig/merge_config.sh .config /workspace/ci/kernel/fragments/10-xe.fragment
Using .config as base
Merging /workspace/ci/kernel/fragments/10-xe.fragment
Value of CONFIG_DRM_XE is redefined by fragment /workspace/ci/kernel/fragments/10-xe.fragment:
Previous value: # CONFIG_DRM_XE is not set
New value: CONFIG_DRM_XE=m

  GEN     Makefile

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]
#
# configuration written to .config
#
Value requested for CONFIG_HAVE_UID16 not in final .config
Requested value:  CONFIG_HAVE_UID16=y
Actual value:     

Value requested for CONFIG_UID16 not in final .config
Requested value:  CONFIG_UID16=y
Actual value:     

Value requested for CONFIG_X86_32 not in final .config
Requested value:  CONFIG_X86_32=y
Actual value:     

Value requested for CONFIG_OUTPUT_FORMAT not in final .config
Requested value:  CONFIG_OUTPUT_FORMAT="elf32-i386"
Actual value:     CONFIG_OUTPUT_FORMAT="elf64-x86-64"

Value requested for CONFIG_ARCH_MMAP_RND_BITS_MIN not in final .config
Requested value:  CONFIG_ARCH_MMAP_RND_BITS_MIN=8
Actual value:     CONFIG_ARCH_MMAP_RND_BITS_MIN=28

Value requested for CONFIG_ARCH_MMAP_RND_BITS_MAX not in final .config
Requested value:  CONFIG_ARCH_MMAP_RND_BITS_MAX=16
Actual value:     CONFIG_ARCH_MMAP_RND_BITS_MAX=32

Value requested for CONFIG_PGTABLE_LEVELS not in final .config
Requested value:  CONFIG_PGTABLE_LEVELS=2
Actual value:     CONFIG_PGTABLE_LEVELS=5

Value requested for CONFIG_X86_BIGSMP not in final .config
Requested value:  # CONFIG_X86_BIGSMP is not set
Actual value:     

Value requested for CONFIG_X86_INTEL_QUARK not in final .config
Requested value:  # CONFIG_X86_INTEL_QUARK is not set
Actual value:     

Value requested for CONFIG_X86_RDC321X not in final .config
Requested value:  # CONFIG_X86_RDC321X is not set
Actual value:     

Value requested for CONFIG_X86_32_NON_STANDARD not in final .config
Requested value:  # CONFIG_X86_32_NON_STANDARD is not set
Actual value:     

Value requested for CONFIG_X86_32_IRIS not in final .config
Requested value:  # CONFIG_X86_32_IRIS is not set
Actual value:     

Value requested for CONFIG_M486SX not in final .config
Requested value:  # CONFIG_M486SX is not set
Actual value:     

Value requested for CONFIG_M486 not in final .config
Requested value:  # CONFIG_M486 is not set
Actual value:     

Value requested for CONFIG_M586 not in final .config
Requested value:  # CONFIG_M586 is not set
Actual value:     

Value requested for CONFIG_M586TSC not in final .config
Requested value:  # CONFIG_M586TSC is not set
Actual value:     

Value requested for CONFIG_M586MMX not in final .config
Requested value:  # CONFIG_M586MMX is not set
Actual value:     

Value requested for CONFIG_M686 not in final .config
Requested value:  CONFIG_M686=y
Actual value:     

Value requested for CONFIG_MPENTIUMII not in final .config
Requested value:  # CONFIG_MPENTIUMII is not set
Actual value:     

Value requested for CONFIG_MPENTIUMIII not in final .config
Requested value:  # CONFIG_MPENTIUMIII is not set
Actual value:     

Value requested for CONFIG_MPENTIUMM not in final .config
Requested value:  # CONFIG_MPENTIUMM is not set
Actual value:     

Value requested for CONFIG_MPENTIUM4 not in final .config
Requested value:  # CONFIG_MPENTIUM4 is not set
Actual value:     

Value requested for CONFIG_MK6 not in final .config
Requested value:  # CONFIG_MK6 is not set
Actual value:     

Value requested for CONFIG_MK7 not in final .config
Requested value:  # CONFIG_MK7 is not set
Actual value:     

Value requested for CONFIG_MCRUSOE not in final .config
Requested value:  # CONFIG_MCRUSOE is not set
Actual value:     

Value requested for CONFIG_MEFFICEON not in final .config
Requested value:  # CONFIG_MEFFICEON is not set
Actual value:     

Value requested for CONFIG_MWINCHIPC6 not in final .config
Requested value:  # CONFIG_MWINCHIPC6 is not set
Actual value:     

Value requested for CONFIG_MWINCHIP3D not in final .config
Requested value:  # CONFIG_MWINCHIP3D is not set
Actual value:     

Value requested for CONFIG_MELAN not in final .config
Requested value:  # CONFIG_MELAN is not set
Actual value:     

Value requested for CONFIG_MGEODEGX1 not in final .config
Requested value:  # CONFIG_MGEODEGX1 is not set
Actual value:     

Value requested for CONFIG_MGEODE_LX not in final .config
Requested value:  # CONFIG_MGEODE_LX is not set
Actual value:     

Value requested for CONFIG_MCYRIXIII not in final .config
Requested value:  # CONFIG_MCYRIXIII is not set
Actual value:     

Value requested for CONFIG_MVIAC3_2 not in final .config
Requested value:  # CONFIG_MVIAC3_2 is not set
Actual value:     

Value requested for CONFIG_MVIAC7 not in final .config
Requested value:  # CONFIG_MVIAC7 is not set
Actual value:     

Value requested for CONFIG_X86_GENERIC not in final .config
Requested value:  # CONFIG_X86_GENERIC is not set
Actual value:     

Value requested for CONFIG_X86_INTERNODE_CACHE_SHIFT not in final .config
Requested value:  CONFIG_X86_INTERNODE_CACHE_SHIFT=5
Actual value:     CONFIG_X86_INTERNODE_CACHE_SHIFT=6

Value requested for CONFIG_X86_L1_CACHE_SHIFT not in final .config
Requested value:  CONFIG_X86_L1_CACHE_SHIFT=5
Actual value:     CONFIG_X86_L1_CACHE_SHIFT=6

Value requested for CONFIG_X86_USE_PPRO_CHECKSUM not in final .config
Requested value:  CONFIG_X86_USE_PPRO_CHECKSUM=y
Actual value:     

Value requested for CONFIG_X86_MINIMUM_CPU_FAMILY not in final .config
Requested value:  CONFIG_X86_MINIMUM_CPU_FAMILY=6
Actual value:     CONFIG_X86_MINIMUM_CPU_FAMILY=64

Value requested for CONFIG_CPU_SUP_TRANSMETA_32 not in final .config
Requested value:  CONFIG_CPU_SUP_TRANSMETA_32=y
Actual value:     

Value requested for CONFIG_CPU_SUP_VORTEX_32 not in final .config
Requested value:  CONFIG_CPU_SUP_VORTEX_32=y
Actual value:     

Value requested for CONFIG_HPET_TIMER not in final .config
Requested value:  # CONFIG_HPET_TIMER is not set
Actual value:     CONFIG_HPET_TIMER=y

Value requested for CONFIG_NR_CPUS_RANGE_END not in final .config
Requested value:  CONFIG_NR_CPUS_RANGE_END=8
Actual value:     CONFIG_NR_CPUS_RANGE_END=512

Value requested for CONFIG_NR_CPUS_DEFAULT not in final .config
Requested value:  CONFIG_NR_CPUS_DEFAULT=8
Actual value:     CONFIG_NR_CPUS_DEFAULT=64

Value requested for CONFIG_X86_ANCIENT_MCE not in final .config
Requested value:  # CONFIG_X86_ANCIENT_MCE is not set
Actual value:     

Value requested for CONFIG_X86_LEGACY_VM86 not in final .config
Requested value:  # CONFIG_X86_LEGACY_VM86 is not set
Actual value:     

Value requested for CONFIG_X86_ESPFIX32 not in final .config
Requested value:  CONFIG_X86_ESPFIX32=y
Actual value:     

Value requested for CONFIG_TOSHIBA not in final .config
Requested value:  # CONFIG_TOSHIBA is not set
Actual value:     

Value requested for CONFIG_X86_REBOOTFIXUPS not in final .config
Requested value:  # CONFIG_X86_REBOOTFIXUPS is not set
Actual value:     

Value requested for CONFIG_MICROCODE_INITRD32 not in final .config
Requested value:  CONFIG_MICROCODE_INITRD32=y
Actual value:     

Value requested for CONFIG_NOHIGHMEM not in final .config
Requested value:  # CONFIG_NOHIGHMEM is not set
Actual value:     

Value requested for CONFIG_HIGHMEM4G not in final .config
Requested value:  CONFIG_HIGHMEM4G=y
Actual value:     

Value requested for CONFIG_HIGHMEM64G not in final .config
Requested value:  # CONFIG_HIGHMEM64G is not set
Actual value:     

Value requested for CONFIG_VMSPLIT_3G not in final .config
Requested value:  CONFIG_VMSPLIT_3G=y
Actual value:     

Value requested for CONFIG_VMSPLIT_3G_OPT not in final .config
Requested value:  # CONFIG_VMSPLIT_3G_OPT is not set
Actual value:     

Value requested for CONFIG_VMSPLIT_2G not in final .config
Requested value:  # CONFIG_VMSPLIT_2G is not set
Actual value:     

Value requested for CONFIG_VMSPLIT_2G_OPT not in final .config
Requested value:  # CONFIG_VMSPLIT_2G_OPT is not set
Actual value:     

Value requested for CONFIG_VMSPLIT_1G not in final .config
Requested value:  # CONFIG_VMSPLIT_1G is not set
Actual value:     

Value requested for CONFIG_PAGE_OFFSET not in final .config
Requested value:  CONFIG_PAGE_OFFSET=0xC0000000
Actual value:     

Value requested for CONFIG_HIGHMEM not in final .config
Requested value:  CONFIG_HIGHMEM=y
Actual value:     

Value requested for CONFIG_X86_PAE not in final .config
Requested value:  # CONFIG_X86_PAE is not set
Actual value:     

Value requested for CONFIG_ARCH_FLATMEM_ENABLE not in final .config
Requested value:  CONFIG_ARCH_FLATMEM_ENABLE=y
Actual value:     

Value requested for CONFIG_ARCH_SELECT_MEMORY_MODEL not in final .config
Requested value:  CONFIG_ARCH_SELECT_MEMORY_MODEL=y
Actual value:     

Value requested for CONFIG_ILLEGAL_POINTER_VALUE not in final .config
Requested value:  CONFIG_ILLEGAL_POINTER_VALUE=0
Actual value:     CONFIG_ILLEGAL_POINTER_VALUE=0xdead000000000000

Value requested for CONFIG_HIGHPTE not in final .config
Requested value:  # CONFIG_HIGHPTE is not set
Actual value:     

Value requested for CONFIG_COMPAT_VDSO not in final .config
Requested value:  # CONFIG_COMPAT_VDSO is not set
Actual value:     

Value requested for CONFIG_FUNCTION_PADDING_CFI not in final .config
Requested value:  CONFIG_FUNCTION_PADDING_CFI=0
Actual value:     CONFIG_FUNCTION_PADDING_CFI=11

Value requested for CONFIG_FUNCTION_PADDING_BYTES not in final .config
Requested value:  CONFIG_FUNCTION_PADDING_BYTES=4
Actual value:     CONFIG_FUNCTION_PADDING_BYTES=16

Value requested for CONFIG_APM not in final .config
Requested value:  # CONFIG_APM is not set
Actual value:     

Value requested for CONFIG_X86_POWERNOW_K6 not in final .config
Requested value:  # CONFIG_X86_POWERNOW_K6 is not set
Actual value:     

Value requested for CONFIG_X86_POWERNOW_K7 not in final .config
Requested value:  # CONFIG_X86_POWERNOW_K7 is not set
Actual value:     

Value requested for CONFIG_X86_GX_SUSPMOD not in final .config
Requested value:  # CONFIG_X86_GX_SUSPMOD is not set
Actual value:     

Value requested for CONFIG_X86_SPEEDSTEP_ICH not in final .config
Requested value:  # CONFIG_X86_SPEEDSTEP_ICH is not set
Actual value:     

Value requested for CONFIG_X86_SPEEDSTEP_SMI not in final .config
Requested value:  # CONFIG_X86_SPEEDSTEP_SMI is not set
Actual value:     

Value requested for CONFIG_X86_CPUFREQ_NFORCE2 not in final .config
Requested value:  # CONFIG_X86_CPUFREQ_NFORCE2 is not set
Actual value:     

Value requested for CONFIG_X86_LONGRUN not in final .config
Requested value:  # CONFIG_X86_LONGRUN is not set
Actual value:     

Value requested for CONFIG_X86_LONGHAUL not in final .config
Requested value:  # CONFIG_X86_LONGHAUL is not set
Actual value:     

Value requested for CONFIG_X86_E_POWERSAVER not in final .config
Requested value:  # CONFIG_X86_E_POWERSAVER is not set
Actual value:     

Value requested for CONFIG_PCI_GOBIOS not in final .config
Requested value:  # CONFIG_PCI_GOBIOS is not set
Actual value:     

Value requested for CONFIG_PCI_GOMMCONFIG not in final .config
Requested value:  # CONFIG_PCI_GOMMCONFIG is not set
Actual value:     

Value requested for CONFIG_PCI_GODIRECT not in final .config
Requested value:  # CONFIG_PCI_GODIRECT is not set
Actual value:     

Value requested for CONFIG_PCI_GOANY not in final .config
Requested value:  CONFIG_PCI_GOANY=y
Actual value:     

Value requested for CONFIG_PCI_BIOS not in final .config
Requested value:  CONFIG_PCI_BIOS=y
Actual value:     

Value requested for CONFIG_ISA not in final .config
Requested value:  # CONFIG_ISA is not set
Actual value:     

Value requested for CONFIG_SCx200 not in final .config
Requested value:  # CONFIG_SCx200 is not set
Actual value:     

Value requested for CONFIG_OLPC not in final .config
Requested value:  # CONFIG_OLPC is not set
Actual value:     

Value requested for CONFIG_ALIX not in final .config
Requested value:  # CONFIG_ALIX is not set
Actual value:     

Value requested for CONFIG_NET5501 not in final .config
Requested value:  # CONFIG_NET5501 is not set
Actual value:     

Value requested for CONFIG_GEOS not in final .config
Requested value:  # CONFIG_GEOS is not set
Actual value:     

Value requested for CONFIG_COMPAT_32 not in final .config
Requested value:  CONFIG_COMPAT_32=y
Actual value:     

Value requested for CONFIG_HAVE_ATOMIC_IOMAP not in final .config
Requested value:  CONFIG_HAVE_ATOMIC_IOMAP=y
Actual value:     

Value requested for CONFIG_ARCH_32BIT_OFF_T not in final .config
Requested value:  CONFIG_ARCH_32BIT_OFF_T=y
Actual value:     

Value requested for CONFIG_ARCH_WANT_IPC_PARSE_VERSION not in final .config
Requested value:  CONFIG_ARCH_WANT_IPC_PARSE_VERSION=y
Actual value:     

Value requested for CONFIG_MODULES_USE_ELF_REL not in final .config
Requested value:  CONFIG_MODULES_USE_ELF_REL=y
Actual value:     

Value requested for CONFIG_ARCH_MMAP_RND_BITS not in final .config
Requested value:  CONFIG_ARCH_MMAP_RND_BITS=8
Actual value:     CONFIG_ARCH_MMAP_RND_BITS=28

Value requested for CONFIG_CLONE_BACKWARDS not in final .config
Requested value:  CONFIG_CLONE_BACKWARDS=y
Actual value:     

Value requested for CONFIG_OLD_SIGSUSPEND3 not in final .config
Requested value:  CONFIG_OLD_SIGSUSPEND3=y
Actual value:     

Value requested for CONFIG_OLD_SIGACTION not in final .config
Requested value:  CONFIG_OLD_SIGACTION=y
Actual value:     

Value requested for CONFIG_ARCH_SPLIT_ARG64 not in final .config
Requested value:  CONFIG_ARCH_SPLIT_ARG64=y
Actual value:     

Value requested for CONFIG_FUNCTION_ALIGNMENT not in final .config
Requested value:  CONFIG_FUNCTION_ALIGNMENT=4
Actual value:     CONFIG_FUNCTION_ALIGNMENT=16

Value requested for CONFIG_SELECT_MEMORY_MODEL not in final .config
Requested value:  CONFIG_SELECT_MEMORY_MODEL=y
Actual value:     

Value requested for CONFIG_FLATMEM_MANUAL not in final .config
Requested value:  CONFIG_FLATMEM_MANUAL=y
Actual value:     

Value requested for CONFIG_SPARSEMEM_MANUAL not in final .config
Requested value:  # CONFIG_SPARSEMEM_MANUAL is not set
Actual value:     

Value requested for CONFIG_FLATMEM not in final .config
Requested value:  CONFIG_FLATMEM=y
Actual value:     

Value requested for CONFIG_SPARSEMEM_STATIC not in final .config
Requested value:  CONFIG_SPARSEMEM_STATIC=y
Actual value:     

Value requested for CONFIG_BOUNCE not in final .config
Requested value:  CONFIG_BOUNCE=y
Actual value:     

Value requested for CONFIG_KMAP_LOCAL not in final .config
Requested value:  CONFIG_KMAP_LOCAL=y
Actual value:     

Value requested for CONFIG_HOTPLUG_PCI_COMPAQ not in final .config
Requested value:  # CONFIG_HOTPLUG_PCI_COMPAQ is not set
Actual value:     

Value requested for CONFIG_HOTPLUG_PCI_IBM not in final .config
Requested value:  # CONFIG_HOTPLUG_PCI_IBM is not set
Actual value:     

Value requested for CONFIG_EFI_CAPSULE_QUIRK_QUARK_CSH not in final .config
Requested value:  CONFIG_EFI_CAPSULE_QUIRK_QUARK_CSH=y
Actual value:     

Value requested for CONFIG_PCH_PHUB not in final .config
Requested value:  # CONFIG_PCH_PHUB is not set
Actual value:     

Value requested for CONFIG_SCSI_NSP32 not in final .config
Requested value:  # CONFIG_SCSI_NSP32 is not set
Actual value:     

Value requested for CONFIG_PATA_CS5520 not in final .config
Requested value:  # CONFIG_PATA_CS5520 is not set
Actual value:     

Value requested for CONFIG_PATA_CS5530 not in final .config
Requested value:  # CONFIG_PATA_CS5530 is not set
Actual value:     

Value requested for CONFIG_PATA_CS5535 not in final .config
Requested value:  # CONFIG_PATA_CS5535 is not set
Actual value:     

Value requested for CONFIG_PATA_CS5536 not in final .config
Requested value:  # CONFIG_PATA_CS5536 is not set
Actual value:     

Value requested for CONFIG_PATA_SC1200 not in final .config
Requested value:  # CONFIG_PATA_SC1200 is not set
Actual value:     

Value requested for CONFIG_PCH_GBE not in final .config
Requested value:  # CONFIG_PCH_GBE is not set
Actual value:     

Value requested for CONFIG_INPUT_WISTRON_BTNS not in final .config
Requested value:  # CONFIG_INPUT_WISTRON_BTNS is not set
Actual value:     

Value requested for CONFIG_SERIAL_TIMBERDALE not in final .config
Requested value:  # CONFIG_SERIAL_TIMBERDALE is not set
Actual value:     

Value requested for CONFIG_SERIAL_PCH_UART not in final .config
Requested value:  # CONFIG_SERIAL_PCH_UART is not set
Actual value:     

Value requested for CONFIG_HW_RANDOM_GEODE not in final .config
Requested value:  CONFIG_HW_RANDOM_GEODE=y
Actual value:     

Value requested for CONFIG_SONYPI not in final .config
Requested value:  # CONFIG_SONYPI is not set
Actual value:     

Value requested for CONFIG_PC8736x_GPIO not in final .config
Requested value:  # CONFIG_PC8736x_GPIO is not set
Actual value:     

Value requested for CONFIG_NSC_GPIO not in final .config
Requested value:  # CONFIG_NSC_GPIO is not set
Actual value:     

Value requested for CONFIG_I2C_EG20T not in final .config
Requested value:  # CONFIG_I2C_EG20T is not set
Actual value:     

Value requested for CONFIG_SCx200_ACB not in final .config
Requested value:  # CONFIG_SCx200_ACB is not set
Actual value:     

Value requested for CONFIG_PTP_1588_CLOCK_PCH not in final .config
Requested value:  # CONFIG_PTP_1588_CLOCK_PCH is not set
Actual value:     

Value requested for CONFIG_SBC8360_WDT not in final .config
Requested value:  # CONFIG_SBC8360_WDT is not set
Actual value:     

Value requested for CONFIG_SBC7240_WDT not in final .config
Requested value:  # CONFIG_SBC7240_WDT is not set
Actual value:     

Value requested for CONFIG_MFD_CS5535 not in final .config
Requested value:  # CONFIG_MFD_CS5535 is not set
Actual value:     

Value requested for CONFIG_AGP_ALI not in final .config
Requested value:  # CONFIG_AGP_ALI is not set
Actual value:     

Value requested for CONFIG_AGP_ATI not in final .config
Requested value:  # CONFIG_AGP_ATI is not set
Actual value:     

Value requested for CONFIG_AGP_AMD not in final .config
Requested value:  # CONFIG_AGP_AMD is not set
Actual value:     

Value requested for CONFIG_AGP_NVIDIA not in final .config
Requested value:  # CONFIG_AGP_NVIDIA is not set
Actual value:     

Value requested for CONFIG_AGP_SWORKS not in final .config
Requested value:  # CONFIG_AGP_SWORKS is not set
Actual value:     

Value requested for CONFIG_AGP_EFFICEON not in final .config
Requested value:  # CONFIG_AGP_EFFICEON is not set
Actual value:     

Value requested for CONFIG_SND_CS5530 not in final .config
Requested value:  # CONFIG_SND_CS5530 is not set
Actual value:     

Value requested for CONFIG_SND_CS5535AUDIO not in final .config
Requested value:  # CONFIG_SND_CS5535AUDIO is not set
Actual value:     

Value requested for CONFIG_SND_SIS7019 not in final .config
Requested value:  # CONFIG_SND_SIS7019 is not set
Actual value:     

Value requested for CONFIG_LEDS_OT200 not in final .config
Requested value:  # CONFIG_LEDS_OT200 is not set
Actual value:     

Value requested for CONFIG_PCH_DMA not in final .config
Requested value:  # CONFIG_PCH_DMA is not set
Actual value:     

Value requested for CONFIG_CLKSRC_I8253 not in final .config
Requested value:  CONFIG_CLKSRC_I8253=y
Actual value:     

Value requested for CONFIG_MAILBOX not in final .config
Requested value:  # CONFIG_MAILBOX is not set
Actual value:     CONFIG_MAILBOX=y

Value requested for CONFIG_CRYPTO_SERPENT_SSE2_586 not in final .config
Requested value:  # CONFIG_CRYPTO_SERPENT_SSE2_586 is not set
Actual value:     

Value requested for CONFIG_CRYPTO_TWOFISH_586 not in final .config
Requested value:  # CONFIG_CRYPTO_TWOFISH_586 is not set
Actual value:     

Value requested for CONFIG_CRYPTO_DEV_GEODE not in final .config
Requested value:  # CONFIG_CRYPTO_DEV_GEODE is not set
Actual value:     

Value requested for CONFIG_CRYPTO_DEV_HIFN_795X not in final .config
Requested value:  # CONFIG_CRYPTO_DEV_HIFN_795X is not set
Actual value:     

Value requested for CONFIG_CRYPTO_LIB_POLY1305_RSIZE not in final .config
Requested value:  CONFIG_CRYPTO_LIB_POLY1305_RSIZE=1
Actual value:     CONFIG_CRYPTO_LIB_POLY1305_RSIZE=11

Value requested for CONFIG_AUDIT_GENERIC not in final .config
Requested value:  CONFIG_AUDIT_GENERIC=y
Actual value:     

Value requested for CONFIG_GENERIC_VDSO_32 not in final .config
Requested value:  CONFIG_GENERIC_VDSO_32=y
Actual value:     

Value requested for CONFIG_DEBUG_KMAP_LOCAL not in final .config
Requested value:  # CONFIG_DEBUG_KMAP_LOCAL is not set
Actual value:     

Value requested for CONFIG_DEBUG_HIGHMEM not in final .config
Requested value:  # CONFIG_DEBUG_HIGHMEM is not set
Actual value:     

Value requested for CONFIG_HAVE_DEBUG_STACKOVERFLOW not in final .config
Requested value:  CONFIG_HAVE_DEBUG_STACKOVERFLOW=y
Actual value:     

Value requested for CONFIG_DEBUG_STACKOVERFLOW not in final .config
Requested value:  # CONFIG_DEBUG_STACKOVERFLOW is not set
Actual value:     

Value requested for CONFIG_HAVE_FUNCTION_GRAPH_TRACER not in final .config
Requested value:  CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
Actual value:     

Value requested for CONFIG_HAVE_FUNCTION_GRAPH_FREGS not in final .config
Requested value:  CONFIG_HAVE_FUNCTION_GRAPH_FREGS=y
Actual value:     

Value requested for CONFIG_HAVE_FTRACE_GRAPH_FUNC not in final .config
Requested value:  CONFIG_HAVE_FTRACE_GRAPH_FUNC=y
Actual value:     

Value requested for CONFIG_DRM_KUNIT_TEST not in final .config
Requested value:  CONFIG_DRM_KUNIT_TEST=m
Actual value:     

Value requested for CONFIG_DRM_XE_WERROR not in final .config
Requested value:  CONFIG_DRM_XE_WERROR=y
Actual value:     

Value requested for CONFIG_DRM_XE_DEBUG not in final .config
Requested value:  CONFIG_DRM_XE_DEBUG=y
Actual value:     

Value requested for CONFIG_DRM_XE_DEBUG_MEM not in final .config
Requested value:  CONFIG_DRM_XE_DEBUG_MEM=y
Actual value:     

Value requested for CONFIG_DRM_XE_KUNIT_TEST not in final .config
Requested value:  CONFIG_DRM_XE_KUNIT_TEST=m
Actual value:     

++ nproc
+ make -j48 ARCH=i386 olddefconfig
  GEN     Makefile

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]
#
# configuration written to .config
#
++ nproc
+ make -j48 ARCH=i386
  SYNC    include/config/auto.conf.cmd
  GEN     Makefile

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]

WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS
  Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n]
  Selected by [m]:
  - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=y] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y]
  GEN     Makefile
  WRAP    arch/x86/include/generated/uapi/asm/bpf_perf_event.h
  WRAP    arch/x86/include/generated/uapi/asm/errno.h
  WRAP    arch/x86/include/generated/uapi/asm/fcntl.h
  WRAP    arch/x86/include/generated/uapi/asm/ioctl.h
  SYSHDR  arch/x86/include/generated/uapi/asm/unistd_64.h
  UPD     include/generated/uapi/linux/version.h
  SYSHDR  arch/x86/include/generated/uapi/asm/unistd_32.h
  WRAP    arch/x86/include/generated/uapi/asm/ioctls.h
  SYSHDR  arch/x86/include/generated/uapi/asm/unistd_x32.h
  SYSTBL  arch/x86/include/generated/asm/syscalls_32.h
  WRAP    arch/x86/include/generated/uapi/asm/ipcbuf.h
  WRAP    arch/x86/include/generated/uapi/asm/param.h
  WRAP    arch/x86/include/generated/uapi/asm/poll.h
  WRAP    arch/x86/include/generated/uapi/asm/resource.h
  WRAP    arch/x86/include/generated/uapi/asm/socket.h
  WRAP    arch/x86/include/generated/uapi/asm/sockios.h
  WRAP    arch/x86/include/generated/uapi/asm/termbits.h
  WRAP    arch/x86/include/generated/uapi/asm/termios.h
  WRAP    arch/x86/include/generated/uapi/asm/types.h
  HOSTCC  arch/x86/tools/relocs_32.o
  HOSTCC  arch/x86/tools/relocs_64.o
  UPD     include/generated/compile.h
  HOSTCC  arch/x86/tools/relocs_common.o
  WRAP    arch/x86/include/generated/asm/early_ioremap.h
  WRAP    arch/x86/include/generated/asm/fprobe.h
  HOSTCC  scripts/kallsyms
  WRAP    arch/x86/include/generated/asm/mcs_spinlock.h
  HOSTCC  scripts/sorttable
  WRAP    arch/x86/include/generated/asm/mmzone.h
  HOSTCC  scripts/asn1_compiler
  WRAP    arch/x86/include/generated/asm/irq_regs.h
  WRAP    arch/x86/include/generated/asm/kmap_size.h
  WRAP    arch/x86/include/generated/asm/local64.h
  WRAP    arch/x86/include/generated/asm/mmiowb.h
  WRAP    arch/x86/include/generated/asm/module.lds.h
  WRAP    arch/x86/include/generated/asm/rwonce.h
  HOSTCC  scripts/selinux/mdp/mdp
  HOSTLD  arch/x86/tools/relocs
  UPD     include/config/kernel.release
  UPD     include/generated/utsrelease.h
  HOSTCC  scripts/mod/mk_elfconfig
  CC      scripts/mod/empty.o
  CC      scripts/mod/devicetable-offsets.s
  UPD     scripts/mod/devicetable-offsets.h
  MKELF   scripts/mod/elfconfig.h
  HOSTCC  scripts/mod/modpost.o
  HOSTCC  scripts/mod/file2alias.o
  HOSTCC  scripts/mod/sumversion.o
  HOSTCC  scripts/mod/symsearch.o
  HOSTLD  scripts/mod/modpost
  CC      kernel/bounds.s
  CHKSHA1 /workspace/kernel/include/linux/atomic/atomic-arch-fallback.h
  CHKSHA1 /workspace/kernel/include/linux/atomic/atomic-long.h
  CHKSHA1 /workspace/kernel/include/linux/atomic/atomic-instrumented.h
  UPD     include/generated/timeconst.h
  UPD     include/generated/bounds.h
  CC      arch/x86/kernel/asm-offsets.s
  UPD     include/generated/asm-offsets.h
  CALL    /workspace/kernel/scripts/checksyscalls.sh
  LDS     scripts/module.lds
  CC      init/main.o
  HOSTCC  usr/gen_init_cpio
  CC      init/do_mounts.o
  CC      init/do_mounts_initrd.o
  UPD     init/utsversion-tmp.h
  CC      init/initramfs.o
  CC      certs/system_keyring.o
  CC      init/calibrate.o
  CC      ipc/util.o
  CC      init/init_task.o
  CC      ipc/msgutil.o
  CC      security/commoncap.o
  CC      mm/filemap.o
  CC      arch/x86/realmode/init.o
  CC      block/bdev.o
  CC      ipc/msg.o
  CC      security/lsm_syscalls.o
  CC      io_uring/io_uring.o
  CC      block/fops.o
  CC      mm/mempool.o
  CC      init/version.o
  AR      arch/x86/crypto/built-in.a
  CC      arch/x86/video/video-common.o
  CC      ipc/sem.o
  CC      arch/x86/pci/i386.o
  AR      arch/x86/net/built-in.a
  HOSTCC  security/selinux/genheaders
  CC      security/keys/gc.o
  CC      arch/x86/power/cpu.o
  CC      block/partitions/core.o
  AR      virt/lib/built-in.a
  AS      arch/x86/lib/atomic64_cx8_32.o
  CC      security/integrity/iint.o
  CC      arch/x86/events/amd/core.o
  CC      arch/x86/events/intel/core.o
  CC      arch/x86/events/core.o
  AR      arch/x86/platform/atom/built-in.a
  CC      arch/x86/mm/pat/set_memory.o
  AS      arch/x86/realmode/rm/header.o
  CC      arch/x86/events/zhaoxin/core.o
  CC      arch/x86/virt/svm/cmdline.o
  AR      virt/built-in.a
  CC      net/core/sock.o
  CC      lib/math/div64.o
  AR      drivers/cache/built-in.a
  CC      arch/x86/kernel/fpu/init.o
  CC      fs/notify/dnotify/dnotify.o
  AR      arch/x86/entry/vsyscall/built-in.a
  CC      sound/core/seq/seq.o
  AR      arch/x86/platform/ce4100/built-in.a
  CC      arch/x86/entry/vdso/vma.o
  AS      arch/x86/lib/checksum_32.o
  CC      arch/x86/platform/efi/memmap.o
  CC      net/ethernet/eth.o
  AS      arch/x86/realmode/rm/trampoline_32.o
  AR      drivers/irqchip/built-in.a
  AR      net/802/built-in.a
  CC      kernel/sched/core.o
  CC      arch/x86/events/probe.o
  AR      drivers/bus/mhi/built-in.a
  AS      arch/x86/realmode/rm/stack.o
  CC      arch/x86/lib/cmdline.o
  AR      drivers/bus/built-in.a
  CC      crypto/asymmetric_keys/asymmetric_type.o
  AS      arch/x86/realmode/rm/reboot.o
  AR      drivers/pwm/built-in.a
  AS      arch/x86/realmode/rm/wakeup_asm.o
  AR      arch/x86/virt/svm/built-in.a
  AR      drivers/leds/trigger/built-in.a
  AR      arch/x86/virt/vmx/built-in.a
  AR      drivers/leds/blink/built-in.a
  CC      arch/x86/realmode/rm/wakemain.o
  AR      arch/x86/virt/built-in.a
  AR      drivers/leds/simple/built-in.a
  CC      ipc/shm.o
  CC      drivers/leds/led-core.o
  AS      arch/x86/lib/cmpxchg8b_emu.o
  CC      lib/math/gcd.o
  GEN     security/selinux/flask.h security/selinux/av_permissions.h
  CC      security/selinux/avc.o
  CC      arch/x86/lib/cpu.o
  CC      ipc/syscall.o
  CC      arch/x86/realmode/rm/video-mode.o
  CC      lib/math/lcm.o
  CC      ipc/ipc_sysctl.o
  CC      lib/math/int_log.o
  AS      arch/x86/realmode/rm/copy.o
  GEN     usr/initramfs_data.cpio
  COPY    usr/initramfs_inc_data
  AS      usr/initramfs_data.o
  AS      arch/x86/realmode/rm/bioscall.o
  HOSTCC  certs/extract-cert
  AR      usr/built-in.a
  CC      arch/x86/realmode/rm/regs.o
  CC      lib/math/int_pow.o
  CC      arch/x86/kernel/fpu/bugs.o
  CC      net/sched/sch_generic.o
  CC      net/netlink/af_netlink.o
  CC      arch/x86/realmode/rm/video-vga.o
  CC      lib/math/int_sqrt.o
  CC      arch/x86/kernel/fpu/core.o
  CC      lib/math/reciprocal_div.o
  CC      arch/x86/realmode/rm/video-vesa.o
  CC      sound/core/seq/seq_lock.o
  CC      arch/x86/lib/delay.o
  CC      lib/math/rational.o
  CC      arch/x86/realmode/rm/video-bios.o
  CC      net/netlink/genetlink.o
  AR      arch/x86/video/built-in.a
  CC      net/sched/sch_mq.o
  CERT    certs/x509_certificate_list
  CERT    certs/signing_key.x509
  AS      certs/system_certificates.o
  PASYMS  arch/x86/realmode/rm/pasyms.h
  AR      certs/built-in.a
  CC      security/integrity/integrity_audit.o
  CC      arch/x86/kernel/cpu/mce/core.o
  CC      arch/x86/kernel/acpi/boot.o
  LDS     arch/x86/realmode/rm/realmode.lds
  CC      crypto/api.o
  CC      sound/core/seq/seq_clientmgr.o
  CC      drivers/leds/led-class.o
  LD      arch/x86/realmode/rm/realmode.elf
  CC      crypto/asymmetric_keys/restrict.o
  CC      net/netlink/policy.o
  RELOCS  arch/x86/realmode/rm/realmode.relocs
  OBJCOPY arch/x86/realmode/rm/realmode.bin
  CC      arch/x86/pci/init.o
  AS      arch/x86/realmode/rmpiggy.o
  CC      security/keys/key.o
  CC      crypto/asymmetric_keys/signature.o
  AR      sound/i2c/other/built-in.a
  CC      arch/x86/entry/vdso/extable.o
  AR      fs/notify/dnotify/built-in.a
  AR      arch/x86/realmode/built-in.a
  AR      sound/i2c/built-in.a
  CC      arch/x86/platform/efi/quirks.o
  CC      fs/notify/inotify/inotify_fsnotify.o
  CC      security/min_addr.o
  AR      arch/x86/platform/geode/built-in.a
  CC      security/keys/keyring.o
  CC      arch/x86/power/hibernate_32.o
  AS      arch/x86/lib/getuser.o
  CC      block/partitions/msdos.o
  AR      arch/x86/events/zhaoxin/built-in.a
  GEN     arch/x86/lib/inat-tables.c
  CC      arch/x86/lib/insn-eval.o
  AR      sound/drivers/opl3/built-in.a
  AR      sound/drivers/opl4/built-in.a
  AR      sound/drivers/mpu401/built-in.a
  AR      lib/math/built-in.a
  CC      sound/core/seq/seq_memory.o
  AR      sound/drivers/vx/built-in.a
  AR      sound/drivers/pcsp/built-in.a
  CC      security/keys/keyctl.o
  AR      sound/drivers/built-in.a
  CC      lib/crypto/mpi/generic_mpih-lshift.o
  CC      sound/core/sound.o
  CC      security/keys/permission.o
  CC      security/selinux/hooks.o
  CC      security/selinux/selinuxfs.o
  CC      drivers/leds/led-triggers.o
  CC      crypto/asymmetric_keys/public_key.o
  CC      block/partitions/efi.o
  CC      arch/x86/events/amd/lbr.o
  CC      lib/crypto/mpi/generic_mpih-mul1.o
  CC      arch/x86/events/utils.o
  CC      sound/core/seq/seq_queue.o
  CC      fs/nfs_common/nfsacl.o
  CC      fs/notify/inotify/inotify_user.o
  AR      net/ethernet/built-in.a
  CC      arch/x86/mm/pat/memtype.o
  CC      security/selinux/netlink.o
  CC      arch/x86/pci/pcbios.o
  CC      arch/x86/pci/mmconfig_32.o
  AR      security/integrity/built-in.a
  CC      arch/x86/kernel/cpu/mce/severity.o
  AR      init/built-in.a
  LDS     arch/x86/entry/vdso/vdso32/vdso32.lds
  CC      arch/x86/events/intel/bts.o
  CC      block/bio.o
  AS      arch/x86/entry/vdso/vdso32/note.o
  AS      arch/x86/power/hibernate_asm_32.o
  CC      arch/x86/kernel/fpu/regset.o
  ASN.1   crypto/asymmetric_keys/x509.asn1.[ch]
  CC      security/security.o
  AS      arch/x86/entry/vdso/vdso32/system_call.o
  CC      arch/x86/power/hibernate.o
  AS      arch/x86/entry/vdso/vdso32/sigreturn.o
  CC      arch/x86/entry/vdso/vdso32/vclock_gettime.o
  CC      drivers/pci/msi/pcidev_msi.o
  CC      drivers/video/console/dummycon.o
  AR      arch/x86/platform/iris/built-in.a
  AR      drivers/idle/built-in.a
  CC      arch/x86/platform/efi/efi.o
  CC      security/selinux/nlmsgtab.o
  CC      lib/crypto/memneq.o
  AR      drivers/char/ipmi/built-in.a
  CC      sound/core/init.o
  CC      crypto/cipher.o
  CC      ipc/mqueue.o
  CC      arch/x86/lib/insn.o
  CC      arch/x86/lib/kaslr.o
  CC      crypto/compress.o
  CC      drivers/acpi/acpica/dsargs.o
  CC      lib/crypto/mpi/generic_mpih-mul2.o
  ASN.1   crypto/asymmetric_keys/x509_akid.asn1.[ch]
  CC      arch/x86/kernel/acpi/sleep.o
  CC      crypto/asymmetric_keys/x509_loader.o
  AR      drivers/leds/built-in.a
  CC      arch/x86/platform/efi/efi_32.o
  CC      arch/x86/entry/vdso/vdso32/vgetcpu.o
  CC      fs/nfs_common/grace.o
  AR      net/bpf/built-in.a
  CC      crypto/algapi.o
  CC      arch/x86/platform/intel/iosf_mbi.o
  CC      arch/x86/kernel/cpu/mtrr/mtrr.o
  CC      arch/x86/events/rapl.o
  AR      block/partitions/built-in.a
  CC      sound/core/seq/seq_fifo.o
  CC      crypto/asymmetric_keys/x509_public_key.o
  AR      drivers/acpi/pmic/built-in.a
  ASN.1   crypto/asymmetric_keys/pkcs7.asn1.[ch]
  CC      arch/x86/mm/init.o
  AS      arch/x86/kernel/acpi/wakeup_32.o
  CC      arch/x86/events/amd/ibs.o
  CC      arch/x86/kernel/acpi/cstate.o
  CC      arch/x86/lib/memcpy_32.o
  CC      arch/x86/pci/direct.o
  CC      fs/nfs_common/common.o
  AS      arch/x86/lib/memmove_32.o
  CC      security/keys/process_keys.o
  CC      kernel/locking/mutex.o
  CC      arch/x86/lib/misc.o
  CC      fs/iomap/trace.o
  CC      drivers/acpi/acpica/dscontrol.o
  CC      arch/x86/lib/pc-conf-reg.o
  CC      drivers/video/console/vgacon.o
  HOSTCC  arch/x86/entry/vdso/vdso2c
  CC      kernel/locking/semaphore.o
  CC      arch/x86/mm/pat/memtype_interval.o
  AR      arch/x86/power/built-in.a
  CC      fs/iomap/iter.o
  CC      lib/crypto/mpi/generic_mpih-mul3.o
  CC      drivers/pci/msi/api.o
  CC      arch/x86/kernel/fpu/signal.o
  AR      fs/notify/inotify/built-in.a
  CC      net/sched/sch_frag.o
  AR      fs/notify/fanotify/built-in.a
  CC      fs/notify/fsnotify.o
  CC      drivers/pci/msi/msi.o
  CC      fs/iomap/buffered-io.o
  AS      arch/x86/lib/putuser.o
  CC      fs/quota/dquot.o
  CC      arch/x86/events/msr.o
  AS      arch/x86/lib/retpoline.o
  CC      arch/x86/lib/string_32.o
  CC      arch/x86/kernel/cpu/mce/genpool.o
  CC      arch/x86/lib/strstr_32.o
  CC      arch/x86/kernel/apic/apic.o
  CC      crypto/scatterwalk.o
  CC      arch/x86/lib/usercopy.o
  CC      drivers/acpi/acpica/dsdebug.o
  CC      crypto/asymmetric_keys/pkcs7_trust.o
  CC      fs/notify/notification.o
  AR      arch/x86/kernel/acpi/built-in.a
  CC      arch/x86/events/intel/ds.o
  CC      block/elevator.o
  CC      arch/x86/entry/vdso/vdso32-setup.o
  CC      sound/core/seq/seq_prioq.o
  CC      sound/core/seq/seq_timer.o
  AS      arch/x86/platform/efi/efi_stub_32.o
  CC      arch/x86/platform/efi/runtime-map.o
  AR      arch/x86/platform/intel/built-in.a
  CC      crypto/proc.o
  CC      arch/x86/kernel/cpu/mtrr/if.o
  AR      net/netlink/built-in.a
  CC      arch/x86/pci/mmconfig-shared.o
  CC      arch/x86/pci/fixup.o
  CC      kernel/locking/rwsem.o
  CC      arch/x86/lib/usercopy_32.o
  CC      lib/crypto/mpi/generic_mpih-rshift.o
  AR      fs/nfs_common/built-in.a
  AR      arch/x86/mm/pat/built-in.a
  CC      drivers/pci/pcie/portdrv.o
  CC      drivers/pnp/pnpacpi/core.o
  CC      kernel/sched/fair.o
  VDSO    arch/x86/entry/vdso/vdso32.so.dbg
  CC      mm/oom_kill.o
  CC      drivers/acpi/acpica/dsfield.o
  CC      crypto/asymmetric_keys/pkcs7_verify.o
  CC      drivers/pnp/core.o
  OBJCOPY arch/x86/entry/vdso/vdso32.so
  VDSO2C  arch/x86/entry/vdso/vdso-image-32.c
  CC      net/core/request_sock.o
  CC      arch/x86/entry/vdso/vdso-image-32.o
  CC      arch/x86/kernel/fpu/xstate.o
  CC      arch/x86/events/intel/knc.o
  CC      arch/x86/mm/init_32.o
  CC      arch/x86/events/intel/lbr.o
  CC      arch/x86/kernel/cpu/mce/intel.o
  CC      arch/x86/lib/msr-smp.o
  CC      security/keys/request_key.o
  CC      arch/x86/mm/fault.o
  CC      fs/notify/group.o
  AR      sound/isa/ad1816a/built-in.a
  CC      arch/x86/pci/acpi.o
  AR      sound/isa/ad1848/built-in.a
  CC      drivers/video/backlight/backlight.o
  AR      sound/isa/cs423x/built-in.a
  AR      sound/pci/ac97/built-in.a
  AR      drivers/video/console/built-in.a
  AR      arch/x86/entry/vdso/built-in.a
  AR      sound/isa/es1688/built-in.a
  AS      arch/x86/entry/entry.o
  AR      sound/ppc/built-in.a
  AR      sound/pci/ali5451/built-in.a
  AR      sound/isa/galaxy/built-in.a
  CC      security/keys/request_key_auth.o
  CC      ipc/namespace.o
  CC      arch/x86/events/amd/uncore.o
  CC      security/keys/user_defined.o
  AR      sound/pci/asihpi/built-in.a
  AR      sound/isa/gus/built-in.a
  AS      arch/x86/entry/entry_32.o
  AR      sound/pci/au88x0/built-in.a
  AR      sound/isa/msnd/built-in.a
  AR      sound/isa/opti9xx/built-in.a
  AR      sound/pci/aw2/built-in.a
  AR      sound/pci/ctxfi/built-in.a
  AR      sound/isa/sb/built-in.a
  AR      sound/arm/built-in.a
  AR      sound/pci/ca0106/built-in.a
  AR      sound/isa/wavefront/built-in.a
  CC      security/keys/proc.o
  AR      sound/pci/cs46xx/built-in.a
  CC      arch/x86/entry/syscall_32.o
  AR      sound/isa/wss/built-in.a
  CC      security/keys/sysctl.o
  AR      sound/isa/built-in.a
  AR      sound/pci/cs5535audio/built-in.a
  CC      drivers/pci/msi/irqdomain.o
  AR      sound/pci/lola/built-in.a
  CC      crypto/asymmetric_keys/x509.asn1.o
  AR      sound/pci/lx6464es/built-in.a
  CC      security/keys/keyctl_pkey.o
  AR      sound/pci/echoaudio/built-in.a
  CC      arch/x86/pci/legacy.o
  AR      sound/pci/emu10k1/built-in.a
  CC      arch/x86/kernel/cpu/mtrr/generic.o
  CC      sound/core/seq/seq_system.o
  CC      drivers/acpi/acpica/dsinit.o
  CC      sound/pci/hda/hda_bind.o
  CC      crypto/asymmetric_keys/x509_akid.asn1.o
  CC      lib/crypto/mpi/generic_mpih-sub1.o
  CC      crypto/asymmetric_keys/x509_cert_parser.o
  CC      arch/x86/lib/cache-smp.o
  CC      sound/core/memory.o
  CC      net/sched/sch_api.o
  CC      drivers/pnp/pnpacpi/rsparser.o
  AR      arch/x86/platform/efi/built-in.a
  AR      arch/x86/platform/intel-mid/built-in.a
  CC      arch/x86/lib/crc32-glue.o
  AR      arch/x86/platform/intel-quark/built-in.a
  AR      arch/x86/platform/olpc/built-in.a
  AR      arch/x86/platform/scx200/built-in.a
  AR      arch/x86/platform/ts5500/built-in.a
  CC      arch/x86/pci/irq.o
  AR      arch/x86/platform/uv/built-in.a
  AR      arch/x86/platform/built-in.a
  CC      kernel/locking/percpu-rwsem.o
  CC      kernel/locking/spinlock.o
  CC      drivers/pci/pcie/rcec.o
  CC      fs/quota/quota_v2.o
  CC      arch/x86/kernel/cpu/mce/amd.o
  CC      block/blk-core.o
  AR      drivers/pci/pwrctrl/built-in.a
  CC      sound/core/seq/seq_ports.o
  CC      drivers/acpi/acpica/dsmethod.o
  CC      ipc/mq_sysctl.o
  CC      security/lsm_audit.o
  CC      block/blk-sysfs.o
  CC      fs/notify/mark.o
  CC      drivers/pci/pcie/bwctrl.o
  CC      crypto/asymmetric_keys/pkcs7.asn1.o
  CC      io_uring/opdef.o
  CC      net/core/skbuff.o
  AR      sound/pci/ice1712/built-in.a
  CC      kernel/sched/build_policy.o
  CC      mm/fadvise.o
  CC      arch/x86/kernel/cpu/mce/threshold.o
  AS      arch/x86/lib/crc32-pclmul.o
  CC      crypto/asymmetric_keys/pkcs7_parser.o
  CC      lib/crypto/mpi/generic_mpih-add1.o
  CC      kernel/locking/osq_lock.o
  CC      arch/x86/lib/msr.o
  CC      arch/x86/kernel/cpu/mtrr/cleanup.o
  CC      fs/quota/quota_tree.o
  CC      drivers/pci/pcie/aspm.o
  CC      net/ethtool/ioctl.o
  AR      security/keys/built-in.a
  CC      net/netfilter/core.o
  AR      drivers/video/backlight/built-in.a
  CC      net/ipv4/netfilter/nf_defrag_ipv4.o
  AR      drivers/pci/msi/built-in.a
  AR      drivers/video/fbdev/core/built-in.a
  CC      net/ipv4/netfilter/nf_reject_ipv4.o
  CC      sound/pci/hda/hda_codec.o
  AR      drivers/video/fbdev/omap/built-in.a
  AR      arch/x86/kernel/fpu/built-in.a
  CC      drivers/video/aperture.o
  AR      drivers/video/fbdev/omap2/omapfb/dss/built-in.a
  AR      drivers/video/fbdev/omap2/omapfb/displays/built-in.a
  AR      drivers/video/fbdev/omap2/omapfb/built-in.a
  AR      drivers/video/fbdev/omap2/built-in.a
  CC      arch/x86/kernel/apic/apic_common.o
  AR      ipc/built-in.a
  AR      drivers/video/fbdev/built-in.a
  CC      drivers/video/cmdline.o
  CC      sound/core/control.o
  CC      net/ipv4/netfilter/ip_tables.o
  CC      net/ipv4/netfilter/iptable_filter.o
  CC      drivers/acpi/acpica/dsmthdat.o
  CC      kernel/locking/qspinlock.o
  CC      arch/x86/entry/common.o
  CC      arch/x86/events/intel/p4.o
  AR      arch/x86/events/amd/built-in.a
  CC      crypto/aead.o
  AR      drivers/amba/built-in.a
  CC      fs/iomap/direct-io.o
  AR      sound/pci/korg1212/built-in.a
  CC      kernel/power/qos.o
  CC      block/blk-flush.o
  AR      drivers/pnp/pnpacpi/built-in.a
  CC      kernel/power/main.o
  CC      drivers/pnp/card.o
  CC      arch/x86/mm/ioremap.o
  CC      kernel/power/console.o
  CC      sound/core/seq/seq_info.o
  CC      net/ipv4/route.o
  AR      crypto/asymmetric_keys/built-in.a
  AS      arch/x86/lib/msr-reg.o
  CC      fs/quota/quota.o
  AR      sound/pci/mixart/built-in.a
  CC      lib/crypto/mpi/mpicoder.o
  CC      lib/crypto/utils.o
  CC      security/device_cgroup.o
  CC      arch/x86/kernel/apic/apic_noop.o
  CC      drivers/acpi/acpica/dsobject.o
  CC      arch/x86/kernel/cpu/mtrr/amd.o
  CC      io_uring/kbuf.o
  CC      mm/maccess.o
  CC      kernel/locking/rtmutex_api.o
  CC      security/selinux/netif.o
  CC      arch/x86/kernel/cpu/microcode/core.o
  CC      fs/notify/fdinfo.o
  CC      arch/x86/pci/common.o
  CC      arch/x86/lib/msr-reg-export.o
  CC      net/netfilter/nf_log.o
  CC      drivers/video/nomodeset.o
  CC      sound/core/misc.o
  CC      fs/proc/task_mmu.o
  CC      net/ipv4/netfilter/iptable_mangle.o
  CC      crypto/geniv.o
  CC      arch/x86/kernel/apic/ipi.o
  AS      arch/x86/lib/hweight.o
  CC      sound/core/seq/seq_dummy.o
  CC      arch/x86/lib/iomem.o
  CC      arch/x86/kernel/cpu/microcode/intel.o
  CC      drivers/acpi/acpica/dsopcode.o
  AR      arch/x86/kernel/cpu/mce/built-in.a
  CC      kernel/power/process.o
  AS      arch/x86/entry/thunk.o
  CC      drivers/pnp/driver.o
  CC      net/netfilter/nf_queue.o
  AR      arch/x86/entry/built-in.a
  CC      net/ethtool/common.o
  CC      net/sched/sch_blackhole.o
  CC      lib/crypto/chacha.o
  CC      net/core/datagram.o
  CC      arch/x86/mm/extable.o
  CC      lib/crypto/mpi/mpi-add.o
  CC      arch/x86/kernel/cpu/mtrr/cyrix.o
  CC      drivers/video/hdmi.o
  CC      fs/quota/kqid.o
  CC      drivers/pci/pcie/pme.o
  CC      net/netfilter/nf_sockopt.o
  CC      arch/x86/events/intel/p6.o
  CC      io_uring/rsrc.o
  CC      kernel/locking/qrwlock.o
  CC      arch/x86/lib/atomic64_32.o
  CC      arch/x86/pci/early.o
  AR      fs/notify/built-in.a
  CC      net/ipv4/inetpeer.o
  CC      net/ipv4/netfilter/ipt_REJECT.o
  CC      io_uring/notif.o
  CC      fs/iomap/fiemap.o
  CC      arch/x86/lib/inat.o
  CC      lib/crypto/aes.o
  CC      drivers/acpi/acpica/dspkginit.o
  CC      mm/page-writeback.o
  CC      arch/x86/kernel/apic/vector.o
  CC      kernel/power/suspend.o
  AR      sound/core/seq/built-in.a
  AR      arch/x86/lib/built-in.a
  CC      sound/core/device.o
  AR      arch/x86/lib/lib.a
  CC      net/ipv4/protocol.o
  AR      drivers/clk/actions/built-in.a
  AR      drivers/clk/analogbits/built-in.a
  AR      drivers/clk/bcm/built-in.a
  AR      drivers/clk/imgtec/built-in.a
  AR      drivers/clk/imx/built-in.a
  CC      net/ipv4/ip_input.o
  AR      drivers/clk/ingenic/built-in.a
  CC      fs/quota/netlink.o
  AR      drivers/clk/mediatek/built-in.a
  AR      sound/sh/built-in.a
  CC      arch/x86/kernel/apic/init.o
  CC      net/ethtool/netlink.o
  AR      drivers/clk/microchip/built-in.a
  CC      block/blk-settings.o
  AR      drivers/clk/mstar/built-in.a
  CC      drivers/pnp/resource.o
  AR      drivers/clk/mvebu/built-in.a
  AR      drivers/clk/ralink/built-in.a
  CC      drivers/pnp/manager.o
  AR      drivers/clk/renesas/built-in.a
  CC      arch/x86/kernel/cpu/cacheinfo.o
  AR      drivers/clk/socfpga/built-in.a
  AR      drivers/clk/sophgo/built-in.a
  AR      drivers/clk/sprd/built-in.a
  AR      drivers/clk/starfive/built-in.a
  AR      drivers/clk/sunxi-ng/built-in.a
  CC      arch/x86/kernel/cpu/microcode/amd.o
  CC      arch/x86/kernel/cpu/mtrr/centaur.o
  AR      drivers/clk/ti/built-in.a
  AR      drivers/clk/versatile/built-in.a
  CC      lib/crypto/mpi/mpi-bit.o
  AR      kernel/locking/built-in.a
  CC      net/core/stream.o
  AR      drivers/clk/xilinx/built-in.a
  CC      lib/crypto/mpi/mpi-cmp.o
  AR      drivers/clk/built-in.a
  CC      crypto/lskcipher.o
  CC      security/selinux/netnode.o
  CC      net/core/scm.o
  CC      drivers/acpi/acpica/dsutils.o
  CC      drivers/acpi/dptf/int340x_thermal.o
  CC      drivers/acpi/x86/apple.o
  AR      drivers/pci/pcie/built-in.a
  AR      sound/pci/nm256/built-in.a
  CC      drivers/pci/hotplug/pci_hotplug_core.o
  AR      drivers/video/built-in.a
  CC      arch/x86/pci/bus_numa.o
  CC      net/sched/cls_api.o
  CC      net/sched/act_api.o
  AR      drivers/pci/controller/dwc/built-in.a
  CC      mm/folio-compat.o
  AR      drivers/pci/controller/mobiveil/built-in.a
  CC      sound/core/info.o
  AR      drivers/pci/controller/plda/built-in.a
  CC      arch/x86/mm/mmap.o
  AR      drivers/pci/controller/built-in.a
  CC      fs/kernfs/mount.o
  CC      arch/x86/events/intel/pt.o
  CC      arch/x86/kernel/kprobes/core.o
  CC      fs/iomap/seek.o
  AR      sound/pci/oxygen/built-in.a
  CC      sound/pci/hda/hda_jack.o
  CC      net/xfrm/xfrm_policy.o
  CC      net/netfilter/utils.o
  CC      arch/x86/events/intel/uncore.o
  CC      arch/x86/kernel/cpu/mtrr/legacy.o
  CC      net/xfrm/xfrm_state.o
  AR      drivers/acpi/dptf/built-in.a
  CC      drivers/acpi/acpica/dswexec.o
  CC      fs/sysfs/file.o
  CC      lib/zlib_inflate/inffast.o
  CC      lib/crypto/mpi/mpi-sub-ui.o
  CC [M]  net/ipv4/netfilter/iptable_nat.o
  AR      fs/quota/built-in.a
  CC      drivers/acpi/x86/cmos_rtc.o
  CC      net/xfrm/xfrm_hash.o
  CC      sound/pci/hda/hda_auto_parser.o
  CC      arch/x86/events/intel/uncore_nhmex.o
  CC      lib/zlib_deflate/deflate.o
  CC      fs/proc/inode.o
  CC      block/blk-ioc.o
  CC      lib/zlib_inflate/inflate.o
  CC      kernel/power/hibernate.o
  CC      io_uring/tctx.o
  CC      net/unix/af_unix.o
  CC      arch/x86/mm/pgtable.o
  AR      arch/x86/kernel/cpu/mtrr/built-in.a
  CC      arch/x86/pci/amd_bus.o
  CC      mm/readahead.o
  AR      arch/x86/kernel/cpu/microcode/built-in.a
  CC      drivers/pnp/support.o
  CC      fs/devpts/inode.o
  CC      arch/x86/kernel/cpu/scattered.o
  CC      kernel/sched/build_utility.o
  CC      crypto/skcipher.o
  CC      fs/iomap/swapfile.o
  CC      drivers/pci/hotplug/acpi_pcihp.o
  CC      fs/netfs/buffered_read.o
  CC      drivers/acpi/acpica/dswload.o
  CC      fs/kernfs/inode.o
  CC      fs/ext4/balloc.o
  CC      net/ethtool/bitset.o
  CC      sound/core/isadma.o
  CC      arch/x86/kernel/apic/hw_nmi.o
  CC      security/selinux/netport.o
  CC      lib/crypto/mpi/mpi-div.o
  CC      sound/pci/hda/hda_sysfs.o
  CC      lib/crypto/arc4.o
  CC      net/core/gen_stats.o
  CC      drivers/acpi/x86/lpss.o
  CC      arch/x86/kernel/kprobes/opt.o
  CC      arch/x86/kernel/cpu/topology_common.o
  CC      fs/sysfs/dir.o
  CC      sound/core/vmaster.o
  LDS     arch/x86/kernel/vmlinux.lds
  CC      lib/zlib_inflate/infutil.o
  AS      arch/x86/kernel/head_32.o
  CC      kernel/printk/printk.o
  CC      drivers/pnp/interface.o
  CC      io_uring/filetable.o
  CC      drivers/acpi/acpica/dswload2.o
  CC      block/blk-map.o
  CC      fs/proc/root.o
  CC      lib/zlib_deflate/deftree.o
  CC      net/core/gen_estimator.o
  CC      lib/lzo/lzo1x_compress.o
  CC      arch/x86/mm/physaddr.o
  AR      arch/x86/pci/built-in.a
  CC      lib/zlib_deflate/deflate_syms.o
  CC      net/ipv6/netfilter/ip6_tables.o
  AR      fs/devpts/built-in.a
  CC      kernel/power/snapshot.o
  CC      lib/crypto/mpi/mpi-mod.o
  AR      fs/iomap/built-in.a
  CC      lib/zlib_inflate/inftrees.o
  AR      drivers/pci/hotplug/built-in.a
  CC      fs/kernfs/dir.o
  CC      net/netfilter/nfnetlink.o
  AR      net/ipv4/netfilter/built-in.a
  AR      drivers/pci/switch/built-in.a
  CC      net/ipv4/ip_fragment.o
  CC      drivers/pci/access.o
  CC      arch/x86/kernel/apic/io_apic.o
  CC      net/sched/sch_fifo.o
  CC      arch/x86/kernel/cpu/topology_ext.o
  CC      io_uring/rw.o
  CC      net/unix/garbage.o
  CC      fs/ext4/bitmap.o
  CC      net/xfrm/xfrm_input.o
  CC      lib/zlib_inflate/inflate_syms.o
  CC      mm/swap.o
  CC      fs/sysfs/symlink.o
  CC      sound/pci/hda/hda_controller.o
  CC      sound/core/ctljack.o
  CC      drivers/acpi/acpica/dswscope.o
  CC      sound/pci/hda/hda_proc.o
  CC      drivers/acpi/x86/s2idle.o
  CC      crypto/seqiv.o
  CC      arch/x86/events/intel/uncore_snb.o
  CC      net/ipv4/ip_forward.o
  CC      fs/netfs/buffered_write.o
  CC      lib/lzo/lzo1x_decompress_safe.o
  CC      drivers/pnp/quirks.o
  AR      arch/x86/kernel/kprobes/built-in.a
  AR      sound/pci/pcxhr/built-in.a
  CC      fs/jbd2/transaction.o
  AR      lib/zlib_deflate/built-in.a
  CC      lib/lz4/lz4_decompress.o
  CC      arch/x86/mm/tlb.o
  CC      drivers/dma/dw/core.o
  CC      arch/x86/kernel/cpu/topology_amd.o
  AR      lib/zlib_inflate/built-in.a
  CC      lib/crypto/mpi/mpi-mul.o
  CC      fs/jbd2/commit.o
  CC      net/unix/sysctl_net_unix.o
  CC      sound/pci/hda/hda_hwdep.o
  CC      fs/proc/base.o
  CC      security/selinux/status.o
  CC      drivers/acpi/acpica/dswstate.o
  CC      sound/core/jack.o
  CC      net/ethtool/strset.o
  CC      arch/x86/kernel/apic/msi.o
  CC      block/blk-merge.o
  CC      drivers/dma/dw/dw.o
  CC      net/packet/af_packet.o
  AR      lib/lzo/built-in.a
  CC      fs/sysfs/mount.o
  AR      net/dsa/built-in.a
  CC      drivers/pci/bus.o
  CC      kernel/irq/irqdesc.o
  CC      crypto/echainiv.o
  CC      arch/x86/kernel/cpu/common.o
  CC      drivers/acpi/acpica/evevent.o
  CC      fs/ext4/block_validity.o
  CC      fs/ext4/dir.o
  CC      net/sched/cls_cgroup.o
  CC      drivers/acpi/x86/utils.o
  CC      lib/crypto/mpi/mpih-cmp.o
  CC      drivers/pnp/system.o
  CC      net/core/net_namespace.o
  CC      kernel/power/swap.o
  CC      fs/kernfs/file.o
  CC      net/sunrpc/auth_gss/auth_gss.o
  CC      net/netfilter/nfnetlink_log.o
  CC      sound/core/hwdep.o
  CC      arch/x86/events/intel/uncore_snbep.o
  AR      sound/synth/emux/built-in.a
  AR      sound/synth/built-in.a
  CC      drivers/acpi/x86/blacklist.o
  CC      drivers/acpi/acpica/evgpe.o
  AR      sound/usb/misc/built-in.a
  CC      drivers/dma/hsu/hsu.o
  CC      fs/netfs/direct_read.o
  AR      sound/usb/usx2y/built-in.a
  AR      drivers/soc/apple/built-in.a
  AR      net/unix/built-in.a
  AR      sound/usb/caiaq/built-in.a
  AR      drivers/soc/aspeed/built-in.a
  AR      sound/usb/6fire/built-in.a
  AR      drivers/soc/bcm/built-in.a
  CC      drivers/acpi/tables.o
  CC      net/sunrpc/clnt.o
  AR      drivers/soc/fsl/built-in.a
  AR      sound/usb/hiface/built-in.a
  AR      drivers/soc/fujitsu/built-in.a
  AR      sound/usb/bcd2000/built-in.a
  AR      sound/usb/built-in.a
  CC      io_uring/net.o
  AR      drivers/soc/hisilicon/built-in.a
  CC      mm/truncate.o
  CC      arch/x86/mm/cpu_entry_area.o
  AR      drivers/soc/imx/built-in.a
  CC      mm/vmscan.o
  AR      drivers/soc/ixp4xx/built-in.a
  AR      drivers/soc/loongson/built-in.a
  CC      drivers/dma/dw/idma32.o
  AR      drivers/soc/mediatek/built-in.a
  CC      crypto/ahash.o
  CC      sound/pci/hda/hda_intel.o
  AR      drivers/soc/microchip/built-in.a
  AR      drivers/soc/nuvoton/built-in.a
  CC      net/ipv6/netfilter/ip6table_filter.o
  AR      drivers/soc/pxa/built-in.a
  CC      kernel/printk/printk_safe.o
  CC      kernel/irq/handle.o
  CC      security/selinux/ss/ebitmap.o
  AR      drivers/soc/amlogic/built-in.a
  AR      drivers/soc/qcom/built-in.a
  CC      net/ipv4/ip_options.o
  AR      drivers/soc/renesas/built-in.a
  AR      drivers/soc/rockchip/built-in.a
  CC      fs/sysfs/group.o
  CC      drivers/pci/probe.o
  CC      net/core/secure_seq.o
  AR      drivers/pnp/built-in.a
  AR      drivers/soc/sunxi/built-in.a
  CC      lib/crypto/mpi/mpih-div.o
  CC      net/sched/ematch.o
  AR      drivers/soc/ti/built-in.a
  AR      drivers/soc/versatile/built-in.a
  AR      drivers/soc/xilinx/built-in.a
  AR      lib/lz4/built-in.a
  AR      drivers/soc/built-in.a
  CC      net/ipv6/netfilter/ip6table_mangle.o
  CC      fs/netfs/direct_write.o
  CC      arch/x86/kernel/apic/probe_32.o
  CC      net/netfilter/nf_conntrack_core.o
  CC      net/ethtool/linkinfo.o
  CC      sound/core/timer.o
  CC      arch/x86/mm/maccess.o
  AR      drivers/acpi/x86/built-in.a
  CC      fs/jbd2/recovery.o
  CC      fs/proc/generic.o
  CC      drivers/acpi/acpica/evgpeblk.o
  CC      drivers/pci/host-bridge.o
  CC      net/core/flow_dissector.o
  AR      sound/firewire/built-in.a
  CC      net/ipv6/af_inet6.o
  CC      fs/ext4/ext4_jbd2.o
  CC      net/xfrm/xfrm_output.o
  CC      kernel/irq/manage.o
  CC      kernel/irq/spurious.o
  CC      block/blk-timeout.o
  CC      arch/x86/mm/pgprot.o
  CC      lib/crypto/mpi/mpih-mul.o
  AR      arch/x86/kernel/apic/built-in.a
  CC      fs/netfs/iterator.o
  CC      fs/kernfs/symlink.o
  CC      kernel/printk/nbcon.o
  CC      drivers/dma/dw/acpi.o
  AR      drivers/dma/hsu/built-in.a
  CC      drivers/acpi/osi.o
  AR      fs/sysfs/built-in.a
  CC      drivers/acpi/acpica/evgpeinit.o
  CC      net/ipv6/netfilter/nf_defrag_ipv6_hooks.o
  CC      net/core/sysctl_net_core.o
  AR      sound/pci/riptide/built-in.a
  AR      sound/sparc/built-in.a
  CC      net/sunrpc/auth_gss/gss_mech_switch.o
  CC      arch/x86/kernel/cpu/rdrand.o
  CC      net/netfilter/nf_conntrack_standalone.o
  CC      kernel/power/user.o
  CC      net/sunrpc/xprt.o
  CC      net/ethtool/linkmodes.o
  CC      arch/x86/kernel/cpu/match.o
  CC      net/ipv4/ip_output.o
  CC      crypto/shash.o
  CC      lib/crypto/gf128mul.o
  AR      kernel/sched/built-in.a
  CC      kernel/rcu/update.o
  CC      net/ipv6/netfilter/nf_conntrack_reasm.o
  CC      arch/x86/mm/pgtable_32.o
  CC      arch/x86/mm/iomap_32.o
  CC      drivers/acpi/acpica/evgpeutil.o
  CC      arch/x86/mm/hugetlbpage.o
  AR      net/sched/built-in.a
  CC      net/sunrpc/auth_gss/svcauth_gss.o
  CC      net/ethtool/rss.o
  AR      net/wireless/tests/built-in.a
  CC      fs/proc/array.o
  CC      net/wireless/core.o
  CC      security/selinux/ss/hashtab.o
  CC      arch/x86/kernel/cpu/bugs.o
  CC      fs/jbd2/checkpoint.o
  CC      block/blk-lib.o
  CC      net/ethtool/linkstate.o
  CC      drivers/acpi/acpica/evglock.o
  AR      drivers/dma/dw/built-in.a
  AR      drivers/dma/idxd/built-in.a
  AR      fs/kernfs/built-in.a
  CC      sound/core/hrtimer.o
  AR      drivers/dma/amd/built-in.a
  CC      fs/proc/fd.o
  CC      crypto/akcipher.o
  AR      drivers/dma/mediatek/built-in.a
  AR      drivers/dma/qcom/built-in.a
  CC      lib/crypto/mpi/mpi-pow.o
  AR      drivers/dma/stm32/built-in.a
  AR      drivers/dma/ti/built-in.a
  AR      drivers/dma/xilinx/built-in.a
  CC      drivers/dma/dmaengine.o
  AR      sound/pci/hda/built-in.a
  CC      kernel/printk/printk_ringbuffer.o
  AR      sound/pci/rme9652/built-in.a
  AR      sound/pci/trident/built-in.a
  AR      sound/pci/ymfpci/built-in.a
  AR      sound/pci/vx222/built-in.a
  CC      net/xfrm/xfrm_sysctl.o
  AR      sound/pci/built-in.a
  CC      fs/netfs/locking.o
  CC      arch/x86/events/intel/uncore_discovery.o
  AR      sound/spi/built-in.a
  AR      sound/parisc/built-in.a
  CC      lib/zstd/zstd_decompress_module.o
  CC      security/selinux/ss/symtab.o
  CC      kernel/rcu/sync.o
  CC      kernel/power/poweroff.o
  CC      drivers/virtio/virtio.o
  CC      drivers/acpi/acpica/evhandler.o
  CC      security/selinux/ss/sidtab.o
  CC      drivers/pci/remove.o
  CC      drivers/tty/vt/vt_ioctl.o
  CC      arch/x86/mm/dump_pagetables.o
  CC      io_uring/poll.o
  CC      sound/core/pcm.o
  CC      fs/ext4/extents.o
  CC      fs/ext4/extents_status.o
  CC      fs/proc/proc_tty.o
  AR      net/mac80211/tests/built-in.a
  CC      net/mac80211/main.o
  CC      drivers/tty/vt/vc_screen.o
  AR      kernel/power/built-in.a
  CC      kernel/irq/resend.o
  CC      fs/netfs/main.o
  CC      drivers/acpi/acpica/evmisc.o
  CC      fs/jbd2/revoke.o
  CC      net/mac80211/status.o
  CC      lib/zstd/decompress/huf_decompress.o
  CC      lib/zstd/decompress/zstd_ddict.o
  CC      net/mac80211/driver-ops.o
  CC      block/blk-mq.o
  CC      drivers/dma/virt-dma.o
  CC      lib/xz/xz_dec_syms.o
  CC      lib/crypto/mpi/mpiutil.o
  CC      io_uring/eventfd.o
  CC      kernel/rcu/srcutree.o
  CC      net/sunrpc/auth_gss/gss_rpc_upcall.o
  CC      security/selinux/ss/avtab.o
  CC      kernel/printk/sysctl.o
  CC      drivers/acpi/osl.o
  CC      crypto/sig.o
  CC      arch/x86/kernel/cpu/aperfmperf.o
  CC      net/ethtool/debug.o
  CC      drivers/acpi/acpica/evregion.o
  CC      fs/ext4/file.o
  AR      net/packet/built-in.a
  CC      drivers/acpi/acpica/evrgnini.o
  CC      kernel/irq/chip.o
  CC      drivers/pci/pci.o
  CC      net/netfilter/nf_conntrack_expect.o
  CC      net/core/dev.o
  CC      net/ipv6/netfilter/nf_reject_ipv6.o
  CC      lib/xz/xz_dec_stream.o
  CC      drivers/virtio/virtio_ring.o
  CC      fs/proc/cmdline.o
  AR      kernel/printk/built-in.a
  CC      net/xfrm/xfrm_replay.o
  CC      net/ipv6/netfilter/ip6t_ipv6header.o
  CC      arch/x86/events/intel/cstate.o
  CC      arch/x86/mm/highmem_32.o
  CC      arch/x86/kernel/head32.o
  CC      sound/core/pcm_native.o
  AR      lib/crypto/mpi/built-in.a
  CC      lib/crypto/blake2s.o
  CC      drivers/dma/acpi-dma.o
  CC      io_uring/uring_cmd.o
  CC      mm/shrinker.o
  CC      fs/jbd2/journal.o
  CC      net/ipv6/netfilter/ip6t_REJECT.o
  CC      drivers/acpi/acpica/evsci.o
  CC      drivers/tty/hvc/hvc_console.o
  CC      lib/xz/xz_dec_lzma2.o
  CC      drivers/tty/vt/selection.o
  CC      net/mac80211/sta_info.o
  CC      arch/x86/kernel/cpu/cpuid-deps.o
  CC      fs/netfs/misc.o
  CC      lib/crypto/blake2s-generic.o
  CC      fs/proc/consoles.o
  CC      crypto/kpp.o
  CC      net/ipv4/ip_sockglue.o
  CC      drivers/char/hw_random/core.o
  CC      drivers/char/agp/backend.o
  CC      drivers/acpi/acpica/evxface.o
  CC      net/ethtool/wol.o
  CC      kernel/rcu/tree.o
  CC      sound/core/pcm_lib.o
  AR      arch/x86/mm/built-in.a
  CC      arch/x86/kernel/cpu/umwait.o
  MKCAP   arch/x86/kernel/cpu/capflags.c
  CC      net/sunrpc/auth_gss/gss_rpc_xdr.o
  CC      lib/zstd/decompress/zstd_decompress.o
  CC      kernel/irq/dummychip.o
  CC      arch/x86/kernel/cpu/powerflags.o
  CC      kernel/rcu/rcu_segcblist.o
  CC      security/selinux/ss/policydb.o
  ASN.1   crypto/rsapubkey.asn1.[ch]
  CC      fs/ramfs/inode.o
  AR      arch/x86/events/intel/built-in.a
  CC      fs/hugetlbfs/inode.o
  AR      arch/x86/events/built-in.a
  CC      lib/crypto/sha1.o
  CC      net/netfilter/nf_conntrack_helper.o
  CC      drivers/tty/vt/keyboard.o
  CC      net/wireless/sysfs.o
  AR      drivers/dma/built-in.a
  CC      drivers/pci/pci-driver.o
  CC      lib/xz/xz_dec_bcj.o
  CC      fs/fat/cache.o
  CC      fs/proc/cpuinfo.o
  CC      mm/shmem.o
  CC      block/blk-mq-tag.o
  AR      drivers/tty/hvc/built-in.a
  AR      kernel/livepatch/built-in.a
  CC      drivers/acpi/acpica/evxfevnt.o
  CC      lib/dim/dim.o
  CC      lib/fonts/fonts.o
  CC      kernel/irq/devres.o
  CC      net/xfrm/xfrm_device.o
  CC      fs/ext4/fsmap.o
  CC      drivers/char/hw_random/intel-rng.o
  CC      arch/x86/kernel/cpu/topology.o
  CC      lib/crypto/sha256.o
  CC      drivers/char/agp/generic.o
  ASN.1   crypto/rsaprivkey.asn1.[ch]
  CC      drivers/char/agp/isoch.o
  CC      crypto/rsa.o
  CC      net/ipv6/anycast.o
  CC      fs/netfs/objects.o
  CC      block/blk-stat.o
  CC      io_uring/openclose.o
  AR      net/ipv6/netfilter/built-in.a
  CC      security/selinux/ss/services.o
  CC      drivers/virtio/virtio_anchor.o
  AR      lib/xz/built-in.a
  AR      drivers/iommu/amd/built-in.a
  AR      drivers/iommu/intel/built-in.a
  CC      lib/dim/net_dim.o
  CC      drivers/acpi/acpica/evxfgpe.o
  AR      drivers/iommu/arm/arm-smmu/built-in.a
  AR      drivers/iommu/arm/arm-smmu-v3/built-in.a
  AR      drivers/iommu/arm/built-in.a
  CC      lib/fonts/font_8x16.o
  AR      drivers/iommu/iommufd/built-in.a
  CC      lib/zstd/decompress/zstd_decompress_block.o
  AR      drivers/iommu/riscv/built-in.a
  CC      fs/ramfs/file-mmu.o
  CC      drivers/iommu/iommu.o
  CC      fs/proc/devices.o
  CC      net/sunrpc/auth_gss/trace.o
  CC      kernel/irq/kexec.o
  CC      net/ethtool/features.o
  CC      net/ipv4/inet_hashtables.o
  CC      net/mac80211/wep.o
  CC      net/ipv6/ip6_output.o
  CC      fs/fat/dir.o
  AR      lib/crypto/built-in.a
  CC      drivers/iommu/iommu-traces.o
  CC      drivers/char/hw_random/amd-rng.o
  CC      net/core/dev_addr_lists.o
  AR      lib/fonts/built-in.a
  CC      drivers/char/hw_random/geode-rng.o
  CC      drivers/char/agp/amd64-agp.o
  CC      crypto/rsa_helper.o
  CC      drivers/acpi/acpica/evxfregn.o
  CC      drivers/virtio/virtio_pci_modern_dev.o
  CC      drivers/virtio/virtio_pci_legacy_dev.o
  CC      drivers/acpi/acpica/exconcat.o
  CC      kernel/irq/autoprobe.o
  CC      net/mac80211/aead_api.o
  CC      net/netfilter/nf_conntrack_proto.o
  CC      drivers/tty/vt/vt.o
  CC      net/netfilter/nf_conntrack_proto_generic.o
  CC      net/xfrm/xfrm_nat_keepalive.o
  CC      fs/proc/interrupts.o
  AR      fs/ramfs/built-in.a
  CC      net/sunrpc/auth_gss/gss_krb5_mech.o
  CC      fs/netfs/read_collect.o
  CC      io_uring/sqpoll.o
  CC      fs/netfs/read_pgpriv2.o
  CC      crypto/rsa-pkcs1pad.o
  AR      drivers/gpu/host1x/built-in.a
  CC      arch/x86/kernel/ebda.o
  CC      sound/core/pcm_misc.o
  AR      fs/hugetlbfs/built-in.a
  CC      drivers/virtio/virtio_pci_modern.o
  CC      fs/isofs/namei.o
  CC      lib/dim/rdma_dim.o
  AR      drivers/gpu/drm/tests/built-in.a
  CC      drivers/acpi/acpica/exconfig.o
  AR      drivers/gpu/drm/arm/built-in.a
  AR      drivers/gpu/drm/clients/built-in.a
  CC      drivers/gpu/drm/display/drm_display_helper_mod.o
  CC      drivers/gpu/drm/display/drm_dp_dual_mode_helper.o
  CC      drivers/pci/search.o
  CC      kernel/irq/irqdomain.o
  CC      drivers/char/hw_random/via-rng.o
  CC      net/netlabel/netlabel_user.o
  AR      fs/jbd2/built-in.a
  CC      net/netlabel/netlabel_kapi.o
  CC      drivers/char/mem.o
  CC      net/ethtool/privflags.o
  CC      fs/proc/loadavg.o
  CC      drivers/tty/serial/8250/8250_core.o
  CC      block/blk-mq-sysfs.o
  CC      drivers/tty/serial/serial_core.o
  CC      drivers/char/agp/intel-agp.o
  CC      drivers/char/random.o
  AR      lib/dim/built-in.a
  AR      drivers/gpu/vga/built-in.a
  CC      fs/proc/meminfo.o
  CC      drivers/connector/cn_queue.o
  COPY    drivers/tty/vt/defkeymap.c
  CC      crypto/rsassa-pkcs1.o
  CC      drivers/base/power/sysfs.o
  CC      net/wireless/radiotap.o
  CC      drivers/acpi/acpica/exconvrt.o
  CC      net/netfilter/nf_conntrack_proto_tcp.o
  CC      fs/ext4/fsync.o
  CC      sound/core/pcm_memory.o
  AR      drivers/char/hw_random/built-in.a
  CC      fs/nfs/client.o
  CC      io_uring/xattr.o
  CC      net/netlabel/netlabel_domainhash.o
  CC      fs/isofs/inode.o
  CC      fs/nfs/dir.o
  CC      fs/nfs/file.o
  CC      fs/nfs/getroot.o
  CC      drivers/virtio/virtio_pci_common.o
  CC      fs/fat/fatent.o
  CC      fs/nfs/inode.o
  CC      net/core/dst.o
  CC      drivers/acpi/acpica/excreate.o
  CC      drivers/pci/rom.o
  CC      net/xfrm/xfrm_algo.o
  CC      drivers/gpu/drm/display/drm_dp_helper.o
  CC      drivers/iommu/iommu-sysfs.o
  CC      drivers/base/power/generic_ops.o
  CC      fs/netfs/read_retry.o
  CC      mm/util.o
  CC      net/ipv4/inet_timewait_sock.o
  CC      drivers/acpi/acpica/exdebug.o
  CC      block/blk-mq-cpumap.o
  CC      net/sunrpc/auth_gss/gss_krb5_seal.o
  CC      crypto/acompress.o
  CC      drivers/char/agp/intel-gtt.o
  CC      fs/proc/stat.o
  CC      drivers/virtio/virtio_pci_legacy.o
  CC      net/ethtool/rings.o
  CC      drivers/tty/serial/8250/8250_platform.o
  CC      kernel/irq/proc.o
  CC      drivers/gpu/drm/ttm/ttm_tt.o
  CC      net/core/netevent.o
  CC      sound/core/memalloc.o
  CC      lib/zstd/zstd_common_module.o
  CC      crypto/scompress.o
  CC      drivers/connector/connector.o
  CC      io_uring/nop.o
  CC      security/selinux/ss/conditional.o
  CC      drivers/base/power/common.o
  CC      net/wireless/util.o
  CC      drivers/acpi/acpica/exdump.o
  CC      drivers/gpu/drm/ttm/ttm_bo.o
  CC      drivers/pci/setup-res.o
  CC      net/mac80211/wpa.o
  CC      drivers/iommu/dma-iommu.o
  CC      lib/zstd/common/debug.o
  CC      kernel/irq/migration.o
  CC      lib/zstd/common/entropy_common.o
  CC      fs/ext4/hash.o
  CC      block/blk-mq-sched.o
  CC      fs/proc/uptime.o
  CC      drivers/acpi/acpica/exfield.o
  CC      drivers/tty/vt/consolemap.o
  CC      drivers/virtio/virtio_pci_admin_legacy_io.o
  CC      drivers/iommu/iova.o
  CC      fs/isofs/dir.o
  CC      net/netlabel/netlabel_addrlist.o
  CC      lib/zstd/common/error_private.o
  AR      kernel/rcu/built-in.a
  CC      lib/zstd/common/fse_decompress.o
  CC      net/sunrpc/auth_gss/gss_krb5_unseal.o
  CC      fs/netfs/read_single.o
  CC      net/ethtool/channels.o
  CC      drivers/tty/serial/8250/8250_pnp.o
  CC      drivers/tty/serial/8250/8250_rsa.o
  CC      drivers/base/power/qos.o
  CC      net/ipv6/ip6_input.o
  CC      fs/fat/file.o
  CC      net/xfrm/xfrm_user.o
  CC      drivers/gpu/drm/ttm/ttm_bo_util.o
  CC      mm/mmzone.o
  AR      drivers/char/agp/built-in.a
  CC      drivers/char/misc.o
  CC      fs/fat/inode.o
  CC      net/netfilter/nf_conntrack_proto_udp.o
  CC      drivers/acpi/utils.o
  CC      fs/fat/misc.o
  CC      kernel/irq/cpuhotplug.o
  CC      fs/fat/nfs.o
  CC      sound/core/pcm_timer.o
  CC      crypto/algboss.o
  CC      io_uring/fs.o
  CC      drivers/acpi/acpica/exfldio.o
  CC      net/ipv4/inet_connection_sock.o
  CC      net/netfilter/nf_conntrack_proto_icmp.o
  CC      fs/fat/namei_vfat.o
  CC      drivers/pci/irq.o
  CC      fs/proc/util.o
  CC      drivers/connector/cn_proc.o
  CC      lib/zstd/common/zstd_common.o
  CC      drivers/virtio/virtio_input.o
  AR      lib/zstd/built-in.a
  CC      fs/ext4/ialloc.o
  CC      lib/argv_split.o
  CC      crypto/testmgr.o
  CC      fs/isofs/util.o
  CC      drivers/virtio/virtio_dma_buf.o
  CC      security/selinux/ss/mls.o
  CC      mm/vmstat.o
  CC      fs/nfs/super.o
  CC      block/ioctl.o
  CC      drivers/tty/serial/8250/8250_port.o
  HOSTCC  drivers/tty/vt/conmakehash
  CC      drivers/acpi/acpica/exmisc.o
  CC      net/sunrpc/auth_gss/gss_krb5_wrap.o
  CC      drivers/pci/vpd.o
  CC      fs/netfs/rolling_buffer.o
  CC      drivers/char/virtio_console.o
  CC      sound/core/seq_device.o
  CC      drivers/gpu/drm/display/drm_dp_mst_topology.o
  CC      kernel/irq/pm.o
  CC      arch/x86/kernel/cpu/proc.o
  CC      lib/bug.o
  AR      drivers/tty/ipwireless/built-in.a
  CC      drivers/tty/vt/defkeymap.o
  CC      fs/nfs/io.o
  CC      net/ipv4/tcp.o
  CC      fs/proc/version.o
  CC      net/netlabel/netlabel_mgmt.o
  CC      drivers/acpi/reboot.o
  AR      sound/pcmcia/vx/built-in.a
  AR      drivers/iommu/built-in.a
  CC      net/ethtool/coalesce.o
  AR      sound/pcmcia/pdaudiocf/built-in.a
  CC      fs/exportfs/expfs.o
  AR      sound/pcmcia/built-in.a
  CC      fs/lockd/clntlock.o
  CC      fs/lockd/clntproc.o
  CC      drivers/gpu/drm/ttm/ttm_bo_vm.o
  CC      net/ethtool/pause.o
  CC      net/mac80211/scan.o
  CC      io_uring/splice.o
  CONMK   drivers/tty/vt/consolemap_deftbl.c
  CC      drivers/tty/vt/consolemap_deftbl.o
  CC      drivers/acpi/acpica/exmutex.o
  CC      fs/isofs/rock.o
  AR      drivers/tty/vt/built-in.a
  CC      crypto/cmac.o
  CC      net/netfilter/nf_conntrack_extend.o
  CC      drivers/base/power/runtime.o
  CC      net/rfkill/core.o
  CC      arch/x86/kernel/cpu/feat_ctl.o
  AR      drivers/virtio/built-in.a
  CC      drivers/tty/serial/8250/8250_dma.o
  CC      security/selinux/ss/context.o
  CC      drivers/acpi/nvs.o
  AR      sound/core/built-in.a
  CC      drivers/tty/tty_io.o
  AR      sound/mips/built-in.a
  AR      sound/soc/built-in.a
  AR      sound/atmel/built-in.a
  CC      sound/hda/hda_bus_type.o
  CC      lib/buildid.o
  CC      fs/proc/softirqs.o
  AR      sound/x86/built-in.a
  CC      drivers/acpi/acpica/exnames.o
  CC      net/core/neighbour.o
  CC      fs/fat/namei_msdos.o
  CC      drivers/gpu/drm/display/drm_dsc_helper.o
  AR      drivers/connector/built-in.a
  CC      net/netlabel/netlabel_unlabeled.o
  CC      net/ipv6/addrconf.o
  CC      kernel/irq/msi.o
  CC      drivers/pci/setup-bus.o
  CC      block/genhd.o
  CC      arch/x86/kernel/cpu/intel.o
  CC      crypto/hmac.o
  CC      lib/clz_tab.o
  CC      net/ipv6/addrlabel.o
  AR      fs/exportfs/built-in.a
  CC      net/ipv6/route.o
  CC      kernel/irq/affinity.o
  CC      fs/netfs/write_collect.o
  CC      drivers/acpi/acpica/exoparg1.o
  CC      net/sunrpc/auth_gss/gss_krb5_crypto.o
  CC      drivers/gpu/drm/ttm/ttm_module.o
  CC      io_uring/sync.o
  AR      sound/xen/built-in.a
  CC      drivers/tty/serial/8250/8250_dwlib.o
  CC      mm/backing-dev.o
  CC      fs/isofs/export.o
  CC      net/wireless/reg.o
  CC      net/wireless/scan.o
  CC      kernel/irq/matrix.o
  CC      fs/proc/namespaces.o
  CC      net/sunrpc/socklib.o
  CC      net/rfkill/input.o
  CC      drivers/char/hpet.o
  CC      fs/nfs/direct.o
  CC      net/core/rtnetlink.o
  CC      sound/hda/hdac_bus.o
  CC      net/ipv6/ip6_fib.o
  CC      net/ethtool/eee.o
  CC      drivers/base/power/wakeirq.o
  CC      arch/x86/kernel/cpu/tsx.o
  CC      net/ethtool/tsinfo.o
  CC      lib/cmdline.o
  CC      net/netfilter/nf_conntrack_acct.o
  CC      drivers/acpi/acpica/exoparg2.o
  CC      net/netfilter/nf_conntrack_seqadj.o
  CC      crypto/crypto_null.o
  CC      security/selinux/netlabel.o
  CC      lib/cpumask.o
  CC      fs/lockd/clntxdr.o
  CC      drivers/gpu/drm/ttm/ttm_execbuf_util.o
  CC      fs/lockd/host.o
  AR      fs/fat/built-in.a
  CC      net/netfilter/nf_conntrack_proto_icmpv6.o
  CC      fs/ext4/indirect.o
  AR      net/xfrm/built-in.a
  CC      net/ipv4/tcp_input.o
  CC      net/netlabel/netlabel_cipso_v4.o
  CC      net/ethtool/cabletest.o
  CC      arch/x86/kernel/cpu/intel_epb.o
  CC      fs/isofs/joliet.o
  CC      drivers/tty/serial/8250/8250_pcilib.o
  CC      drivers/base/power/main.o
  CC      drivers/acpi/acpica/exoparg3.o
  CC      net/ethtool/tunnels.o
  CC      io_uring/msg_ring.o
  AR      net/rfkill/built-in.a
  CC      fs/netfs/write_issue.o
  CC      drivers/pci/vc.o
  CC      drivers/gpu/drm/i915/i915_config.o
  CC      block/ioprio.o
  CC      net/sunrpc/xprtsock.o
  CC      fs/proc/self.o
  CC      sound/hda/hdac_device.o
  CC      crypto/md5.o
  CC      lib/ctype.o
  CC      lib/dec_and_lock.o
  CC      net/ipv4/tcp_output.o
  CC      mm/mm_init.o
  CC      drivers/gpu/drm/i915/i915_driver.o
  CC      fs/proc/thread_self.o
  CC      drivers/char/nvram.o
  CC      arch/x86/kernel/cpu/amd.o
  CC      drivers/gpu/drm/ttm/ttm_range_manager.o
  CC      drivers/acpi/acpica/exoparg6.o
  CC      net/sunrpc/sched.o
  CC      net/sunrpc/auth_gss/gss_krb5_keys.o
  CC      drivers/acpi/wakeup.o
  CC      lib/decompress.o
  CC      lib/decompress_bunzip2.o
  CC      drivers/base/firmware_loader/builtin/main.o
  CC      drivers/tty/serial/serial_base_bus.o
  CC      fs/isofs/compress.o
  AR      kernel/irq/built-in.a
  CC      kernel/dma/mapping.o
  CC      drivers/tty/serial/8250/8250_early.o
  CC      kernel/entry/common.o
  CC      kernel/module/main.o
  CC      drivers/acpi/acpica/exprep.o
  CC      crypto/sha256_generic.o
  CC      drivers/pci/mmap.o
  CC      net/sunrpc/auth.o
  CC      net/mac80211/offchannel.o
  CC      io_uring/advise.o
  AR      sound/virtio/built-in.a
  AR      security/selinux/built-in.a
  AR      drivers/base/firmware_loader/builtin/built-in.a
  CC      block/badblocks.o
  AR      security/built-in.a
  CC      drivers/base/firmware_loader/main.o
  CC      kernel/dma/direct.o
  CC      fs/proc/proc_sysctl.o
  AR      drivers/gpu/drm/renesas/rcar-du/built-in.a
  AR      drivers/gpu/drm/renesas/rz-du/built-in.a
  AR      drivers/gpu/drm/renesas/built-in.a
  CC      net/wireless/nl80211.o
  CC      fs/netfs/write_retry.o
  CC      drivers/gpu/drm/ttm/ttm_resource.o
  CC      mm/percpu.o
  CC      fs/lockd/svc.o
  CC      net/netfilter/nf_conntrack_netlink.o
  CC      net/netlabel/netlabel_calipso.o
In file included from /workspace/kernel/drivers/gpu/drm/i915/display/intel_bw.h:12,
                 from /workspace/kernel/drivers/gpu/drm/i915/i915_driver.c:50:
/workspace/kernel/drivers/gpu/drm/i915/display/intel_display_power.h: In function ‘intel_display_power_put’:
/workspace/kernel/drivers/gpu/drm/i915/display/intel_display_power.h:228:43: error: passing argument 1 of ‘intel_display_power_put_unchecked’ from incompatible pointer type [-Werror=incompatible-pointer-types]
  228 |         intel_display_power_put_unchecked(display, domain);
      |                                           ^~~~~~~
      |                                           |
      |                                           struct intel_display *
  CC      drivers/gpu/drm/display/drm_hdcp_helper.o
  CC      drivers/acpi/acpica/exregion.o
/workspace/kernel/drivers/gpu/drm/i915/display/intel_display_power.h:220:65: note: expected ‘struct drm_i915_private *’ but argument is of type ‘struct intel_display *’
  220 | void intel_display_power_put_unchecked(struct drm_i915_private *dev_priv,
      |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~
  CC      arch/x86/kernel/cpu/hygon.o
  CC      sound/hda/hdac_sysfs.o
  AR      drivers/char/built-in.a
  CC      net/ethtool/fec.o
  CC      drivers/gpu/drm/i915/i915_drm_client.o
  CC      drivers/tty/serial/8250/8250_exar.o
  CC      net/netfilter/nf_conntrack_ftp.o
  CC      lib/decompress_inflate.o
  CC      kernel/module/strict_rwx.o
  CC      crypto/sha512_generic.o
  CC      net/9p/mod.o
  CC      fs/nfs/pagelist.o
  CC      drivers/pci/devres.o
  AR      fs/isofs/built-in.a
  CC      fs/nfs/read.o
  CC      drivers/acpi/acpica/exresnte.o
  CC      drivers/base/power/wakeup.o
  CC      fs/ext4/inline.o
  CC      drivers/acpi/acpica/exresolv.o
  CC      drivers/tty/n_tty.o
  CC      io_uring/epoll.o
  AR      net/sunrpc/auth_gss/built-in.a
  CC      sound/sound_core.o
  CC      arch/x86/kernel/cpu/centaur.o
  CC      kernel/entry/syscall_user_dispatch.o
  CC      block/blk-rq-qos.o
  CC      lib/decompress_unlz4.o
  CC      drivers/base/regmap/regmap.o
  AR      drivers/base/firmware_loader/built-in.a
  CC      arch/x86/kernel/platform-quirks.o
  CC      drivers/gpu/drm/display/drm_hdmi_helper.o
cc1: all warnings being treated as errors
make[6]: *** [/workspace/kernel/scripts/Makefile.build:207: drivers/gpu/drm/i915/i915_driver.o] Error 1
make[6]: *** Waiting for unfinished jobs....
  CC      drivers/gpu/drm/display/drm_scdc_helper.o
  AR      fs/netfs/built-in.a
  CC      fs/ext4/inode.o
  CC      net/ethtool/eeprom.o
  CC      net/9p/client.o
  CC      net/dns_resolver/dns_key.o
  CC      drivers/gpu/drm/ttm/ttm_pool.o
  CC      net/handshake/alert.o
  CC      sound/hda/hdac_regmap.o
In file included from /workspace/kernel/drivers/gpu/drm/i915/display/intel_display_core.h:23,
                 from /workspace/kernel/drivers/gpu/drm/i915/i915_drv.h:40,
                 from /workspace/kernel/drivers/gpu/drm/i915/gt/intel_context.h:14,
                 from /workspace/kernel/drivers/gpu/drm/i915/gem/i915_gem_context.h:12,
                 from /workspace/kernel/drivers/gpu/drm/i915/i915_drm_client.c:14:
/workspace/kernel/drivers/gpu/drm/i915/display/intel_display_power.h: In function ‘intel_display_power_put’:
/workspace/kernel/drivers/gpu/drm/i915/display/intel_display_power.h:228:43: error: passing argument 1 of ‘intel_display_power_put_unchecked’ from incompatible pointer type [-Werror=incompatible-pointer-types]
  228 |         intel_display_power_put_unchecked(display, domain);
      |                                           ^~~~~~~
      |                                           |
      |                                           struct intel_display *
/workspace/kernel/drivers/gpu/drm/i915/display/intel_display_power.h:220:65: note: expected ‘struct drm_i915_private *’ but argument is of type ‘struct intel_display *’
  220 | void intel_display_power_put_unchecked(struct drm_i915_private *dev_priv,
      |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~
  CC      drivers/acpi/acpica/exresop.o
  CC      net/devres.o
  CC      arch/x86/kernel/cpu/transmeta.o
  CC      crypto/sha3_generic.o
  AR      net/netlabel/built-in.a
  CC      fs/lockd/svclock.o
  CC      drivers/pci/proc.o
  CC      drivers/tty/serial/8250/8250_lpss.o
  CC      crypto/ecb.o
  CC      net/9p/error.o
  AR      kernel/entry/built-in.a
  CC      kernel/dma/ops_helpers.o
  CC      lib/decompress_unlzma.o
cc1: all warnings being treated as errors
make[6]: *** [/workspace/kernel/scripts/Makefile.build:207: drivers/gpu/drm/i915/i915_drm_client.o] Error 1
  CC      net/core/utils.o
make[5]: *** [/workspace/kernel/scripts/Makefile.build:465: drivers/gpu/drm/i915] Error 2
make[5]: *** Waiting for unfinished jobs....
  CC      net/wireless/mlme.o
  CC      io_uring/statx.o
  CC      fs/proc/proc_net.o
  CC      drivers/acpi/acpica/exserial.o
  CC      block/disk-events.o
  CC      drivers/tty/serial/serial_ctrl.o
  CC      net/dns_resolver/dns_query.o
  CC      mm/slab_common.o
  CC      drivers/tty/tty_ioctl.o
  CC      arch/x86/kernel/cpu/zhaoxin.o
  CC      crypto/cbc.o
  AR      drivers/gpu/drm/display/built-in.a
  CC      crypto/ctr.o
  CC      drivers/base/regmap/regcache.o
  CC      drivers/base/power/wakeup_stats.o
  CC      fs/nfs/symlink.o
  CC      drivers/base/component.o
  AR      drivers/base/test/built-in.a
  CC      sound/hda/hdac_controller.o
  CC      drivers/tty/tty_ldisc.o
  CC      drivers/acpi/acpica/exstore.o
  CC      kernel/module/kmod.o
  CC      net/netfilter/nf_conntrack_irc.o
  CC      drivers/gpu/drm/ttm/ttm_device.o
  CC      drivers/tty/serial/8250/8250_mid.o
  CC      mm/compaction.o
  CC      net/ethtool/stats.o
  CC      kernel/dma/remap.o
  CC      fs/lockd/svcshare.o
  CC      net/mac80211/ht.o
  CC      drivers/pci/pci-sysfs.o
  CC      net/ipv6/ipv6_sockglue.o
  CC      sound/last.o
  CC      io_uring/timeout.o
  CC      arch/x86/kernel/cpu/vortex.o
  CC      kernel/time/time.o
  CC      io_uring/fdinfo.o
  CC      lib/decompress_unlzo.o
  CC      fs/lockd/svcproc.o
  CC      net/ipv6/ndisc.o
  CC      drivers/base/power/trace.o
  CC      crypto/gcm.o
  CC      crypto/ccm.o
  CC      drivers/acpi/acpica/exstoren.o
  CC      fs/nfs/unlink.o
  CC      net/handshake/genl.o
  CC      fs/proc/kcore.o
  AR      net/dns_resolver/built-in.a
  CC      block/blk-ia-ranges.o
  CC      fs/nls/nls_base.o
  CC      drivers/gpu/drm/ttm/ttm_sys_manager.o
  CC      fs/proc/vmcore.o
  CC      drivers/tty/serial/serial_port.o
  CC      crypto/aes_generic.o
  CC      net/netfilter/nf_conntrack_sip.o
  CC      arch/x86/kernel/cpu/perfctr-watchdog.o
  CC      drivers/base/core.o
  CC      drivers/tty/serial/8250/8250_pci.o
  CC      net/core/link_watch.o
  CC      kernel/module/tree_lookup.o
  AR      kernel/dma/built-in.a
  CC      drivers/pci/slot.o
  CC      drivers/tty/serial/8250/8250_pericom.o
  CC      drivers/gpu/drm/ttm/ttm_agp_backend.o
  CC      drivers/acpi/acpica/exstorob.o
  CC      net/handshake/netlink.o
  CC      drivers/base/bus.o
  CC      fs/proc/kmsg.o
  CC      sound/hda/hdac_stream.o
  CC      net/9p/protocol.o
  CC      lib/decompress_unxz.o
  CC      fs/nls/nls_cp437.o
  CC      net/ethtool/phc_vclocks.o
  CC      block/early-lookup.o
  AR      drivers/base/power/built-in.a
  CC      block/bounce.o
  CC      drivers/acpi/acpica/exsystem.o
  CC      net/sunrpc/auth_null.o
  CC      drivers/tty/serial/earlycon.o
  CC      drivers/tty/tty_buffer.o
  CC      lib/decompress_unzstd.o
  CC      kernel/time/timer.o
  AR      fs/unicode/built-in.a
  CC      crypto/authenc.o
  CC      drivers/acpi/acpica/extrace.o
  CC      io_uring/cancel.o
  CC      arch/x86/kernel/cpu/vmware.o
  CC      lib/dump_stack.o
  CC      fs/nls/nls_ascii.o
  CC      kernel/module/kallsyms.o
  CC      drivers/acpi/sleep.o
  CC      net/handshake/request.o
  CC      drivers/block/loop.o
  CC      net/ipv4/tcp_timer.o
  AR      drivers/gpu/drm/ttm/built-in.a
  CC      drivers/misc/eeprom/eeprom_93cx6.o
make[4]: *** [/workspace/kernel/scripts/Makefile.build:465: drivers/gpu/drm] Error 2
  CC      net/handshake/tlshd.o
make[3]: *** [/workspace/kernel/scripts/Makefile.build:465: drivers/gpu] Error 2
make[3]: *** Waiting for unfinished jobs....
  CC      kernel/time/hrtimer.o
  CC      drivers/block/virtio_blk.o
  CC      net/ipv6/udp.o
  CC      mm/show_mem.o
  CC      drivers/pci/pci-acpi.o
  CC      fs/lockd/svcsubs.o
  CC      drivers/pci/iomap.o
  CC      kernel/module/procfs.o
  CC      fs/proc/page.o
  CC      drivers/base/regmap/regcache-rbtree.o
  CC      drivers/acpi/acpica/exutils.o
  CC      drivers/tty/tty_port.o
  CC      fs/nls/nls_iso8859-1.o
  CC      net/9p/trans_common.o
  CC      drivers/tty/tty_mutex.o
  AR      drivers/misc/eeprom/built-in.a
  AR      drivers/misc/cb710/built-in.a
  CC      fs/autofs/init.o
  CC      net/core/filter.o
  AR      drivers/misc/lis3lv02d/built-in.a
  CC      sound/hda/array.o
  AR      drivers/misc/cardreader/built-in.a
  CC      net/mac80211/agg-tx.o
  AR      drivers/misc/keba/built-in.a
  AR      drivers/misc/built-in.a
  CC      fs/autofs/inode.o
  CC      fs/9p/vfs_super.o
  CC      net/ethtool/mm.o
  CC      lib/earlycpio.o
  CC      arch/x86/kernel/cpu/hypervisor.o
  CC      io_uring/waitid.o
  CC      lib/extable.o
  CC      fs/nfs/write.o
  CC      drivers/acpi/acpica/hwacpi.o
  AR      drivers/tty/serial/8250/built-in.a
  AR      drivers/tty/serial/built-in.a
  CC      fs/nls/nls_utf8.o
  CC      block/bsg.o
  CC      arch/x86/kernel/cpu/mshyperv.o
  CC      fs/autofs/root.o
  CC      kernel/module/sysfs.o
  CC      drivers/base/dd.o
  CC      kernel/time/sleep_timeout.o
  CC      kernel/futex/core.o
  CC      net/core/sock_diag.o
  CC      net/9p/trans_fd.o
  CC      crypto/authencesn.o
  CC      drivers/base/regmap/regcache-flat.o
  CC      net/9p/trans_virtio.o
  CC      fs/ext4/ioctl.o
  CC      block/blk-cgroup.o
  CC      drivers/base/syscore.o
  AR      fs/proc/built-in.a
  CC      net/core/dev_ioctl.o
  CC      drivers/acpi/acpica/hwesleep.o
  CC      net/netfilter/nf_nat_core.o
  CC      drivers/tty/tty_ldsem.o
  CC      drivers/tty/tty_baudrate.o
  AR      fs/nls/built-in.a
  CC      kernel/cgroup/cgroup.o
  CC      net/netfilter/nf_nat_proto.o
  CC      net/ipv6/udplite.o
  CC      lib/flex_proportions.o
  CC      drivers/acpi/device_sysfs.o
  CC      sound/hda/hdmi_chmap.o
  CC      drivers/acpi/device_pm.o
  CC      drivers/pci/quirks.o
  CC      fs/9p/vfs_inode.o
  CC      net/netfilter/nf_nat_helper.o
  CC      fs/lockd/mon.o
  CC      net/handshake/trace.o
  CC      mm/interval_tree.o
  CC      sound/hda/trace.o
  CC      fs/ext4/mballoc.o
  CC      net/sunrpc/auth_tls.o
  CC      net/ipv4/tcp_ipv4.o
  CC      drivers/acpi/acpica/hwgpe.o
  CC      drivers/base/regmap/regcache-maple.o
  CC      kernel/futex/syscalls.o
  AR      drivers/block/built-in.a
  CC      lib/idr.o
  CC      kernel/cgroup/rstat.o
  CC      io_uring/register.o
  AR      kernel/module/built-in.a
  CC      net/ipv6/raw.o
  CC      net/ethtool/module.o
  CC      fs/autofs/symlink.o
  CC      kernel/time/timekeeping.o
  CC      arch/x86/kernel/process_32.o
  CC      net/core/tso.o
  CC      arch/x86/kernel/cpu/debugfs.o
  CC      drivers/base/regmap/regmap-debugfs.o
  CC      drivers/tty/tty_jobctrl.o
  CC      net/wireless/ibss.o
  CC      net/mac80211/agg-rx.o
  CC      drivers/acpi/acpica/hwregs.o
  CC      drivers/pci/pci-label.o
  CC      crypto/lzo.o
  CC      net/core/sock_reuseport.o
  CC      lib/iomem_copy.o
  CC      fs/lockd/trace.o
  CC      kernel/time/ntp.o
  CC      net/ipv4/tcp_minisocks.o
  AR      fs/hostfs/built-in.a
  CC      lib/irq_regs.o
  CC      mm/list_lru.o
  CC      kernel/cgroup/namespace.o
  CC      net/ipv4/tcp_cong.o
  AR      net/9p/built-in.a
  CC      net/core/fib_notifier.o
  CC      net/netfilter/nf_nat_masquerade.o
  CC      fs/autofs/waitq.o
  CC      arch/x86/kernel/cpu/bus_lock.o
  CC      drivers/acpi/acpica/hwsleep.o
  CC      sound/hda/hdac_component.o
  CC      lib/is_single_threaded.o
  CC      kernel/trace/trace_clock.o
  CC      kernel/futex/pi.o
  CC      fs/9p/vfs_inode_dotl.o
  CC      arch/x86/kernel/signal.o
  CC      net/ipv4/tcp_metrics.o
  CC      drivers/tty/n_null.o
  CC      net/wireless/sme.o
  CC      block/blk-ioprio.o
  CC      net/mac80211/vht.o
  AR      drivers/base/regmap/built-in.a
  CC      drivers/base/driver.o
  CC      net/sunrpc/auth_unix.o
  CC      crypto/lzo-rle.o
  CC      net/sunrpc/svc.o
  CC      kernel/bpf/core.o
  CC      kernel/events/core.o
  CC      net/wireless/chan.o
  CC      drivers/acpi/acpica/hwvalid.o
  CC      net/socket.o
  CC      net/ipv4/tcp_fastopen.o
  CC      net/ethtool/cmis_fw_update.o
  CC      kernel/trace/ring_buffer.o
  AR      net/handshake/built-in.a
  CC      lib/klist.o
  CC      arch/x86/kernel/signal_32.o
  CC      crypto/rng.o
  CC      block/blk-iolatency.o
  CC      kernel/time/clocksource.o
  CC      mm/workingset.o
  CC      sound/hda/hdac_i915.o
  CC      drivers/tty/pty.o
  CC      drivers/base/class.o
  CC      drivers/tty/tty_audit.o
  CC      lib/kobject.o
  CC      drivers/acpi/acpica/hwxface.o
  CC      fs/nfs/namespace.o
  CC      io_uring/truncate.o
  CC      fs/autofs/expire.o
  CC      net/ipv4/tcp_rate.o
  CC      kernel/time/jiffies.o
  CC      fs/lockd/xdr.o
  CC      net/wireless/ethtool.o
  CC      kernel/futex/requeue.o
  CC      fs/nfs/mount_clnt.o
  CC      fs/9p/vfs_addr.o
  CC      arch/x86/kernel/cpu/capflags.o
  AR      arch/x86/kernel/cpu/built-in.a
  CC      net/sunrpc/svcsock.o
  CC      drivers/acpi/acpica/hwxfsleep.o
  CC      drivers/pci/vgaarb.o
  CC      io_uring/memmap.o
  CC      net/ipv6/icmp.o
  CC      net/netfilter/nf_nat_ftp.o
  CC      lib/kobject_uevent.o
  CC      net/mac80211/he.o
  CC      fs/nfs/nfstrace.o
  CC      sound/hda/intel-dsp-config.o
  CC      crypto/drbg.o
  CC      arch/x86/kernel/traps.o
  CC      net/ethtool/cmis_cdb.o
  CC      kernel/events/ring_buffer.o
  CC      kernel/cgroup/cgroup-v1.o
  CC      drivers/acpi/acpica/hwpci.o
  CC      mm/debug.o
  CC      drivers/base/platform.o
  CC      fs/nfs/export.o
  CC      drivers/tty/sysrq.o
  CC      kernel/time/timer_list.o
  CC      fs/debugfs/inode.o
  CC      net/wireless/mesh.o
  CC      sound/hda/intel-nhlt.o
  CC      kernel/futex/waitwake.o
  CC      fs/autofs/dev-ioctl.o
  CC      io_uring/alloc_cache.o
  CC      drivers/acpi/proc.o
  CC      fs/9p/vfs_file.o
  CC      block/blk-iocost.o
  CC      crypto/jitterentropy.o
  CC      drivers/acpi/acpica/nsaccess.o
  CC      fs/nfs/sysfs.o
  CC      net/ipv6/mcast.o
  CC      drivers/base/cpu.o
  CC      lib/logic_pio.o
  CC      fs/9p/vfs_dir.o
  CC      mm/gup.o
  CC      net/ipv4/tcp_recovery.o
  CC      fs/lockd/clnt4xdr.o
  CC      sound/hda/intel-sdw-acpi.o
  AR      drivers/pci/built-in.a
  CC      net/netfilter/nf_nat_irc.o
  CC      crypto/jitterentropy-kcapi.o
  CC      kernel/time/timeconv.o
  CC      net/ipv6/reassembly.o
  CC      kernel/events/callchain.o
  CC      drivers/acpi/acpica/nsalloc.o
  CC      io_uring/io-wq.o
  CC      kernel/events/hw_breakpoint.o
  CC      lib/maple_tree.o
  AR      kernel/futex/built-in.a
  CC      fs/debugfs/file.o
  CC      arch/x86/kernel/idt.o
  CC      net/ipv6/tcp_ipv6.o
  AR      drivers/tty/built-in.a
  CC      arch/x86/kernel/irq.o
  CC      net/ethtool/pse-pd.o
  CC      crypto/ghash-generic.o
  CC      net/ethtool/plca.o
  AR      fs/autofs/built-in.a
  CC      fs/ext4/migrate.o
  CC      drivers/acpi/bus.o
  CC      net/core/xdp.o
  CC      io_uring/futex.o
  CC      kernel/trace/trace.o
  CC      kernel/time/timecounter.o
  AR      sound/hda/built-in.a
  AR      sound/built-in.a
  CC      net/mac80211/s1g.o
  CC      kernel/time/alarmtimer.o
  CC      drivers/acpi/acpica/nsarguments.o
  CC      fs/nfs/fs_context.o
  CC      fs/9p/vfs_dentry.o
  CC      net/ethtool/phy.o
  CC      kernel/trace/trace_output.o
  CC      net/netfilter/nf_nat_sip.o
  CC      net/netfilter/x_tables.o
  CC      drivers/base/firmware.o
  CC      kernel/fork.o
  CC      crypto/hash_info.o
  CC      crypto/rsapubkey.asn1.o
  CC      io_uring/napi.o
  CC      net/sunrpc/svcauth.o
  CC      crypto/rsaprivkey.asn1.o
  CC      net/ipv4/tcp_ulp.o
  AR      crypto/built-in.a
  CC      kernel/time/posix-timers.o
  CC      kernel/cgroup/freezer.o
  CC      net/sysctl_net.o
  CC      drivers/acpi/acpica/nsconvert.o
  AR      kernel/bpf/built-in.a
  CC      kernel/cgroup/legacy_freezer.o
  CC      fs/lockd/xdr4.o
  CC      kernel/cgroup/pids.o
  CC      drivers/acpi/glue.o
  CC      drivers/base/init.o
  CC      net/mac80211/ibss.o
  CC      net/ipv6/ping.o
  CC      mm/mmap_lock.o
  CC      net/core/flow_offload.o
  CC      fs/9p/v9fs.o
  CC      drivers/acpi/acpica/nsdump.o
  CC      fs/ext4/mmp.o
  CC      net/sunrpc/svcauth_unix.o
  CC      lib/memcat_p.o
  CC      fs/9p/fid.o
  AR      fs/debugfs/built-in.a
  CC      fs/ext4/move_extent.o
  CC      kernel/time/posix-cpu-timers.o
  CC      block/mq-deadline.o
  CC      net/core/gro.o
  CC      drivers/acpi/acpica/nseval.o
  CC      block/kyber-iosched.o
  CC      kernel/trace/trace_seq.o
  CC      arch/x86/kernel/irq_32.o
  CC      net/ethtool/tsconfig.o
  CC      drivers/base/map.o
  CC      net/ipv4/tcp_offload.o
  CC      fs/nfs/nfsroot.o
  CC      kernel/cgroup/rdma.o
  CC      drivers/acpi/acpica/nsinit.o
  CC      net/mac80211/iface.o
  CC      fs/lockd/svc4proc.o
  CC      kernel/trace/trace_stat.o
  CC      fs/ext4/namei.o
  CC      fs/tracefs/inode.o
  CC      kernel/cgroup/cpuset.o
  CC      arch/x86/kernel/dumpstack_32.o
  CC      drivers/acpi/scan.o
  CC      fs/nfs/sysctl.o
  CC      block/blk-mq-debugfs.o
  CC [M]  fs/efivarfs/inode.o
  CC      mm/highmem.o
  CC      fs/open.o
  CC      fs/9p/xattr.o
  CC      drivers/base/devres.o
  CC      kernel/cgroup/misc.o
  CC      drivers/acpi/acpica/nsload.o
  CC      net/core/netdev-genl.o
  CC      fs/tracefs/event_inode.o
  AR      io_uring/built-in.a
  CC      net/ipv6/exthdrs.o
  CC      lib/nmi_backtrace.o
  CC      drivers/acpi/mipi-disco-img.o
  CC      drivers/acpi/resource.o
  CC      fs/nfs/nfs3super.o
  CC [M]  fs/efivarfs/file.o
  CC      fs/read_write.o
  CC      net/wireless/ap.o
  CC      kernel/exec_domain.o
  CC      kernel/time/posix-clock.o
  CC      net/netfilter/xt_tcpudp.o
  CC      lib/objpool.o
  CC      drivers/acpi/acpica/nsnames.o
  CC      drivers/base/attribute_container.o
  CC      net/mac80211/link.o
  CC      net/ipv6/datagram.o
  CC      arch/x86/kernel/time.o
  CC      arch/x86/kernel/ioport.o
  AR      net/ethtool/built-in.a
  CC      drivers/base/transport_class.o
  CC      net/ipv4/tcp_plb.o
  CC      fs/file_table.o
  CC      kernel/time/itimer.o
  CC      net/wireless/trace.o
  AR      fs/9p/built-in.a
  CC      net/wireless/ocb.o
  CC      net/netfilter/xt_CONNSECMARK.o
  CC      kernel/events/uprobes.o
  CC      drivers/acpi/acpica/nsobject.o
  CC      fs/ext4/page-io.o
  CC [M]  fs/efivarfs/super.o
  CC      block/blk-pm.o
  CC      net/mac80211/rate.o
  CC      fs/super.o
  CC      mm/memory.o
  CC      fs/lockd/procfs.o
  CC      arch/x86/kernel/dumpstack.o
  CC      net/ipv4/datagram.o
  CC      kernel/cgroup/debug.o
  CC      kernel/panic.o
  CC      fs/nfs/nfs3client.o
  CC      kernel/trace/trace_printk.o
  CC      block/holder.o
  CC      net/core/netdev-genl-gen.o
  CC      net/mac80211/michael.o
  AR      fs/tracefs/built-in.a
  CC [M]  fs/efivarfs/vars.o
  CC      drivers/base/topology.o
  CC      net/ipv4/raw.o
  CC      mm/mincore.o
  CC      drivers/acpi/acpica/nsparse.o
  CC      net/netfilter/xt_NFLOG.o
  CC      drivers/acpi/acpica/nspredef.o
  CC      fs/nfs/nfs3proc.o
  CC      net/sunrpc/addr.o
  CC      fs/char_dev.o
  CC      lib/plist.o
  CC      fs/ext4/readpage.o
  CC      kernel/trace/pid_list.o
  CC      net/netfilter/xt_SECMARK.o
  CC      drivers/acpi/acpi_processor.o
  CC      kernel/time/clockevents.o
  AR      fs/lockd/built-in.a
  CC      net/netfilter/xt_TCPMSS.o
  CC      net/ipv4/udp.o
  CC      net/wireless/pmsr.o
  AR      block/built-in.a
  CC      arch/x86/kernel/nmi.o
  CC      net/ipv4/udplite.o
  CC      lib/radix-tree.o
  CC      kernel/cpu.o
  CC      drivers/acpi/acpica/nsprepkg.o
  CC      fs/nfs/nfs3xdr.o
  CC      kernel/time/tick-common.o
  CC      drivers/base/container.o
  LD [M]  fs/efivarfs/efivarfs.o
  CC      net/mac80211/tkip.o
  CC      net/core/gso.o
  CC      net/core/net-sysfs.o
  CC      kernel/time/tick-broadcast.o
  CC      net/mac80211/aes_cmac.o
  CC      net/sunrpc/rpcb_clnt.o
  AR      kernel/cgroup/built-in.a
  CC      lib/ratelimit.o
  CC      net/ipv6/ip6_flowlabel.o
  CC      lib/rbtree.o
  CC      fs/ext4/resize.o
  CC      fs/nfs/nfs3acl.o
  CC      net/mac80211/aes_gmac.o
  CC      arch/x86/kernel/ldt.o
  CC      drivers/acpi/processor_core.o
  CC      drivers/base/property.o
  CC      net/sunrpc/timer.o
  CC      drivers/acpi/acpica/nsrepair.o
  CC      net/netfilter/xt_conntrack.o
  GEN     net/wireless/shipped-certs.c
  CC      drivers/base/cacheinfo.o
  CC      drivers/acpi/processor_pdc.o
  CC      fs/ext4/super.o
  CC      kernel/exit.o
  CC      net/sunrpc/xdr.o
  CC      kernel/trace/trace_sched_switch.o
  CC      net/ipv4/udp_offload.o
  CC      net/netfilter/xt_policy.o
  CC      fs/nfs/nfs4proc.o
  CC      net/mac80211/fils_aead.o
  CC      drivers/base/swnode.o
  CC      arch/x86/kernel/setup.o
  CC      fs/nfs/nfs4xdr.o
  AR      kernel/events/built-in.a
  CC      kernel/trace/trace_nop.o
  CC      net/netfilter/xt_state.o
  CC      net/core/hotdata.o
  CC      drivers/acpi/acpica/nsrepair2.o
  CC      arch/x86/kernel/x86_init.o
  CC      kernel/softirq.o
  CC      mm/mlock.o
  CC      kernel/trace/blktrace.o
  CC      fs/stat.o
  CC      lib/seq_buf.o
  CC      kernel/time/tick-broadcast-hrtimer.o
  CC      kernel/time/tick-oneshot.o
  CC      kernel/time/tick-sched.o
  CC      kernel/trace/trace_events.o
  CC      kernel/resource.o
  CC      mm/mmap.o
  CC      net/ipv6/inet6_connection_sock.o
  CC      drivers/acpi/acpica/nssearch.o
  CC      net/ipv4/arp.o
  CC      fs/nfs/nfs4state.o
  CC      kernel/time/timer_migration.o
  CC      kernel/time/vsyscall.o
  CC [M]  net/netfilter/nf_log_syslog.o
  CC      arch/x86/kernel/i8259.o
  CC      kernel/trace/trace_export.o
  CC      net/ipv6/udp_offload.o
  CC      drivers/base/auxiliary.o
  CC      net/ipv4/icmp.o
  CC      fs/exec.o
  CC      net/mac80211/cfg.o
  CC      drivers/acpi/acpica/nsutils.o
  CC      net/sunrpc/sunrpc_syms.o
  CC      kernel/sysctl.o
  CC      kernel/time/timekeeping_debug.o
  CC      lib/siphash.o
  CC      lib/string.o
  CC      net/ipv6/seg6.o
  CC      fs/pipe.o
  CC      net/mac80211/ethtool.o
  CC      net/mac80211/rx.o
  CC [M]  net/netfilter/xt_mark.o
  CC      net/sunrpc/cache.o
  CC      fs/ext4/symlink.o
  CC      net/core/netdev_rx_queue.o
  CC      drivers/acpi/ec.o
  CC      net/core/net-procfs.o
  CC      kernel/time/namespace.o
  CC      arch/x86/kernel/irqinit.o
  CC      drivers/base/devtmpfs.o
  CC      kernel/capability.o
  CC      drivers/acpi/dock.o
  CC      net/ipv6/fib6_notifier.o
  CC      drivers/acpi/acpica/nswalk.o
  CC      drivers/acpi/acpica/nsxfeval.o
  CC      net/core/netpoll.o
  CC      fs/nfs/nfs4renewd.o
  CC [M]  net/netfilter/xt_nat.o
  CC      fs/nfs/nfs4super.o
  CC      lib/timerqueue.o
  CC      drivers/base/module.o
  CC      fs/ext4/sysfs.o
  CC      net/ipv6/rpl.o
  CC      net/ipv6/ioam6.o
  CC      net/ipv4/devinet.o
  CC      lib/union_find.o
  CC      lib/vsprintf.o
  CC      fs/namei.o
  CC      arch/x86/kernel/jump_label.o
  CC      net/ipv4/af_inet.o
  CC      drivers/acpi/acpica/nsxfname.o
  CC      net/core/fib_rules.o
  CC      drivers/acpi/pci_root.o
  CC      kernel/ptrace.o
  CC [M]  net/netfilter/xt_LOG.o
  CC      mm/mmu_gather.o
  CC      fs/fcntl.o
  CC      net/wireless/shipped-certs.o
  CC      kernel/trace/trace_event_perf.o
  CC      arch/x86/kernel/irq_work.o
  CC      net/sunrpc/rpc_pipe.o
  CC      net/mac80211/spectmgmt.o
  CC      drivers/base/auxiliary_sysfs.o
  CC      fs/nfs/nfs4file.o
  CC      kernel/trace/trace_events_filter.o
  CC      net/mac80211/tx.o
  CC      fs/ext4/xattr.o
  AR      kernel/time/built-in.a
  CC      fs/ioctl.o
  CC      drivers/acpi/acpica/nsxfobj.o
  CC      lib/win_minmax.o
  CC      fs/readdir.o
  CC      net/sunrpc/sysfs.o
  CC      kernel/user.o
  CC      drivers/acpi/acpica/psargs.o
  CC      net/ipv4/igmp.o
  CC      kernel/trace/trace_events_trigger.o
  CC      net/mac80211/key.o
  CC [M]  net/netfilter/xt_MASQUERADE.o
  CC      mm/mprotect.o
  CC      net/ipv6/sysctl_net_ipv6.o
  CC      drivers/base/devcoredump.o
  CC      net/core/net-traces.o
  CC      arch/x86/kernel/probe_roms.o
  CC      fs/nfs/delegation.o
  CC      net/ipv4/fib_frontend.o
  CC      kernel/trace/trace_eprobe.o
  CC [M]  net/netfilter/xt_addrtype.o
  CC      drivers/base/platform-msi.o
  CC      drivers/acpi/pci_link.o
  CC      drivers/acpi/acpica/psloop.o
  CC      drivers/acpi/acpica/psobject.o
  CC      drivers/acpi/pci_irq.o
  CC      lib/xarray.o
  CC      kernel/trace/trace_kprobe.o
  CC      fs/ext4/xattr_hurd.o
  CC      arch/x86/kernel/sys_ia32.o
  CC      net/ipv6/xfrm6_policy.o
  CC      mm/mremap.o
  CC      net/sunrpc/svc_xprt.o
  CC      net/mac80211/util.o
  CC      drivers/acpi/acpica/psopcode.o
  CC      net/ipv4/fib_semantics.o
  CC      drivers/acpi/acpi_apd.o
  CC      drivers/base/physical_location.o
  CC      net/ipv4/fib_trie.o
  CC      lib/lockref.o
  CC      fs/nfs/nfs4idmap.o
  CC      net/sunrpc/xprtmultipath.o
  CC      fs/ext4/xattr_trusted.o
  CC      kernel/trace/error_report-traces.o
  CC      net/mac80211/parse.o
  CC      net/ipv4/fib_notifier.o
  CC      drivers/acpi/acpica/psopinfo.o
  CC      net/ipv6/xfrm6_state.o
  CC      drivers/base/trace.o
  CC      lib/bcd.o
  CC      fs/select.o
  CC      arch/x86/kernel/ksysfs.o
  CC      net/ipv4/inet_fragment.o
  CC      drivers/acpi/acpica/psparse.o
  CC      drivers/acpi/acpi_platform.o
  CC      mm/msync.o
  CC      kernel/signal.o
  CC      net/core/selftests.o
  CC      net/ipv4/ping.o
  CC      fs/nfs/callback.o
  CC      net/sunrpc/stats.o
  CC      kernel/sys.o
  CC      fs/dcache.o
  CC      lib/sort.o
  CC      mm/page_vma_mapped.o
  CC      drivers/acpi/acpica/psscope.o
  CC      kernel/trace/power-traces.o
  CC      net/core/ptp_classifier.o
  AR      net/netfilter/built-in.a
  CC      drivers/acpi/acpi_pnp.o
  CC      drivers/acpi/power.o
  CC      fs/nfs/callback_xdr.o
  CC      net/mac80211/wme.o
  CC      fs/nfs/callback_proc.o
  CC      fs/inode.o
  CC      net/ipv6/xfrm6_input.o
  CC      net/mac80211/chan.o
  CC      drivers/acpi/acpica/pstree.o
  CC      net/ipv4/ip_tunnel_core.o
  CC      arch/x86/kernel/bootflag.o
  CC      drivers/acpi/event.o
  CC      lib/parser.o
  AR      drivers/base/built-in.a
  CC      net/sunrpc/sysctl.o
  CC      kernel/trace/rpm-traces.o
  CC      fs/attr.o
  CC      net/ipv4/gre_offload.o
  CC      fs/nfs/nfs4namespace.o
  CC      net/ipv4/metrics.o
  CC      net/ipv4/netlink.o
  CC      fs/ext4/xattr_user.o
  CC      drivers/acpi/acpica/psutils.o
  CC      mm/pagewalk.o
  CC      fs/bad_inode.o
  CC      net/core/netprio_cgroup.o
  CC      kernel/umh.o
  CC      lib/debug_locks.o
  CC      net/core/netclassid_cgroup.o
  CC      drivers/acpi/acpica/pswalk.o
  CC      fs/file.o
  CC      net/ipv6/xfrm6_output.o
  CC      arch/x86/kernel/e820.o
  CC      mm/pgtable-generic.o
  CC      kernel/workqueue.o
  CC      drivers/acpi/evged.o
  CC      drivers/acpi/sysfs.o
  CC      lib/random32.o
  CC      drivers/acpi/acpica/psxface.o
  CC      fs/filesystems.o
  CC      net/mac80211/trace.o
  CC      net/core/dst_cache.o
  CC      kernel/pid.o
  CC      arch/x86/kernel/pci-dma.o
  CC      kernel/trace/trace_dynevent.o
  CC      mm/rmap.o
  CC      net/core/gro_cells.o
  CC      drivers/acpi/acpica/rsaddr.o
  CC      drivers/acpi/property.o
  CC      lib/bust_spinlocks.o
  CC      arch/x86/kernel/quirks.o
  CC      net/ipv6/xfrm6_protocol.o
  CC      kernel/task_work.o
  CC      drivers/acpi/debugfs.o
  CC      kernel/trace/trace_probe.o
  CC      fs/namespace.o
  CC      kernel/extable.o
  CC      drivers/acpi/acpi_lpat.o
  CC      arch/x86/kernel/kdebugfs.o
  CC      kernel/trace/trace_uprobe.o
  CC      mm/vmalloc.o
  AR      net/sunrpc/built-in.a
  CC      arch/x86/kernel/alternative.o
  CC      net/mac80211/mlme.o
  CC      net/ipv4/nexthop.o
  CC      kernel/params.o
  CC      fs/seq_file.o
  CC      fs/ext4/fast_commit.o
  CC      kernel/trace/rethook.o
  CC      drivers/acpi/acpica/rscalc.o
  CC      drivers/acpi/acpi_pcc.o
  CC      lib/kasprintf.o
  CC      fs/nfs/nfs4getroot.o
  CC      fs/ext4/orphan.o
  CC      net/ipv4/udp_tunnel_stub.o
  CC      drivers/acpi/acpica/rscreate.o
  CC      net/mac80211/tdls.o
  CC      drivers/acpi/ac.o
  CC      net/ipv6/netfilter.o
  CC      fs/xattr.o
  CC      mm/vma.o
  CC      lib/bitmap.o
  CC      lib/scatterlist.o
  CC      fs/nfs/nfs4client.o
  CC      fs/ext4/acl.o
  CC      net/mac80211/ocb.o
  CC      net/core/failover.o
  CC      fs/libfs.o
  CC      arch/x86/kernel/i8253.o
  CC      net/ipv4/ip_tunnel.o
  CC      fs/ext4/xattr_security.o
  CC      drivers/acpi/acpica/rsdumpinfo.o
  CC      fs/fs-writeback.o
  CC      arch/x86/kernel/hw_breakpoint.o
  CC      lib/list_sort.o
  CC      net/ipv6/proc.o
  CC      mm/process_vm_access.o
  CC      drivers/acpi/button.o
  CC      net/ipv4/sysctl_net_ipv4.o
  CC      net/ipv6/syncookies.o
  CC      drivers/acpi/acpica/rsinfo.o
  CC      drivers/acpi/fan_core.o
  CC      arch/x86/kernel/tsc.o
  CC      net/mac80211/airtime.o
  CC      kernel/kthread.o
  CC      fs/nfs/nfs4session.o
  CC      arch/x86/kernel/tsc_msr.o
  CC      mm/page_alloc.o
  CC      drivers/acpi/acpica/rsio.o
  CC      lib/uuid.o
  CC      net/ipv4/proc.o
  CC      net/mac80211/eht.o
  CC      drivers/acpi/fan_attr.o
  CC      kernel/sys_ni.o
  CC      lib/iov_iter.o
  CC      mm/page_frag_cache.o
  CC      net/mac80211/led.o
  CC      drivers/acpi/fan_hwmon.o
  CC      fs/pnode.o
  CC      net/ipv6/calipso.o
  CC      drivers/acpi/acpica/rsirq.o
  CC      arch/x86/kernel/io_delay.o
  CC      lib/clz_ctz.o
  CC      fs/splice.o
  AR      net/core/built-in.a
  CC      kernel/nsproxy.o
  CC      drivers/acpi/acpica/rslist.o
  CC      fs/nfs/dns_resolve.o
  CC      net/ipv6/ah6.o
  CC      drivers/acpi/acpica/rsmemory.o
  CC      net/ipv4/fib_rules.o
  CC      fs/sync.o
  CC      net/mac80211/pm.o
  CC      lib/bsearch.o
  CC      drivers/acpi/acpi_video.o
  CC      mm/init-mm.o
  AR      kernel/trace/built-in.a
  CC      net/ipv4/ipmr.o
  CC      fs/nfs/nfs4trace.o
  CC      drivers/acpi/acpica/rsmisc.o
  CC      lib/find_bit.o
  CC      arch/x86/kernel/rtc.o
  CC      fs/utimes.o
  CC      mm/memblock.o
  CC      kernel/notifier.o
  CC      net/ipv4/ipmr_base.o
  CC      net/mac80211/rc80211_minstrel_ht.o
  CC      mm/slub.o
  CC      net/ipv6/esp6.o
  CC      lib/llist.o
  CC      fs/nfs/nfs4sysctl.o
  CC      fs/d_path.o
  CC      arch/x86/kernel/resource.o
  AR      fs/ext4/built-in.a
  CC      fs/stack.o
  CC      fs/fs_struct.o
  CC      drivers/acpi/video_detect.o
  CC      lib/lwq.o
  CC      net/ipv4/syncookies.o
  CC      mm/madvise.o
  CC      drivers/acpi/acpica/rsserial.o
  AS      arch/x86/kernel/irqflags.o
  CC      drivers/acpi/processor_driver.o
  CC      net/ipv6/sit.o
  CC      fs/statfs.o
  CC      drivers/acpi/processor_thermal.o
  CC      lib/memweight.o
  CC      mm/page_io.o
  CC      arch/x86/kernel/static_call.o
  CC      drivers/acpi/processor_idle.o
  CC      net/ipv4/tunnel4.o
  CC      lib/kfifo.o
  CC      kernel/ksysfs.o
  CC      net/ipv4/ipconfig.o
  CC      fs/fs_pin.o
  CC      net/ipv6/addrconf_core.o
  CC      drivers/acpi/acpica/rsutils.o
  CC      fs/nsfs.o
  CC      lib/percpu-refcount.o
  CC      mm/swap_state.o
  CC      net/mac80211/wbrf.o
  CC      arch/x86/kernel/process.o
  CC      drivers/acpi/processor_throttling.o
  CC      net/ipv6/exthdrs_core.o
  CC      drivers/acpi/acpica/rsxface.o
  CC      arch/x86/kernel/ptrace.o
  AR      net/wireless/built-in.a
  CC      kernel/cred.o
  CC      drivers/acpi/processor_perflib.o
  CC      mm/swapfile.o
  CC      fs/fs_types.o
  CC      lib/rhashtable.o
  CC      arch/x86/kernel/tls.o
  CC      fs/fs_context.o
  CC      drivers/acpi/acpica/tbdata.o
  CC      fs/fs_parser.o
  CC      net/ipv4/netfilter.o
  CC      kernel/reboot.o
  CC      mm/swap_slots.o
  CC      fs/fsopen.o
  CC      net/ipv4/tcp_cubic.o
  CC      kernel/async.o
  CC      drivers/acpi/acpica/tbfadt.o
  CC      drivers/acpi/container.o
  CC      net/ipv6/ip6_checksum.o
  CC      net/ipv6/ip6_icmp.o
  CC      net/ipv4/tcp_sigpool.o
  CC      drivers/acpi/thermal_lib.o
  CC      fs/init.o
  CC      kernel/range.o
  CC      arch/x86/kernel/step.o
  CC      net/ipv6/output_core.o
  CC      drivers/acpi/acpica/tbfind.o
  CC      drivers/acpi/acpica/tbinstal.o
  CC      kernel/smpboot.o
  CC      net/ipv4/cipso_ipv4.o
  CC      net/ipv6/protocol.o
  CC      net/ipv6/ip6_offload.o
  CC      lib/base64.o
  CC      arch/x86/kernel/i8237.o
  CC      mm/dmapool.o
  CC      drivers/acpi/acpica/tbprint.o
  CC      kernel/ucount.o
  CC      drivers/acpi/thermal.o
  CC      net/ipv4/xfrm4_policy.o
  CC      arch/x86/kernel/stacktrace.o
  CC      fs/kernel_read_file.o
  CC      net/ipv6/tcpv6_offload.o
  CC      fs/mnt_idmapping.o
  CC      mm/hugetlb.o
  CC      drivers/acpi/acpica/tbutils.o
  CC      kernel/regset.o
  CC      arch/x86/kernel/reboot.o
  CC      net/ipv4/xfrm4_state.o
  CC      lib/once.o
  CC      mm/mmu_notifier.o
  CC      net/ipv4/xfrm4_input.o
  CC      mm/migrate.o
  CC      lib/refcount.o
  CC      arch/x86/kernel/msr.o
  CC      net/ipv4/xfrm4_output.o
  CC      drivers/acpi/acpica/tbxface.o
  CC      drivers/acpi/nhlt.o
  CC      drivers/acpi/acpica/tbxfload.o
  CC      net/ipv4/xfrm4_protocol.o
  CC      net/ipv6/exthdrs_offload.o
  CC      mm/page_counter.o
  CC      fs/remap_range.o
  CC      lib/rcuref.o
  CC      kernel/ksyms_common.o
  CC      fs/pidfs.o
  CC      kernel/groups.o
  CC      fs/buffer.o
  CC      lib/usercopy.o
  CC      net/ipv6/inet6_hashtables.o
  CC      mm/hugetlb_cgroup.o
  CC      drivers/acpi/acpica/tbxfroot.o
  CC      net/ipv6/mcast_snoop.o
  CC      fs/mpage.o
  CC      lib/errseq.o
  CC      drivers/acpi/acpica/utaddress.o
  CC      arch/x86/kernel/cpuid.o
  CC      mm/early_ioremap.o
  CC      mm/secretmem.o
  CC      kernel/kcmp.o
  CC      mm/hmm.o
  CC      arch/x86/kernel/early-quirks.o
  CC      mm/memfd.o
  CC      kernel/freezer.o
  CC      drivers/acpi/acpi_memhotplug.o
  CC      drivers/acpi/acpica/utalloc.o
  CC      drivers/acpi/ioapic.o
  CC      arch/x86/kernel/smp.o
  CC      lib/bucket_locks.o
  CC      kernel/profile.o
  CC      drivers/acpi/acpica/utascii.o
  CC      fs/proc_namespace.o
  CC      arch/x86/kernel/smpboot.o
  CC      lib/generic-radix-tree.o
  CC      mm/ptdump.o
  CC      drivers/acpi/acpica/utbuffer.o
  CC      arch/x86/kernel/tsc_sync.o
  CC      mm/execmem.o
  CC      kernel/stacktrace.o
  AR      fs/nfs/built-in.a
  CC      drivers/acpi/battery.o
  CC      lib/bitmap-str.o
  CC      drivers/acpi/acpica/utcksum.o
  CC      drivers/acpi/bgrt.o
  CC      arch/x86/kernel/setup_percpu.o
  CC      kernel/dma.o
  CC      arch/x86/kernel/mpparse.o
  CC      drivers/acpi/spcr.o
  CC      lib/string_helpers.o
  CC      fs/direct-io.o
  CC      fs/eventpoll.o
  CC      arch/x86/kernel/trace_clock.o
  CC      fs/anon_inodes.o
  CC      kernel/smp.o
  CC      lib/hexdump.o
  CC      arch/x86/kernel/trace.o
  CC      kernel/uid16.o
  CC      fs/signalfd.o
  CC      drivers/acpi/acpica/utcopy.o
  CC      lib/kstrtox.o
  CC      fs/timerfd.o
  CC      lib/iomap.o
  CC      kernel/kallsyms.o
  CC      drivers/acpi/acpica/utexcep.o
  CC      fs/eventfd.o
  CC      kernel/acct.o
  CC      lib/iomap_copy.o
  CC      kernel/vmcore_info.o
  CC      fs/aio.o
  CC      kernel/elfcorehdr.o
  CC      kernel/crash_reserve.o
  CC      drivers/acpi/acpica/utdebug.o
  CC      arch/x86/kernel/rethook.o
  CC      kernel/kexec_core.o
  CC      fs/locks.o
  CC      drivers/acpi/acpica/utdecode.o
  CC      lib/devres.o
  AR      net/ipv4/built-in.a
  CC      arch/x86/kernel/vmcore_info_32.o
  CC      kernel/crash_core.o
  CC      kernel/kexec.o
  CC      lib/check_signature.o
  CC      fs/binfmt_misc.o
  CC      arch/x86/kernel/machine_kexec_32.o
  CC      lib/interval_tree.o
  CC      drivers/acpi/acpica/utdelete.o
  AS      arch/x86/kernel/relocate_kernel_32.o
  CC      fs/binfmt_script.o
  CC      kernel/utsname.o
  CC      arch/x86/kernel/crash_dump_32.o
  CC      drivers/acpi/acpica/uterror.o
  CC      fs/binfmt_elf.o
  CC      lib/assoc_array.o
  CC      drivers/acpi/acpica/uteval.o
  CC      kernel/pid_namespace.o
  AR      net/ipv6/built-in.a
  CC      drivers/acpi/acpica/utglobal.o
  CC      fs/mbcache.o
  CC      arch/x86/kernel/crash.o
  CC      lib/bitrev.o
  CC      kernel/stop_machine.o
  CC      lib/crc-ccitt.o
  CC      drivers/acpi/acpica/uthex.o
  CC      fs/posix_acl.o
  CC      arch/x86/kernel/module.o
  CC      kernel/audit.o
  CC      kernel/auditfilter.o
  CC      arch/x86/kernel/doublefault_32.o
  CC      drivers/acpi/acpica/utids.o
  CC      arch/x86/kernel/early_printk.o
  CC      drivers/acpi/acpica/utinit.o
  CC      lib/crc16.o
  CC      drivers/acpi/acpica/utlock.o
  HOSTCC  lib/gen_crc32table
  CC      arch/x86/kernel/hpet.o
  CC      kernel/auditsc.o
  CC      arch/x86/kernel/amd_nb.o
  CC      lib/xxhash.o
  CC      kernel/audit_watch.o
  CC      lib/genalloc.o
  CC      arch/x86/kernel/amd_node.o
  CC      fs/coredump.o
  CC      kernel/audit_fsnotify.o
  CC      drivers/acpi/acpica/utmath.o
  CC      lib/percpu_counter.o
  CC      arch/x86/kernel/kvm.o
  CC      lib/audit.o
  CC      lib/syscall.o
  CC      kernel/audit_tree.o
  CC      fs/drop_caches.o
  CC      drivers/acpi/acpica/utmisc.o
  CC      lib/errname.o
  CC      kernel/kprobes.o
  CC      drivers/acpi/acpica/utmutex.o
  CC      kernel/seccomp.o
  CC      arch/x86/kernel/kvmclock.o
  CC      fs/sysctls.o
  CC      drivers/acpi/acpica/utnonansi.o
  CC      lib/nlattr.o
  CC      arch/x86/kernel/paravirt.o
  CC      drivers/acpi/acpica/utobject.o
  CC      fs/fhandle.o
  CC      kernel/relay.o
  CC      lib/cpu_rmap.o
  CC      lib/dynamic_queue_limits.o
  CC      drivers/acpi/acpica/utosi.o
  CC      kernel/utsname_sysctl.o
  CC      kernel/delayacct.o
  CC      lib/glob.o
  CC      drivers/acpi/acpica/utownerid.o
  CC      lib/strncpy_from_user.o
  CC      arch/x86/kernel/pvclock.o
  CC      drivers/acpi/acpica/utpredef.o
  CC      arch/x86/kernel/pcspeaker.o
  CC      kernel/taskstats.o
  CC      lib/strnlen_user.o
  CC      arch/x86/kernel/check.o
  CC      lib/net_utils.o
  CC      drivers/acpi/acpica/utresdecode.o
  CC      arch/x86/kernel/uprobes.o
  CC      arch/x86/kernel/perf_regs.o
  CC      drivers/acpi/acpica/utresrc.o
  CC      arch/x86/kernel/tracepoint.o
  CC      lib/sg_pool.o
  CC      kernel/tsacct.o
  CC      arch/x86/kernel/itmt.o
  CC      lib/stackdepot.o
  CC      arch/x86/kernel/umip.o
  CC      lib/asn1_decoder.o
  CC      arch/x86/kernel/unwind_frame.o
  CC      kernel/tracepoint.o
  GEN     lib/oid_registry_data.c
  CC      kernel/irq_work.o
  CC      lib/ucs2_string.o
  CC      drivers/acpi/acpica/utstate.o
  CC      kernel/static_call.o
  CC      lib/sbitmap.o
  CC      kernel/padata.o
  CC      kernel/jump_label.o
  CC      drivers/acpi/acpica/utstring.o
  CC      lib/group_cpus.o
  CC      kernel/context_tracking.o
  CC      kernel/iomem.o
  CC      drivers/acpi/acpica/utstrsuppt.o
  CC      kernel/rseq.o
  CC      lib/fw_table.o
  CC      drivers/acpi/acpica/utstrtoul64.o
  CC      drivers/acpi/acpica/utxface.o
  AR      mm/built-in.a
  CC      drivers/acpi/acpica/utxfinit.o
  AR      lib/lib.a
  GEN     lib/crc32table.h
  CC      drivers/acpi/acpica/utxferror.o
  CC      lib/oid_registry.o
  CC      lib/crc32.o
  CC      drivers/acpi/acpica/utxfmutex.o
  AR      drivers/acpi/acpica/built-in.a
  AR      drivers/acpi/built-in.a
make[2]: *** [/workspace/kernel/scripts/Makefile.build:465: drivers] Error 2
make[2]: *** Waiting for unfinished jobs....
  AR      fs/built-in.a
  AR      net/mac80211/built-in.a
  AR      net/built-in.a
  AR      arch/x86/kernel/built-in.a
  AR      arch/x86/built-in.a
  AR      lib/built-in.a
  AR      kernel/built-in.a
make[1]: *** [/workspace/kernel/Makefile:1994: .] Error 2
make: *** [/workspace/kernel/Makefile:251: __sub-make] Error 2
run-parts: /workspace/ci/hooks/11-build-32b exited with return code 2

✗ CI.checksparse: warning for Add support for EU stall sampling (rev2)

[Patchwork]

== Series Details ==

Series: Add support for EU stall sampling (rev2)
URL   : https://patchwork.freedesktop.org/series/144609/
State : warning

== Summary ==

+ trap cleanup EXIT
+ KERNEL=/kernel
+ MT=/root/linux/maintainer-tools
+ git clone https://gitlab.freedesktop.org/drm/maintainer-tools /root/linux/maintainer-tools
Cloning into '/root/linux/maintainer-tools'...
warning: redirecting to https://gitlab.freedesktop.org/drm/maintainer-tools.git/
+ make -C /root/linux/maintainer-tools
make: Entering directory '/root/linux/maintainer-tools'
cc -O2 -g -Wextra -o remap-log remap-log.c
make: Leaving directory '/root/linux/maintainer-tools'
+ cd /kernel
+ git config --global --add safe.directory /kernel
+ /root/linux/maintainer-tools/dim sparse --fast 2fc58ab10139895686001c7e1ee247f15226abc4
Sparse version: 0.6.4 (Ubuntu: 0.6.4-4ubuntu3)
+ cleanup
++ stat -c %u:%g /kernel
+ chown -R 1003:1003 /kernel

✓ Xe.CI.BAT: success for Add support for EU stall sampling (rev2)

[Patchwork]

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

== Series Details ==

Series: Add support for EU stall sampling (rev2)
URL   : https://patchwork.freedesktop.org/series/144609/
State : success

== Summary ==

CI Bug Log - changes from xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4_BAT -> xe-pw-144609v2_BAT
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  

Participating hosts (9 -> 8)
------------------------------

  Missing    (1): bat-adlp-vm 

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

  Here are the changes found in xe-pw-144609v2_BAT that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@xe_intel_bb@render@render-xmajor-256:
    - bat-adlp-vf:        [PASS][1] -> [DMESG-WARN][2] ([Intel XE#3970]) +2 other tests dmesg-warn
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/bat-adlp-vf/igt@xe_intel_bb@render@render-xmajor-256.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/bat-adlp-vf/igt@xe_intel_bb@render@render-xmajor-256.html

  
#### Possible fixes ####

  * igt@xe_intel_bb@intel-bb-blit-y:
    - bat-adlp-vf:        [DMESG-WARN][3] ([Intel XE#3970]) -> [PASS][4]
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/bat-adlp-vf/igt@xe_intel_bb@intel-bb-blit-y.html
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/bat-adlp-vf/igt@xe_intel_bb@intel-bb-blit-y.html

  
  [Intel XE#3970]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3970


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

  * Linux: xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4 -> xe-pw-144609v2

  IGT_8228: 8228
  xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4: 2fc58ab10139895686001c7e1ee247f15226abc4
  xe-pw-144609v2: 144609v2

== Logs ==

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

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

✗ Xe.CI.Full: failure for Add support for EU stall sampling (rev2)

[Patchwork]

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

== Series Details ==

Series: Add support for EU stall sampling (rev2)
URL   : https://patchwork.freedesktop.org/series/144609/
State : failure

== Summary ==

CI Bug Log - changes from xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4_full -> xe-pw-144609v2_full
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with xe-pw-144609v2_full absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in xe-pw-144609v2_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 (4 -> 4)
------------------------------

  No changes in participating hosts

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

  Here are the unknown changes that may have been introduced in xe-pw-144609v2_full:

### IGT changes ###

#### Possible regressions ####

  * igt@core_hotunplug@unbind-rebind:
    - shard-adlp:         [PASS][1] -> [INCOMPLETE][2]
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-adlp-3/igt@core_hotunplug@unbind-rebind.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-adlp-6/igt@core_hotunplug@unbind-rebind.html

  * igt@kms_plane_alpha_blend@constant-alpha-mid:
    - shard-dg2-set2:     NOTRUN -> [INCOMPLETE][3]
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_plane_alpha_blend@constant-alpha-mid.html

  * igt@kms_rotation_crc@sprite-rotation-180:
    - shard-adlp:         [PASS][4] -> [DMESG-WARN][5]
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-adlp-3/igt@kms_rotation_crc@sprite-rotation-180.html
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-adlp-8/igt@kms_rotation_crc@sprite-rotation-180.html

  * igt@xe_exec_basic@many-basic-defer-bind:
    - shard-dg2-set2:     [PASS][6] -> [INCOMPLETE][7]
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@xe_exec_basic@many-basic-defer-bind.html
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@xe_exec_basic@many-basic-defer-bind.html

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

  Here are the changes found in xe-pw-144609v2_full that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels:
    - shard-bmg:          NOTRUN -> [SKIP][8] ([Intel XE#2370])
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html

  * igt@kms_big_fb@linear-16bpp-rotate-270:
    - shard-dg2-set2:     NOTRUN -> [SKIP][9] ([Intel XE#316])
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_big_fb@linear-16bpp-rotate-270.html

  * igt@kms_big_fb@x-tiled-16bpp-rotate-90:
    - shard-bmg:          NOTRUN -> [SKIP][10] ([Intel XE#2327])
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_big_fb@x-tiled-16bpp-rotate-90.html

  * igt@kms_big_fb@y-tiled-16bpp-rotate-90:
    - shard-dg2-set2:     NOTRUN -> [SKIP][11] ([Intel XE#1124]) +6 other tests skip
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_big_fb@y-tiled-16bpp-rotate-90.html

  * igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-180-async-flip:
    - shard-bmg:          NOTRUN -> [SKIP][12] ([Intel XE#1124]) +5 other tests skip
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-180-async-flip.html

  * igt@kms_big_fb@yf-tiled-addfb-size-overflow:
    - shard-bmg:          NOTRUN -> [SKIP][13] ([Intel XE#610])
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_big_fb@yf-tiled-addfb-size-overflow.html

  * igt@kms_bw@connected-linear-tiling-4-displays-1920x1080p:
    - shard-bmg:          NOTRUN -> [SKIP][14] ([Intel XE#2314] / [Intel XE#2894]) +1 other test skip
   [14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_bw@connected-linear-tiling-4-displays-1920x1080p.html

  * igt@kms_bw@linear-tiling-1-displays-1920x1080p:
    - shard-bmg:          NOTRUN -> [SKIP][15] ([Intel XE#367])
   [15]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_bw@linear-tiling-1-displays-1920x1080p.html

  * igt@kms_ccs@ccs-on-another-bo-y-tiled-gen12-rc-ccs-cc@pipe-d-dp-4:
    - shard-dg2-set2:     NOTRUN -> [SKIP][16] ([Intel XE#455] / [Intel XE#787]) +37 other tests skip
   [16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-434/igt@kms_ccs@ccs-on-another-bo-y-tiled-gen12-rc-ccs-cc@pipe-d-dp-4.html

  * igt@kms_ccs@crc-primary-basic-4-tiled-bmg-ccs:
    - shard-dg2-set2:     NOTRUN -> [SKIP][17] ([Intel XE#2907])
   [17]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_ccs@crc-primary-basic-4-tiled-bmg-ccs.html

  * igt@kms_ccs@crc-primary-basic-4-tiled-mtl-rc-ccs@pipe-b-hdmi-a-6:
    - shard-dg2-set2:     NOTRUN -> [SKIP][18] ([Intel XE#787]) +163 other tests skip
   [18]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_ccs@crc-primary-basic-4-tiled-mtl-rc-ccs@pipe-b-hdmi-a-6.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs:
    - shard-dg2-set2:     NOTRUN -> [SKIP][19] ([Intel XE#3442])
   [19]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-rc-ccs-cc@pipe-d-dp-4:
    - shard-dg2-set2:     NOTRUN -> [DMESG-WARN][20] ([Intel XE#1033]) +17 other tests dmesg-warn
   [20]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-435/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-rc-ccs-cc@pipe-d-dp-4.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs@pipe-a-dp-2:
    - shard-bmg:          NOTRUN -> [SKIP][21] ([Intel XE#2652] / [Intel XE#787]) +11 other tests skip
   [21]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs@pipe-a-dp-2.html

  * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-dg2-rc-ccs-cc:
    - shard-bmg:          NOTRUN -> [SKIP][22] ([Intel XE#2887]) +8 other tests skip
   [22]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-dg2-rc-ccs-cc.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs:
    - shard-dg2-set2:     [PASS][23] -> [INCOMPLETE][24] ([Intel XE#1727] / [Intel XE#4010])
   [23]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-436/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs.html
   [24]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-434/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs-cc@pipe-a-hdmi-a-6:
    - shard-dg2-set2:     [PASS][25] -> [INCOMPLETE][26] ([Intel XE#3113] / [Intel XE#4010])
   [25]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs-cc@pipe-a-hdmi-a-6.html
   [26]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs-cc@pipe-a-hdmi-a-6.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-a-dp-4:
    - shard-dg2-set2:     [PASS][27] -> [INCOMPLETE][28] ([Intel XE#4010])
   [27]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-436/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-a-dp-4.html
   [28]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-434/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-a-dp-4.html

  * igt@kms_cdclk@mode-transition@pipe-d-dp-4:
    - shard-dg2-set2:     NOTRUN -> [SKIP][29] ([Intel XE#314]) +3 other tests skip
   [29]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_cdclk@mode-transition@pipe-d-dp-4.html

  * igt@kms_chamelium_color@ctm-max:
    - shard-bmg:          NOTRUN -> [SKIP][30] ([Intel XE#2325]) +1 other test skip
   [30]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_chamelium_color@ctm-max.html
    - shard-dg2-set2:     NOTRUN -> [SKIP][31] ([Intel XE#306])
   [31]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_chamelium_color@ctm-max.html

  * igt@kms_chamelium_hpd@common-hpd-after-suspend:
    - shard-bmg:          NOTRUN -> [SKIP][32] ([Intel XE#2252]) +5 other tests skip
   [32]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_chamelium_hpd@common-hpd-after-suspend.html
    - shard-dg2-set2:     NOTRUN -> [SKIP][33] ([Intel XE#373]) +5 other tests skip
   [33]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_chamelium_hpd@common-hpd-after-suspend.html

  * igt@kms_content_protection@atomic-dpms@pipe-a-dp-2:
    - shard-bmg:          NOTRUN -> [FAIL][34] ([Intel XE#1178]) +2 other tests fail
   [34]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_content_protection@atomic-dpms@pipe-a-dp-2.html

  * igt@kms_content_protection@legacy@pipe-a-dp-4:
    - shard-dg2-set2:     NOTRUN -> [FAIL][35] ([Intel XE#1178]) +1 other test fail
   [35]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_content_protection@legacy@pipe-a-dp-4.html

  * igt@kms_content_protection@lic-type-0@pipe-a-dp-2:
    - shard-bmg:          NOTRUN -> [DMESG-FAIL][36] ([Intel XE#4172])
   [36]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_content_protection@lic-type-0@pipe-a-dp-2.html

  * igt@kms_cursor_crc@cursor-onscreen-32x32:
    - shard-bmg:          NOTRUN -> [SKIP][37] ([Intel XE#2320]) +3 other tests skip
   [37]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_cursor_crc@cursor-onscreen-32x32.html

  * igt@kms_cursor_crc@cursor-sliding-512x512:
    - shard-bmg:          NOTRUN -> [SKIP][38] ([Intel XE#2321])
   [38]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_cursor_crc@cursor-sliding-512x512.html

  * igt@kms_cursor_crc@cursor-sliding-max-size:
    - shard-dg2-set2:     NOTRUN -> [SKIP][39] ([Intel XE#455]) +4 other tests skip
   [39]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_cursor_crc@cursor-sliding-max-size.html

  * igt@kms_cursor_crc@cursor-suspend:
    - shard-bmg:          [PASS][40] -> [INCOMPLETE][41] ([Intel XE#3878])
   [40]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_cursor_crc@cursor-suspend.html
   [41]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_cursor_crc@cursor-suspend.html

  * igt@kms_cursor_crc@cursor-suspend@pipe-d-hdmi-a-3:
    - shard-bmg:          NOTRUN -> [INCOMPLETE][42] ([Intel XE#3878])
   [42]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_cursor_crc@cursor-suspend@pipe-d-hdmi-a-3.html

  * igt@kms_cursor_legacy@2x-long-nonblocking-modeset-vs-cursor-atomic:
    - shard-bmg:          NOTRUN -> [SKIP][43] ([Intel XE#2291]) +1 other test skip
   [43]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_cursor_legacy@2x-long-nonblocking-modeset-vs-cursor-atomic.html

  * igt@kms_cursor_legacy@cursora-vs-flipb-varying-size:
    - shard-bmg:          [PASS][44] -> [SKIP][45] ([Intel XE#2291]) +4 other tests skip
   [44]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_cursor_legacy@cursora-vs-flipb-varying-size.html
   [45]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_cursor_legacy@cursora-vs-flipb-varying-size.html

  * igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions-varying-size:
    - shard-dg2-set2:     [PASS][46] -> [SKIP][47] ([Intel XE#309])
   [46]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-435/igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions-varying-size.html
   [47]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions-varying-size.html

  * igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size:
    - shard-bmg:          NOTRUN -> [SKIP][48] ([Intel XE#2286])
   [48]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size.html

  * igt@kms_dsc@dsc-fractional-bpp:
    - shard-bmg:          NOTRUN -> [SKIP][49] ([Intel XE#2244]) +1 other test skip
   [49]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_dsc@dsc-fractional-bpp.html

  * igt@kms_feature_discovery@display-2x:
    - shard-bmg:          [PASS][50] -> [SKIP][51] ([Intel XE#2373])
   [50]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_feature_discovery@display-2x.html
   [51]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_feature_discovery@display-2x.html

  * igt@kms_flip@2x-blocking-wf_vblank@ab-hdmi-a6-dp4:
    - shard-dg2-set2:     NOTRUN -> [FAIL][52] ([Intel XE#886])
   [52]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-435/igt@kms_flip@2x-blocking-wf_vblank@ab-hdmi-a6-dp4.html

  * igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@ab-dp2-hdmi-a3:
    - shard-bmg:          NOTRUN -> [FAIL][53] ([Intel XE#3321]) +2 other tests fail
   [53]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-8/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@ab-dp2-hdmi-a3.html

  * igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@bd-hdmi-a6-dp4:
    - shard-dg2-set2:     NOTRUN -> [FAIL][54] ([Intel XE#301] / [Intel XE#3321])
   [54]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@bd-hdmi-a6-dp4.html

  * igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@cd-hdmi-a6-dp4:
    - shard-dg2-set2:     NOTRUN -> [FAIL][55] ([Intel XE#301]) +3 other tests fail
   [55]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@cd-hdmi-a6-dp4.html

  * igt@kms_flip@2x-flip-vs-panning-vs-hang:
    - shard-bmg:          [PASS][56] -> [SKIP][57] ([Intel XE#2316]) +3 other tests skip
   [56]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-7/igt@kms_flip@2x-flip-vs-panning-vs-hang.html
   [57]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_flip@2x-flip-vs-panning-vs-hang.html

  * igt@kms_flip@2x-nonexisting-fb:
    - shard-bmg:          NOTRUN -> [SKIP][58] ([Intel XE#2316]) +3 other tests skip
   [58]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_flip@2x-nonexisting-fb.html

  * igt@kms_flip@flip-vs-expired-vblank-interruptible@a-dp4:
    - shard-dg2-set2:     [PASS][59] -> [FAIL][60] ([Intel XE#301]) +6 other tests fail
   [59]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_flip@flip-vs-expired-vblank-interruptible@a-dp4.html
   [60]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@kms_flip@flip-vs-expired-vblank-interruptible@a-dp4.html

  * igt@kms_flip@flip-vs-expired-vblank@c-dp4:
    - shard-dg2-set2:     [PASS][61] -> [FAIL][62] ([Intel XE#301] / [Intel XE#3321]) +2 other tests fail
   [61]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-463/igt@kms_flip@flip-vs-expired-vblank@c-dp4.html
   [62]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_flip@flip-vs-expired-vblank@c-dp4.html

  * igt@kms_flip@flip-vs-expired-vblank@d-hdmi-a3:
    - shard-bmg:          [PASS][63] -> [FAIL][64] ([Intel XE#3321]) +1 other test fail
   [63]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-1/igt@kms_flip@flip-vs-expired-vblank@d-hdmi-a3.html
   [64]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_flip@flip-vs-expired-vblank@d-hdmi-a3.html

  * igt@kms_flip@plain-flip-fb-recreate-interruptible@a-dp2:
    - shard-bmg:          NOTRUN -> [FAIL][65] ([Intel XE#2882]) +1 other test fail
   [65]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_flip@plain-flip-fb-recreate-interruptible@a-dp2.html

  * igt@kms_flip@plain-flip-fb-recreate-interruptible@a-hdmi-a6:
    - shard-dg2-set2:     [PASS][66] -> [FAIL][67] ([Intel XE#886])
   [66]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_flip@plain-flip-fb-recreate-interruptible@a-hdmi-a6.html
   [67]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@kms_flip@plain-flip-fb-recreate-interruptible@a-hdmi-a6.html

  * igt@kms_flip@plain-flip-fb-recreate-interruptible@b-hdmi-a6:
    - shard-dg2-set2:     [PASS][68] -> [FAIL][69] ([Intel XE#2882])
   [68]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_flip@plain-flip-fb-recreate-interruptible@b-hdmi-a6.html
   [69]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@kms_flip@plain-flip-fb-recreate-interruptible@b-hdmi-a6.html

  * igt@kms_flip@plain-flip-fb-recreate-interruptible@c-hdmi-a1:
    - shard-adlp:         [PASS][70] -> [FAIL][71] ([Intel XE#2882]) +1 other test fail
   [70]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-adlp-8/igt@kms_flip@plain-flip-fb-recreate-interruptible@c-hdmi-a1.html
   [71]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-adlp-3/igt@kms_flip@plain-flip-fb-recreate-interruptible@c-hdmi-a1.html

  * igt@kms_flip@plain-flip-ts-check-interruptible@b-dp2:
    - shard-bmg:          [PASS][72] -> [FAIL][73] ([Intel XE#2882])
   [72]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-1/igt@kms_flip@plain-flip-ts-check-interruptible@b-dp2.html
   [73]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_flip@plain-flip-ts-check-interruptible@b-dp2.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-64bpp-ytile-downscaling:
    - shard-bmg:          NOTRUN -> [SKIP][74] ([Intel XE#2293] / [Intel XE#2380]) +2 other tests skip
   [74]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-64bpp-ytile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytilegen12rcccs-upscaling@pipe-a-valid-mode:
    - shard-bmg:          NOTRUN -> [SKIP][75] ([Intel XE#2293]) +2 other tests skip
   [75]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytilegen12rcccs-upscaling@pipe-a-valid-mode.html

  * igt@kms_flip_tiling@flip-change-tiling@pipe-c-hdmi-a-1-y-to-x:
    - shard-adlp:         [PASS][76] -> [DMESG-FAIL][77] ([Intel XE#1033])
   [76]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-adlp-6/igt@kms_flip_tiling@flip-change-tiling@pipe-c-hdmi-a-1-y-to-x.html
   [77]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-adlp-9/igt@kms_flip_tiling@flip-change-tiling@pipe-c-hdmi-a-1-y-to-x.html

  * igt@kms_frontbuffer_tracking@drrs-1p-primscrn-pri-indfb-draw-render:
    - shard-bmg:          NOTRUN -> [SKIP][78] ([Intel XE#2311]) +6 other tests skip
   [78]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_frontbuffer_tracking@drrs-1p-primscrn-pri-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@drrs-2p-pri-indfb-multidraw:
    - shard-bmg:          NOTRUN -> [SKIP][79] ([Intel XE#2312]) +17 other tests skip
   [79]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_frontbuffer_tracking@drrs-2p-pri-indfb-multidraw.html

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-cur-indfb-move:
    - shard-bmg:          NOTRUN -> [SKIP][80] ([Intel XE#4141]) +3 other tests skip
   [80]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-cur-indfb-move.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-onoff:
    - shard-dg2-set2:     [PASS][81] -> [SKIP][82] ([Intel XE#656]) +2 other tests skip
   [81]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-435/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-onoff.html
   [82]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-cur-indfb-draw-render:
    - shard-dg2-set2:     NOTRUN -> [SKIP][83] ([Intel XE#651]) +17 other tests skip
   [83]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-466/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-cur-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y:
    - shard-bmg:          NOTRUN -> [SKIP][84] ([Intel XE#2352])
   [84]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-shrfb-msflip-blt:
    - shard-dg2-set2:     NOTRUN -> [SKIP][85] ([Intel XE#653]) +7 other tests skip
   [85]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@kms_frontbuffer_tracking@psr-2p-primscrn-shrfb-msflip-blt.html

  * igt@kms_frontbuffer_tracking@psr-rgb101010-draw-mmap-wc:
    - shard-bmg:          NOTRUN -> [SKIP][86] ([Intel XE#2313]) +7 other tests skip
   [86]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_frontbuffer_tracking@psr-rgb101010-draw-mmap-wc.html

  * igt@kms_getfb@getfb-reject-ccs:
    - shard-dg2-set2:     NOTRUN -> [SKIP][87] ([Intel XE#605])
   [87]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_getfb@getfb-reject-ccs.html

  * igt@kms_hdr@brightness-with-hdr:
    - shard-bmg:          NOTRUN -> [SKIP][88] ([Intel XE#3544])
   [88]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_hdr@brightness-with-hdr.html

  * igt@kms_joiner@basic-force-big-joiner:
    - shard-bmg:          NOTRUN -> [SKIP][89] ([Intel XE#3012])
   [89]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_joiner@basic-force-big-joiner.html

  * igt@kms_panel_fitting@atomic-fastset:
    - shard-bmg:          NOTRUN -> [SKIP][90] ([Intel XE#2486])
   [90]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_panel_fitting@atomic-fastset.html

  * igt@kms_pipe_crc_basic@compare-crc-sanitycheck-xr24@pipe-d-dp-2:
    - shard-bmg:          NOTRUN -> [DMESG-WARN][91] ([Intel XE#4172]) +1 other test dmesg-warn
   [91]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_pipe_crc_basic@compare-crc-sanitycheck-xr24@pipe-d-dp-2.html

  * igt@kms_plane_scaling@2x-scaler-multi-pipe:
    - shard-bmg:          [PASS][92] -> [SKIP][93] ([Intel XE#2571])
   [92]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_plane_scaling@2x-scaler-multi-pipe.html
   [93]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_plane_scaling@2x-scaler-multi-pipe.html

  * igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5:
    - shard-bmg:          NOTRUN -> [SKIP][94] ([Intel XE#2763]) +14 other tests skip
   [94]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5.html

  * igt@kms_pm_backlight@fade-with-dpms:
    - shard-bmg:          NOTRUN -> [SKIP][95] ([Intel XE#870])
   [95]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_pm_backlight@fade-with-dpms.html
    - shard-dg2-set2:     NOTRUN -> [SKIP][96] ([Intel XE#870])
   [96]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_pm_backlight@fade-with-dpms.html

  * igt@kms_pm_dc@dc5-retention-flops:
    - shard-dg2-set2:     NOTRUN -> [SKIP][97] ([Intel XE#3309])
   [97]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_pm_dc@dc5-retention-flops.html
    - shard-bmg:          NOTRUN -> [SKIP][98] ([Intel XE#3309])
   [98]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_pm_dc@dc5-retention-flops.html

  * igt@kms_pm_lpsp@kms-lpsp:
    - shard-bmg:          NOTRUN -> [SKIP][99] ([Intel XE#2499])
   [99]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_pm_lpsp@kms-lpsp.html

  * igt@kms_pm_rpm@modeset-lpsp-stress-no-wait:
    - shard-bmg:          NOTRUN -> [SKIP][100] ([Intel XE#1439] / [Intel XE#3141] / [Intel XE#836])
   [100]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_pm_rpm@modeset-lpsp-stress-no-wait.html

  * igt@kms_pm_rpm@modeset-non-lpsp-stress:
    - shard-dg2-set2:     [PASS][101] -> [SKIP][102] ([Intel XE#836])
   [101]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_pm_rpm@modeset-non-lpsp-stress.html
   [102]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_pm_rpm@modeset-non-lpsp-stress.html

  * igt@kms_psr2_sf@fbc-pr-cursor-plane-move-continuous-exceed-sf:
    - shard-bmg:          NOTRUN -> [SKIP][103] ([Intel XE#1489]) +3 other tests skip
   [103]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_psr2_sf@fbc-pr-cursor-plane-move-continuous-exceed-sf.html

  * igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-sf:
    - shard-dg2-set2:     NOTRUN -> [SKIP][104] ([Intel XE#1489])
   [104]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-sf.html

  * igt@kms_psr@fbc-psr2-primary-blt:
    - shard-bmg:          NOTRUN -> [SKIP][105] ([Intel XE#2234] / [Intel XE#2850]) +8 other tests skip
   [105]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_psr@fbc-psr2-primary-blt.html

  * igt@kms_psr@fbc-psr2-sprite-plane-onoff:
    - shard-dg2-set2:     NOTRUN -> [SKIP][106] ([Intel XE#2850] / [Intel XE#929]) +4 other tests skip
   [106]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_psr@fbc-psr2-sprite-plane-onoff.html

  * igt@kms_rotation_crc@bad-pixel-format:
    - shard-dg2-set2:     NOTRUN -> [SKIP][107] ([Intel XE#3414])
   [107]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-466/igt@kms_rotation_crc@bad-pixel-format.html

  * igt@kms_rotation_crc@cursor-rotation-180:
    - shard-bmg:          [PASS][108] -> [DMESG-WARN][109] ([Intel XE#4172]) +15 other tests dmesg-warn
   [108]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_rotation_crc@cursor-rotation-180.html
   [109]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-2/igt@kms_rotation_crc@cursor-rotation-180.html

  * igt@kms_rotation_crc@primary-rotation-270:
    - shard-bmg:          NOTRUN -> [SKIP][110] ([Intel XE#3414] / [Intel XE#3904])
   [110]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_rotation_crc@primary-rotation-270.html

  * igt@kms_rotation_crc@primary-y-tiled-reflect-x-180:
    - shard-bmg:          NOTRUN -> [SKIP][111] ([Intel XE#2330])
   [111]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_rotation_crc@primary-y-tiled-reflect-x-180.html

  * igt@kms_scaling_modes@scaling-mode-full-aspect:
    - shard-bmg:          NOTRUN -> [SKIP][112] ([Intel XE#2413])
   [112]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_scaling_modes@scaling-mode-full-aspect.html

  * igt@kms_tiled_display@basic-test-pattern:
    - shard-bmg:          NOTRUN -> [SKIP][113] ([Intel XE#2426])
   [113]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_tiled_display@basic-test-pattern.html

  * igt@kms_vrr@cmrr@pipe-a-edp-1:
    - shard-lnl:          [PASS][114] -> [FAIL][115] ([Intel XE#2159]) +1 other test fail
   [114]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-lnl-7/igt@kms_vrr@cmrr@pipe-a-edp-1.html
   [115]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-lnl-1/igt@kms_vrr@cmrr@pipe-a-edp-1.html

  * igt@kms_writeback@writeback-check-output-xrgb2101010:
    - shard-bmg:          NOTRUN -> [SKIP][116] ([Intel XE#756])
   [116]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_writeback@writeback-check-output-xrgb2101010.html
    - shard-dg2-set2:     NOTRUN -> [SKIP][117] ([Intel XE#756])
   [117]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_writeback@writeback-check-output-xrgb2101010.html

  * igt@xe_copy_basic@mem-set-linear-0xfd:
    - shard-dg2-set2:     NOTRUN -> [SKIP][118] ([Intel XE#1126])
   [118]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-466/igt@xe_copy_basic@mem-set-linear-0xfd.html

  * igt@xe_eudebug@discovery-empty:
    - shard-bmg:          NOTRUN -> [SKIP][119] ([Intel XE#2905]) +5 other tests skip
   [119]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@xe_eudebug@discovery-empty.html

  * igt@xe_eudebug_online@resume-dss:
    - shard-dg2-set2:     NOTRUN -> [SKIP][120] ([Intel XE#2905]) +2 other tests skip
   [120]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@xe_eudebug_online@resume-dss.html

  * igt@xe_exec_basic@multigpu-no-exec-basic-defer-bind:
    - shard-bmg:          NOTRUN -> [SKIP][121] ([Intel XE#2322]) +3 other tests skip
   [121]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@xe_exec_basic@multigpu-no-exec-basic-defer-bind.html

  * igt@xe_exec_basic@multigpu-once-bindexecqueue-userptr-rebind:
    - shard-dg2-set2:     [PASS][122] -> [SKIP][123] ([Intel XE#1392]) +3 other tests skip
   [122]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-435/igt@xe_exec_basic@multigpu-once-bindexecqueue-userptr-rebind.html
   [123]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-432/igt@xe_exec_basic@multigpu-once-bindexecqueue-userptr-rebind.html

  * igt@xe_exec_fault_mode@many-execqueues-basic-imm:
    - shard-dg2-set2:     NOTRUN -> [SKIP][124] ([Intel XE#288]) +8 other tests skip
   [124]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@xe_exec_fault_mode@many-execqueues-basic-imm.html

  * igt@xe_exec_mix_modes@exec-spinner-interrupted-dma-fence:
    - shard-dg2-set2:     NOTRUN -> [SKIP][125] ([Intel XE#2360])
   [125]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@xe_exec_mix_modes@exec-spinner-interrupted-dma-fence.html

  * igt@xe_exec_threads@threads-hang-userptr-invalidate-race:
    - shard-dg2-set2:     [PASS][126] -> [DMESG-WARN][127] ([Intel XE#1033]) +1 other test dmesg-warn
   [126]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@xe_exec_threads@threads-hang-userptr-invalidate-race.html
   [127]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@xe_exec_threads@threads-hang-userptr-invalidate-race.html

  * igt@xe_fault_injection@inject-fault-probe-function-xe_guc_relay_init:
    - shard-adlp:         [PASS][128] -> [DMESG-WARN][129] ([Intel XE#4173])
   [128]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-adlp-3/igt@xe_fault_injection@inject-fault-probe-function-xe_guc_relay_init.html
   [129]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-adlp-8/igt@xe_fault_injection@inject-fault-probe-function-xe_guc_relay_init.html

  * igt@xe_live_ktest@xe_eudebug:
    - shard-bmg:          NOTRUN -> [SKIP][130] ([Intel XE#2833])
   [130]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@xe_live_ktest@xe_eudebug.html

  * igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit:
    - shard-dg2-set2:     NOTRUN -> [SKIP][131] ([Intel XE#2229])
   [131]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-434/igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit.html

  * igt@xe_live_ktest@xe_mocs:
    - shard-bmg:          [PASS][132] -> [SKIP][133] ([Intel XE#1192]) +1 other test skip
   [132]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-5/igt@xe_live_ktest@xe_mocs.html
   [133]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-2/igt@xe_live_ktest@xe_mocs.html

  * igt@xe_mmap@small-bar:
    - shard-bmg:          NOTRUN -> [SKIP][134] ([Intel XE#586])
   [134]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@xe_mmap@small-bar.html
    - shard-dg2-set2:     NOTRUN -> [SKIP][135] ([Intel XE#512])
   [135]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@xe_mmap@small-bar.html

  * igt@xe_oa@disabled-read-error:
    - shard-dg2-set2:     NOTRUN -> [SKIP][136] ([Intel XE#2541] / [Intel XE#3573]) +3 other tests skip
   [136]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-466/igt@xe_oa@disabled-read-error.html

  * igt@xe_pm@d3cold-basic:
    - shard-bmg:          NOTRUN -> [SKIP][137] ([Intel XE#2284])
   [137]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@xe_pm@d3cold-basic.html

  * igt@xe_pm@s2idle-vm-bind-unbind-all:
    - shard-adlp:         [PASS][138] -> [DMESG-WARN][139] ([Intel XE#2953])
   [138]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-adlp-3/igt@xe_pm@s2idle-vm-bind-unbind-all.html
   [139]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-adlp-8/igt@xe_pm@s2idle-vm-bind-unbind-all.html

  * igt@xe_pm@s2idle-vm-bind-userptr:
    - shard-dg2-set2:     [PASS][140] -> [ABORT][141] ([Intel XE#1794]) +1 other test abort
   [140]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-466/igt@xe_pm@s2idle-vm-bind-userptr.html
   [141]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-432/igt@xe_pm@s2idle-vm-bind-userptr.html

  * igt@xe_pm@s4-mocs:
    - shard-bmg:          NOTRUN -> [ABORT][142] ([Intel XE#4268])
   [142]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@xe_pm@s4-mocs.html

  * igt@xe_pm@s4-vm-bind-unbind-all:
    - shard-dg2-set2:     NOTRUN -> [ABORT][143] ([Intel XE#4268]) +1 other test abort
   [143]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@xe_pm@s4-vm-bind-unbind-all.html

  * igt@xe_pm@vram-d3cold-threshold:
    - shard-dg2-set2:     NOTRUN -> [SKIP][144] ([Intel XE#579])
   [144]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@xe_pm@vram-d3cold-threshold.html

  * igt@xe_pm_residency@gt-c6-on-idle:
    - shard-dg2-set2:     [PASS][145] -> [DMESG-WARN][146] ([Intel XE#1727]) +1 other test dmesg-warn
   [145]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-436/igt@xe_pm_residency@gt-c6-on-idle.html
   [146]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-434/igt@xe_pm_residency@gt-c6-on-idle.html

  * igt@xe_query@multigpu-query-topology-l3-bank-mask:
    - shard-bmg:          NOTRUN -> [SKIP][147] ([Intel XE#944])
   [147]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@xe_query@multigpu-query-topology-l3-bank-mask.html

  * igt@xe_sriov_flr@flr-each-isolation:
    - shard-dg2-set2:     NOTRUN -> [SKIP][148] ([Intel XE#3342])
   [148]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@xe_sriov_flr@flr-each-isolation.html

  * igt@xe_sriov_flr@flr-twice:
    - shard-bmg:          NOTRUN -> [SKIP][149] ([Intel XE#4273])
   [149]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@xe_sriov_flr@flr-twice.html

  
#### Possible fixes ####

  * igt@kms_bw@connected-linear-tiling-2-displays-2160x1440p:
    - shard-dg2-set2:     [SKIP][150] ([Intel XE#2191]) -> [PASS][151] +1 other test pass
   [150]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_bw@connected-linear-tiling-2-displays-2160x1440p.html
   [151]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-432/igt@kms_bw@connected-linear-tiling-2-displays-2160x1440p.html

  * igt@kms_cursor_legacy@2x-long-cursor-vs-flip-atomic:
    - shard-dg2-set2:     [SKIP][152] ([Intel XE#309]) -> [PASS][153] +5 other tests pass
   [152]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_cursor_legacy@2x-long-cursor-vs-flip-atomic.html
   [153]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-435/igt@kms_cursor_legacy@2x-long-cursor-vs-flip-atomic.html

  * igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions-varying-size:
    - shard-bmg:          [SKIP][154] ([Intel XE#2291]) -> [PASS][155] +4 other tests pass
   [154]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-4/igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions-varying-size.html
   [155]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions-varying-size.html

  * igt@kms_flip@2x-absolute-wf_vblank-interruptible@ab-dp2-hdmi-a3:
    - shard-bmg:          [INCOMPLETE][156] ([Intel XE#2049]) -> [PASS][157] +1 other test pass
   [156]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_flip@2x-absolute-wf_vblank-interruptible@ab-dp2-hdmi-a3.html
   [157]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_flip@2x-absolute-wf_vblank-interruptible@ab-dp2-hdmi-a3.html

  * igt@kms_flip@2x-plain-flip-fb-recreate-interruptible:
    - shard-bmg:          [SKIP][158] ([Intel XE#2316]) -> [PASS][159] +6 other tests pass
   [158]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-4/igt@kms_flip@2x-plain-flip-fb-recreate-interruptible.html
   [159]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-8/igt@kms_flip@2x-plain-flip-fb-recreate-interruptible.html

  * igt@kms_flip@2x-plain-flip-ts-check-interruptible:
    - shard-dg2-set2:     [SKIP][160] ([Intel XE#310]) -> [PASS][161] +2 other tests pass
   [160]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_flip@2x-plain-flip-ts-check-interruptible.html
   [161]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-435/igt@kms_flip@2x-plain-flip-ts-check-interruptible.html

  * igt@kms_flip@flip-vs-expired-vblank@d-dp2:
    - shard-bmg:          [FAIL][162] ([Intel XE#3321]) -> [PASS][163] +2 other tests pass
   [162]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-1/igt@kms_flip@flip-vs-expired-vblank@d-dp2.html
   [163]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_flip@flip-vs-expired-vblank@d-dp2.html

  * igt@kms_flip@plain-flip-ts-check-interruptible@c-edp1:
    - shard-lnl:          [FAIL][164] ([Intel XE#886]) -> [PASS][165]
   [164]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-lnl-1/igt@kms_flip@plain-flip-ts-check-interruptible@c-edp1.html
   [165]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-lnl-7/igt@kms_flip@plain-flip-ts-check-interruptible@c-edp1.html

  * igt@kms_flip_tiling@flip-change-tiling@pipe-b-hdmi-a-1-y-to-y:
    - shard-adlp:         [DMESG-FAIL][166] ([Intel XE#1033]) -> [PASS][167]
   [166]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-adlp-6/igt@kms_flip_tiling@flip-change-tiling@pipe-b-hdmi-a-1-y-to-y.html
   [167]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-adlp-9/igt@kms_flip_tiling@flip-change-tiling@pipe-b-hdmi-a-1-y-to-y.html

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-shrfb-draw-render:
    - shard-dg2-set2:     [INCOMPLETE][168] -> [PASS][169]
   [168]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-466/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-shrfb-draw-render.html
   [169]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-shrfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-move:
    - shard-dg2-set2:     [SKIP][170] ([Intel XE#656]) -> [PASS][171] +6 other tests pass
   [170]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-move.html
   [171]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-435/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-move.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-shrfb-plflip-blt:
    - shard-dg2-set2:     [DMESG-WARN][172] ([Intel XE#1033]) -> [PASS][173] +2 other tests pass
   [172]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-shrfb-plflip-blt.html
   [173]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-shrfb-plflip-blt.html

  * igt@kms_frontbuffer_tracking@fbc-suspend:
    - shard-dg2-set2:     [ABORT][174] ([Intel XE#2625]) -> [PASS][175]
   [174]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-432/igt@kms_frontbuffer_tracking@fbc-suspend.html
   [175]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_frontbuffer_tracking@fbc-suspend.html

  * igt@kms_hdr@invalid-hdr:
    - shard-bmg:          [SKIP][176] ([Intel XE#1503]) -> [PASS][177]
   [176]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_hdr@invalid-hdr.html
   [177]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-8/igt@kms_hdr@invalid-hdr.html

  * igt@kms_pipe_crc_basic@suspend-read-crc:
    - shard-dg2-set2:     [ABORT][178] ([Intel XE#2625] / [Intel XE#4080]) -> [PASS][179]
   [178]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-432/igt@kms_pipe_crc_basic@suspend-read-crc.html
   [179]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-466/igt@kms_pipe_crc_basic@suspend-read-crc.html

  * igt@kms_plane_scaling@plane-downscale-factor-0-5-with-modifiers@pipe-d:
    - shard-bmg:          [DMESG-WARN][180] ([Intel XE#4172]) -> [PASS][181] +8 other tests pass
   [180]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-7/igt@kms_plane_scaling@plane-downscale-factor-0-5-with-modifiers@pipe-d.html
   [181]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-1/igt@kms_plane_scaling@plane-downscale-factor-0-5-with-modifiers@pipe-d.html

  * igt@kms_pm_rpm@modeset-non-lpsp:
    - shard-dg2-set2:     [SKIP][182] ([Intel XE#836]) -> [PASS][183] +1 other test pass
   [182]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_pm_rpm@modeset-non-lpsp.html
   [183]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_pm_rpm@modeset-non-lpsp.html

  * igt@kms_rotation_crc@primary-x-tiled-reflect-x-180:
    - shard-dg2-set2:     [INCOMPLETE][184] ([Intel XE#4170]) -> [PASS][185]
   [184]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-463/igt@kms_rotation_crc@primary-x-tiled-reflect-x-180.html
   [185]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_rotation_crc@primary-x-tiled-reflect-x-180.html

  * igt@kms_setmode@clone-exclusive-crtc:
    - shard-bmg:          [SKIP][186] ([Intel XE#1435]) -> [PASS][187]
   [186]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_setmode@clone-exclusive-crtc.html
   [187]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-8/igt@kms_setmode@clone-exclusive-crtc.html
    - shard-dg2-set2:     [SKIP][188] ([Intel XE#455]) -> [PASS][189] +2 other tests pass
   [188]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_setmode@clone-exclusive-crtc.html
   [189]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_setmode@clone-exclusive-crtc.html

  * igt@xe_compute_preempt@compute-preempt-many@engine-drm_xe_engine_class_compute:
    - shard-lnl:          [FAIL][190] ([Intel XE#4278]) -> [PASS][191] +1 other test pass
   [190]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-lnl-8/igt@xe_compute_preempt@compute-preempt-many@engine-drm_xe_engine_class_compute.html
   [191]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-lnl-2/igt@xe_compute_preempt@compute-preempt-many@engine-drm_xe_engine_class_compute.html

  * igt@xe_exec_basic@multigpu-once-basic-defer-mmap:
    - shard-dg2-set2:     [SKIP][192] ([Intel XE#1392]) -> [PASS][193] +4 other tests pass
   [192]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-432/igt@xe_exec_basic@multigpu-once-basic-defer-mmap.html
   [193]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@xe_exec_basic@multigpu-once-basic-defer-mmap.html

  * igt@xe_exec_reset@cm-gt-reset:
    - shard-bmg:          [INCOMPLETE][194] -> [PASS][195]
   [194]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@xe_exec_reset@cm-gt-reset.html
   [195]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@xe_exec_reset@cm-gt-reset.html

  * igt@xe_fault_injection@inject-fault-probe-function-xe_guc_relay_init:
    - shard-dg2-set2:     [DMESG-WARN][196] -> [PASS][197]
   [196]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@xe_fault_injection@inject-fault-probe-function-xe_guc_relay_init.html
   [197]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@xe_fault_injection@inject-fault-probe-function-xe_guc_relay_init.html

  * igt@xe_live_ktest@xe_dma_buf:
    - shard-bmg:          [SKIP][198] ([Intel XE#1192]) -> [PASS][199]
   [198]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@xe_live_ktest@xe_dma_buf.html
   [199]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@xe_live_ktest@xe_dma_buf.html

  
#### Warnings ####

  * igt@kms_ccs@ccs-on-another-bo-y-tiled-ccs@pipe-d-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][200] ([Intel XE#455] / [Intel XE#787]) -> [SKIP][201] ([Intel XE#787]) +7 other tests skip
   [200]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_ccs@ccs-on-another-bo-y-tiled-ccs@pipe-d-hdmi-a-6.html
   [201]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-435/igt@kms_ccs@ccs-on-another-bo-y-tiled-ccs@pipe-d-hdmi-a-6.html

  * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs@pipe-d-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][202] ([Intel XE#787]) -> [SKIP][203] ([Intel XE#455] / [Intel XE#787]) +6 other tests skip
   [202]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-435/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs@pipe-d-hdmi-a-6.html
   [203]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs@pipe-d-hdmi-a-6.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs-cc:
    - shard-dg2-set2:     [DMESG-WARN][204] ([Intel XE#1033]) -> [INCOMPLETE][205] ([Intel XE#1727] / [Intel XE#4010])
   [204]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs-cc.html
   [205]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs-cc.html

  * igt@kms_content_protection@legacy:
    - shard-bmg:          [SKIP][206] ([Intel XE#2341]) -> [FAIL][207] ([Intel XE#1178])
   [206]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_content_protection@legacy.html
   [207]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-8/igt@kms_content_protection@legacy.html
    - shard-dg2-set2:     [SKIP][208] ([Intel XE#455]) -> [FAIL][209] ([Intel XE#1178]) +1 other test fail
   [208]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_content_protection@legacy.html
   [209]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_content_protection@legacy.html

  * igt@kms_content_protection@lic-type-0:
    - shard-bmg:          [SKIP][210] ([Intel XE#2341]) -> [DMESG-FAIL][211] ([Intel XE#4172])
   [210]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_content_protection@lic-type-0.html
   [211]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_content_protection@lic-type-0.html

  * igt@kms_content_protection@uevent:
    - shard-bmg:          [FAIL][212] ([Intel XE#1188]) -> [SKIP][213] ([Intel XE#2341])
   [212]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_content_protection@uevent.html
   [213]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_content_protection@uevent.html

  * igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic:
    - shard-bmg:          [SKIP][214] ([Intel XE#2291]) -> [DMESG-WARN][215] ([Intel XE#4172]) +1 other test dmesg-warn
   [214]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic.html
   [215]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic.html

  * igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size:
    - shard-bmg:          [SKIP][216] ([Intel XE#2291]) -> [DMESG-WARN][217] ([Intel XE#877])
   [216]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size.html
   [217]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-1/igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size.html

  * igt@kms_flip@2x-blocking-wf_vblank:
    - shard-dg2-set2:     [SKIP][218] ([Intel XE#310]) -> [FAIL][219] ([Intel XE#886])
   [218]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_flip@2x-blocking-wf_vblank.html
   [219]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-435/igt@kms_flip@2x-blocking-wf_vblank.html

  * igt@kms_flip@2x-flip-vs-expired-vblank:
    - shard-bmg:          [FAIL][220] ([Intel XE#3321]) -> [SKIP][221] ([Intel XE#2316])
   [220]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-7/igt@kms_flip@2x-flip-vs-expired-vblank.html
   [221]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_flip@2x-flip-vs-expired-vblank.html

  * igt@kms_flip@2x-flip-vs-expired-vblank-interruptible:
    - shard-bmg:          [SKIP][222] ([Intel XE#2316]) -> [FAIL][223] ([Intel XE#3321])
   [222]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible.html
   [223]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-8/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible.html
    - shard-dg2-set2:     [SKIP][224] ([Intel XE#310]) -> [FAIL][225] ([Intel XE#301])
   [224]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible.html
   [225]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible.html

  * igt@kms_flip@2x-flip-vs-modeset-vs-hang:
    - shard-dg2-set2:     [DMESG-WARN][226] ([Intel XE#1033]) -> [SKIP][227] ([Intel XE#310])
   [226]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_flip@2x-flip-vs-modeset-vs-hang.html
   [227]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_flip@2x-flip-vs-modeset-vs-hang.html

  * igt@kms_flip@flip-vs-expired-vblank-interruptible:
    - shard-bmg:          [DMESG-FAIL][228] ([Intel XE#4172]) -> [DMESG-WARN][229] ([Intel XE#4172])
   [228]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_flip@flip-vs-expired-vblank-interruptible.html
   [229]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_flip@flip-vs-expired-vblank-interruptible.html

  * igt@kms_flip@plain-flip-fb-recreate-interruptible:
    - shard-dg2-set2:     [DMESG-WARN][230] ([Intel XE#1033]) -> [DMESG-FAIL][231] ([Intel XE#1033]) +2 other tests dmesg-fail
   [230]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-434/igt@kms_flip@plain-flip-fb-recreate-interruptible.html
   [231]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-433/igt@kms_flip@plain-flip-fb-recreate-interruptible.html
    - shard-bmg:          [DMESG-WARN][232] ([Intel XE#4172]) -> [DMESG-FAIL][233] ([Intel XE#4172])
   [232]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_flip@plain-flip-fb-recreate-interruptible.html
   [233]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-5/igt@kms_flip@plain-flip-fb-recreate-interruptible.html

  * igt@kms_flip@plain-flip-ts-check-interruptible:
    - shard-lnl:          [FAIL][234] ([Intel XE#3149] / [Intel XE#886]) -> [FAIL][235] ([Intel XE#886])
   [234]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-lnl-1/igt@kms_flip@plain-flip-ts-check-interruptible.html
   [235]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-lnl-7/igt@kms_flip@plain-flip-ts-check-interruptible.html

  * igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-indfb-draw-mmap-wc:
    - shard-bmg:          [SKIP][236] ([Intel XE#2312]) -> [SKIP][237] ([Intel XE#2311]) +21 other tests skip
   [236]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-indfb-draw-mmap-wc.html
   [237]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-8/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-indfb-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-shrfb-draw-render:
    - shard-dg2-set2:     [SKIP][238] ([Intel XE#651]) -> [SKIP][239] ([Intel XE#656]) +4 other tests skip
   [238]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-435/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-shrfb-draw-render.html
   [239]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-shrfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-shrfb-pgflip-blt:
    - shard-bmg:          [SKIP][240] ([Intel XE#2312]) -> [SKIP][241] ([Intel XE#4141]) +8 other tests skip
   [240]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-4/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-shrfb-pgflip-blt.html
   [241]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-7/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-shrfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render:
    - shard-bmg:          [SKIP][242] ([Intel XE#4141]) -> [SKIP][243] ([Intel XE#2312]) +10 other tests skip
   [242]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render.html
   [243]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-spr-indfb-draw-blt:
    - shard-bmg:          [SKIP][244] ([Intel XE#2311]) -> [INCOMPLETE][245] ([Intel XE#2050] / [Intel XE#2594])
   [244]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-5/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-spr-indfb-draw-blt.html
   [245]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-2/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-spr-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-cur-indfb-draw-mmap-wc:
    - shard-bmg:          [SKIP][246] ([Intel XE#2311]) -> [SKIP][247] ([Intel XE#2312]) +14 other tests skip
   [246]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-8/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-cur-indfb-draw-mmap-wc.html
   [247]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-6/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-cur-indfb-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-shrfb-pgflip-blt:
    - shard-dg2-set2:     [SKIP][248] ([Intel XE#656]) -> [SKIP][249] ([Intel XE#651]) +10 other tests skip
   [248]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-shrfb-pgflip-blt.html
   [249]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-436/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-shrfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-pri-indfb-draw-render:
    - shard-bmg:          [SKIP][250] ([Intel XE#2312]) -> [SKIP][251] ([Intel XE#2313]) +22 other tests skip
   [250]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-6/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-pri-indfb-draw-render.html
   [251]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-1/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-pri-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-shrfb-pgflip-blt:
    - shard-bmg:          [SKIP][252] ([Intel XE#2313]) -> [SKIP][253] ([Intel XE#2312]) +15 other tests skip
   [252]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-bmg-2/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-shrfb-pgflip-blt.html
   [253]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-shrfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-indfb-msflip-blt:
    - shard-dg2-set2:     [SKIP][254] ([Intel XE#653]) -> [SKIP][255] ([Intel XE#656]) +5 other tests skip
   [254]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-435/igt@kms_frontbuffer_tracking@psr-2p-primscrn-indfb-msflip-blt.html
   [255]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-464/igt@kms_frontbuffer_tracking@psr-2p-primscrn-indfb-msflip-blt.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-blt:
    - shard-dg2-set2:     [SKIP][256] ([Intel XE#656]) -> [SKIP][257] ([Intel XE#653]) +14 other tests skip
   [256]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-464/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-blt.html
   [257]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-435/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-blt.html

  * igt@kms_tiled_display@basic-test-pattern-with-chamelium:
    - shard-dg2-set2:     [SKIP][258] ([Intel XE#1500]) -> [SKIP][259] ([Intel XE#362])
   [258]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-432/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html
   [259]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-463/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html

  * igt@xe_pm@s3-basic:
    - shard-dg2-set2:     [ABORT][260] ([Intel XE#1033] / [Intel XE#1794]) -> [DMESG-WARN][261] ([Intel XE#1033] / [Intel XE#569])
   [260]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-432/igt@xe_pm@s3-basic.html
   [261]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-434/igt@xe_pm@s3-basic.html

  * igt@xe_pm@s3-mocs:
    - shard-dg2-set2:     [DMESG-WARN][262] ([Intel XE#1033] / [Intel XE#569]) -> [ABORT][263] ([Intel XE#1033] / [Intel XE#1794])
   [262]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4/shard-dg2-435/igt@xe_pm@s3-mocs.html
   [263]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v2/shard-dg2-432/igt@xe_pm@s3-mocs.html

  
  [Intel XE#1033]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1033
  [Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
  [Intel XE#1126]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1126
  [Intel XE#1178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1178
  [Intel XE#1188]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1188
  [Intel XE#1192]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1192
  [Intel XE#1392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1392
  [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#1500]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1500
  [Intel XE#1503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1503
  [Intel XE#1727]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1727
  [Intel XE#1794]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1794
  [Intel XE#2049]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2049
  [Intel XE#2050]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2050
  [Intel XE#2159]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2159
  [Intel XE#2191]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2191
  [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#2244]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2244
  [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#2291]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2291
  [Intel XE#2293]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2293
  [Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
  [Intel XE#2312]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2312
  [Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
  [Intel XE#2314]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2314
  [Intel XE#2316]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2316
  [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#2341]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2341
  [Intel XE#2352]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2352
  [Intel XE#2360]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2360
  [Intel XE#2370]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2370
  [Intel XE#2373]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2373
  [Intel XE#2380]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2380
  [Intel XE#2413]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2413
  [Intel XE#2426]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2426
  [Intel XE#2486]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2486
  [Intel XE#2499]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2499
  [Intel XE#2541]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2541
  [Intel XE#2571]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2571
  [Intel XE#2594]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2594
  [Intel XE#2625]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2625
  [Intel XE#2652]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2652
  [Intel XE#2763]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2763
  [Intel XE#2833]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2833
  [Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850
  [Intel XE#288]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/288
  [Intel XE#2882]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2882
  [Intel XE#2887]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2887
  [Intel XE#2894]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2894
  [Intel XE#2905]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2905
  [Intel XE#2907]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2907
  [Intel XE#2953]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2953
  [Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
  [Intel XE#3012]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3012
  [Intel XE#306]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/306
  [Intel XE#309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/309
  [Intel XE#310]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/310
  [Intel XE#3113]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3113
  [Intel XE#314]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/314
  [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#316]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/316
  [Intel XE#3309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3309
  [Intel XE#3321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3321
  [Intel XE#3342]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3342
  [Intel XE#3414]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3414
  [Intel XE#3442]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3442
  [Intel XE#3544]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3544
  [Intel XE#3573]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3573
  [Intel XE#362]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/362
  [Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
  [Intel XE#373]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/373
  [Intel XE#3878]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3878
  [Intel XE#3904]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3904
  [Intel XE#4010]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4010
  [Intel XE#4080]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4080
  [Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141
  [Intel XE#4170]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4170
  [Intel XE#4172]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4172
  [Intel XE#4173]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4173
  [Intel XE#4268]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4268
  [Intel XE#4273]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4273
  [Intel XE#4278]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4278
  [Intel XE#455]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/455
  [Intel XE#512]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/512
  [Intel XE#569]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/569
  [Intel XE#579]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/579
  [Intel XE#586]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/586
  [Intel XE#605]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/605
  [Intel XE#610]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/610
  [Intel XE#651]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/651
  [Intel XE#653]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/653
  [Intel XE#656]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/656
  [Intel XE#756]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/756
  [Intel XE#787]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/787
  [Intel XE#836]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/836
  [Intel XE#870]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/870
  [Intel XE#877]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/877
  [Intel XE#886]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/886
  [Intel XE#929]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/929
  [Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944


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

  * Linux: xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4 -> xe-pw-144609v2

  IGT_8228: 8228
  xe-2635-2fc58ab10139895686001c7e1ee247f15226abc4: 2fc58ab10139895686001c7e1ee247f15226abc4
  xe-pw-144609v2: 144609v2

== Logs ==

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

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

Re: [PATCH v9 3/8] drm/xe/eustall: Add support to init, enable and disable EU stall sampling

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:44 -0800, Harish Chegondi wrote:
>

Hi Harish,

> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> index 0ceb3091f81e..12afa9720971 100644
> --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> @@ -8,17 +8,57 @@
>  #include <linux/poll.h>
>  #include <linux/types.h>
>
> +#include <drm/drm_drv.h>
>  #include <uapi/drm/xe_drm.h>
>
> +#include "xe_bo.h"
>  #include "xe_device.h"
>  #include "xe_eu_stall.h"
> +#include "xe_force_wake.h"
> +#include "xe_gt_mcr.h"
>  #include "xe_gt_printk.h"
>  #include "xe_gt_topology.h"
>  #include "xe_macros.h"
>  #include "xe_observation.h"
> +#include "xe_pm.h"
> +
> +#include "regs/xe_eu_stall_regs.h"
> +#include "regs/xe_gt_regs.h"
> +
> +#define POLL_PERIOD_MS	10
>
>  static size_t per_xecore_buf_size = SZ_512K;
>
> +struct per_xecore_buf {
> +	/* Buffer vaddr */
> +	u8 *vaddr;
> +	/* Write pointer */
> +	u32 write;
> +	/* Read pointer */
> +	u32 read;
> +	/* lock to protect read and write pointers */
> +	struct mutex ptr_lock;
> +};
> +
> +struct xe_eu_stall_data_stream {
> +	bool enabled;
> +	size_t data_record_size;
> +	size_t per_xecore_buf_size;
> +	unsigned int wait_num_reports;
> +	unsigned int sampling_rate_mult;
> +
> +	struct xe_gt *gt;
> +	struct xe_bo *bo;
> +	struct per_xecore_buf *xecore_buf;
> +};
> +
> +struct xe_eu_stall_gt {
> +	/* Lock to protect stream */
> +	struct mutex stream_lock;
> +	/* EU stall data stream */
> +	struct xe_eu_stall_data_stream *stream;
> +};
> +
>  /**
>   * struct eu_stall_open_properties - EU stall sampling properties received
>   *				     from user space at open.
> @@ -33,6 +73,47 @@ struct eu_stall_open_properties {
>	struct xe_gt *gt;
>  };
>
> +/**
> + * struct xe_eu_stall_data_pvc - EU stall data format for PVC
> + *			Bits		Field
> + * @ip_addr:		0  to 28	IP (addr)
> + * @active_count:	29 to 36	active count
> + * @other_count:	37 to 44	other count
> + * @control_count:	45 to 52	control count
> + * @pipestall_count:	53 to 60	pipestall count
> + * @send_count:		61 to 68	send count
> + * @dist_acc_count:	69 to 76	dist_acc count
> + * @sbid_count:		77 to 84	sbid count
> + * @sync_count:		85 to 92	sync count
> + * @inst_fetch_count:	93 to 100	inst_fetch count
> + * @unused_bits:	101 to 127	unused bits
> + * @unused:		remaining	unused bytes
> + */

I'd say delete this comment, it seems to be no zero extra information above
what is already included in the struct below.

If you want to document the bit positions, add them on the same line as the
struct field, e.g.:

	__u64 active_count:8; /* bits 36:29 */

> +struct xe_eu_stall_data_pvc {
> +	__u64 ip_addr:29;
> +	__u64 active_count:8;
> +	__u64 other_count:8;
> +	__u64 control_count:8;
> +	__u64 pipestall_count:8;
> +	__u64 send_count:8;
> +	__u64 dist_acc_count:8;
> +	__u64 sbid_count:8;
> +	__u64 sync_count:8;
> +	__u64 inst_fetch_count:8;
> +	__u64 unused_bits:27;
> +	__u64 unused[6];
> +} __packed;
> +
> +static size_t xe_eu_stall_data_record_size(struct xe_device *xe)
> +{
> +	unsigned long record_size = 0;
> +
> +	if (xe->info.platform == XE_PVC)
> +		record_size = sizeof(struct xe_eu_stall_data_pvc);
> +
> +	return record_size;
> +}
> +
>  /**
>   * num_data_rows - Return the number of EU stall data rows of 64B each
>   *		   for a given data size.
> @@ -44,6 +125,36 @@ static u32 num_data_rows(u32 data_size)
>	return (data_size >> 6);
>  }
>
> +/**
> + * xe_eu_stall_init() - Allocate and initialize GT level EU stall data
> + *			structure xe_eu_stall_gt within struct xe_gt.
> + *
> + * @gt: GT being initialized.
> + *
> + * Returns: zero on success or a negative error code.
> + */
> +int xe_eu_stall_init(struct xe_gt *gt)
> +{
> +	gt->eu_stall = kzalloc(sizeof(*gt->eu_stall), GFP_KERNEL);
> +	if (!gt->eu_stall)
> +		return -ENOMEM;
> +
> +	mutex_init(&gt->eu_stall->stream_lock);
> +	return 0;
> +}
> +
> +/**
> + * xe_eu_stall_fini() - Clean up the GT level EU stall data
> + *			structure xe_eu_stall_gt within struct xe_gt.
> + *
> + * @gt: GT being cleaned up.
> + */
> +void xe_eu_stall_fini(struct xe_gt *gt)
> +{
> +	mutex_destroy(&gt->eu_stall->stream_lock);
> +	kfree(gt->eu_stall);
> +}
> +
>  static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
>					   struct eu_stall_open_properties *props)
>  {
> @@ -166,6 +277,120 @@ static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
>	return ret;
>  }
>
> +static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
> +{
> +	if (stream->bo)
> +		xe_bo_unpin_map_no_vm(stream->bo);
> +}
> +
> +static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> +				   u16 num_xecore)
> +{
> +	struct xe_tile *tile = stream->gt->tile;
> +	struct xe_bo *bo;
> +	u32 size;
> +
> +	size = stream->per_xecore_buf_size * num_xecore;
> +
> +	bo = xe_bo_create_pin_map_at_aligned(tile->xe, tile, NULL,
> +					     size, ~0ull, ttm_bo_type_kernel,
> +					     XE_BO_FLAG_SYSTEM | XE_BO_FLAG_GGTT, SZ_64);
> +	if (IS_ERR(bo))
> +		return PTR_ERR(bo);
> +
> +	XE_WARN_ON(!IS_ALIGNED(xe_bo_ggtt_addr(bo), SZ_64));
> +	stream->bo = bo;
> +
> +	return 0;
> +}
> +
> +static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> +{
> +	u32 write_ptr_reg, write_ptr, read_ptr_reg, reg_value;
> +	struct per_xecore_buf *xecore_buf;
> +	struct xe_gt *gt = stream->gt;
> +	u16 group, instance;
> +	unsigned int fw_ref;
> +	int xecore;
> +
> +	/* Take runtime pm ref and forcewake to disable RC6 */
> +	xe_pm_runtime_get(gt_to_xe(gt));
> +	fw_ref = xe_force_wake_get(gt_to_fw(gt), XE_FW_RENDER);
> +	if (!xe_force_wake_ref_has_domain(fw_ref, XE_FW_RENDER)) {
> +		xe_gt_err(gt, "Failed to get RENDER forcewake\n");
> +		xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);

The above line should not be there.

> +		xe_pm_runtime_put(gt_to_xe(gt));
> +		return -ETIMEDOUT;
> +	}
> +
> +	for_each_dss_steering(xecore, gt, group, instance) {
> +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> +		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
> +		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);

My previous question regarding this is still unanswered: "Why do we need to
do all this, read the write ptr reg and write to read ptr register? Can't
we just set both read and write ptr to the start of the per xecore buf
address (likely stream->bo ggtt_addr).

> +		/* Initialize the read pointer to the write pointer */
> +		xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> +		write_ptr <<= 6;
> +		write_ptr &= (stream->per_xecore_buf_size << 1) - 1;
> +		xecore_buf = &stream->xecore_buf[xecore];
> +		xecore_buf->write = write_ptr;
> +		xecore_buf->read = write_ptr;
> +	}
> +	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
> +				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |

Please explain this mocs.uc_index business, as I mentioned in the prev version.

> +				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> +						 stream->sampling_rate_mult));
> +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_CTRL, reg_value);
> +	/* GGTT addresses can never be > 32 bits */
> +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE_UPPER, 0);
> +	reg_value = xe_bo_ggtt_addr(stream->bo);
> +	reg_value |= REG_FIELD_PREP(XEHPC_EUSTALL_BASE_XECORE_BUF_SZ, 2);

This "2" should be derived from per_xecore_buf_size or
stream->per_xecore_buf_size by dividing by 256, as I previously indicated.

> +	reg_value |= XEHPC_EUSTALL_BASE_ENABLE_SAMPLING;
> +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, reg_value);
> +
> +	return 0;
> +}
> +
> +static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> +				   struct eu_stall_open_properties *props)
> +{
> +	struct per_xecore_buf *xecore_buf;
> +	u16 num_xecore, group, instance;
> +	struct xe_gt *gt = stream->gt;
> +	xe_dss_mask_t all_xecore;
> +	u32 vaddr_offset;

Should probably be size_t

> +	int ret, xecore;
> +
> +	stream->sampling_rate_mult = props->sampling_rate_mult;
> +	stream->wait_num_reports = props->wait_num_reports;
> +	stream->per_xecore_buf_size = per_xecore_buf_size;
> +	stream->data_record_size = xe_eu_stall_data_record_size(gt_to_xe(gt));
> +
> +	bitmap_or(all_xecore, gt->fuse_topo.g_dss_mask, gt->fuse_topo.c_dss_mask,
> +		  XE_MAX_DSS_FUSE_BITS);
> +	/*
> +	 * Enabled subslices can be discontiguous. Find the maximum number of subslices
> +	 * that are enabled.
> +	 */
> +	num_xecore = xe_gt_topology_mask_last_dss(all_xecore) + 1;
> +
> +	ret = alloc_eu_stall_data_buf(stream, num_xecore);
> +	if (ret)
> +		return ret;
> +
> +	stream->xecore_buf = kcalloc(num_xecore, sizeof(*stream->xecore_buf), GFP_KERNEL);
> +	if (!stream->xecore_buf)
> +		return -ENOMEM;

What about free_eu_stall_data_buf here?

The way to do this is: either the function succeeds, or if it fails, it
frees all resources it allocates before returning.

> +
> +	for_each_dss_steering(xecore, gt, group, instance) {
> +		xecore_buf = &stream->xecore_buf[xecore];
> +		vaddr_offset = xecore * stream->per_xecore_buf_size;
> +		xecore_buf->vaddr = stream->bo->vmap.vaddr + vaddr_offset;
> +		mutex_init(&xecore_buf->ptr_lock);
> +	}
> +	return 0;
> +}
> +
>  /**
>   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
>   *
> @@ -181,6 +406,49 @@ static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
>	return ret;
>  }
>
> +static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
> +{
> +	int ret = 0;
> +
> +	if (stream->enabled)
> +		return ret;
> +
> +	stream->enabled = true;
> +
> +	ret = xe_eu_stall_stream_enable(stream);
> +	return ret;
> +}
> +
> +static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
> +{
> +	struct xe_gt *gt = stream->gt;
> +
> +	if (!stream->enabled)
> +		return 0;
> +
> +	stream->enabled = false;
> +
> +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> +
> +	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> +	xe_pm_runtime_put(gt_to_xe(gt));
> +
> +	return 0;
> +}
> +
> +static long xe_eu_stall_stream_ioctl_locked(struct xe_eu_stall_data_stream *stream,
> +					    unsigned int cmd, unsigned long arg)
> +{
> +	switch (cmd) {
> +	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> +		return xe_eu_stall_enable_locked(stream);
> +	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> +		return xe_eu_stall_disable_locked(stream);
> +	}
> +
> +	return -EINVAL;
> +}
> +
>  /**
>   * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
>   *
> @@ -195,14 +463,22 @@ static long xe_eu_stall_stream_ioctl(struct file *file,
>				     unsigned int cmd,
>				     unsigned long arg)
>  {
> -	switch (cmd) {
> -	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> -		return 0;
> -	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> -		return 0;
> -	}
> +	struct xe_eu_stall_data_stream *stream = file->private_data;
> +	struct xe_gt *gt = stream->gt;
> +	long ret;
>
> -	return -EINVAL;
> +	mutex_lock(&gt->eu_stall->stream_lock);
> +	ret = xe_eu_stall_stream_ioctl_locked(stream, cmd, arg);
> +	mutex_unlock(&gt->eu_stall->stream_lock);
> +
> +	return ret;
> +}
> +
> +static void
> +xe_eu_stall_stream_close_locked(struct xe_eu_stall_data_stream *stream)
> +{
> +	xe_eu_stall_disable_locked(stream);
> +	free_eu_stall_data_buf(stream);
>  }

I don't see the point of this function since it is just called from one
place xe_eu_stall_stream_close. You might as well put these 2 lines of code
there.

As suggested below we can have a xe_eu_stall_stream_destroy() which can be
called from xe_eu_stall_stream_open_locked() and from
xe_eu_stall_stream_close(). But optional.

>
>  /**
> @@ -215,6 +491,19 @@ static long xe_eu_stall_stream_ioctl(struct file *file,
>   */
>  static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
>  {
> +	struct xe_eu_stall_data_stream *stream = file->private_data;
> +	struct xe_gt *gt = stream->gt;
> +
> +	mutex_lock(&gt->eu_stall->stream_lock);
> +	xe_eu_stall_stream_close_locked(stream);
> +	kfree(stream->xecore_buf);
> +	kfree(stream);
> +	gt->eu_stall->stream = NULL;

This sequence should generally be identical to the error unwind sequence in
xe_eu_stall_stream_open_locked.

> +	mutex_unlock(&gt->eu_stall->stream_lock);
> +
> +	/* Release the reference the EU stall stream kept on the driver */
> +	drm_dev_put(&gt->tile->xe->drm);
> +
>	return 0;
>  }
>
> @@ -230,7 +519,67 @@ static const struct file_operations fops_eu_stall = {
>
>  static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
>  {
> -	return false;
> +	return ((xe->info.platform == XE_PVC) ? true : false);

return xe->info.platform == XE_PVC;

> +}
> +
> +/**
> + * xe_eu_stall_stream_open_locked - Open a EU stall data stream FD.
> + * @dev: drm device instance
> + * @props: individually validated u64 property value pairs
> + * @file: drm file
> + *
> + * Returns: zero on success or a negative error code.
> + */
> +static int
> +xe_eu_stall_stream_open_locked(struct drm_device *dev,
> +			       struct eu_stall_open_properties *props,
> +			       struct drm_file *file)
> +{
> +	struct xe_eu_stall_data_stream *stream;
> +	struct xe_gt *gt = props->gt;
> +	unsigned long f_flags = 0;
> +	int ret, stream_fd;
> +
> +	/* Only one session can be active at any time */
> +	if (gt->eu_stall->stream) {
> +		xe_gt_dbg(gt, "EU stall sampling session already active\n");
> +		return -EBUSY;
> +	}
> +
> +	stream = kzalloc(sizeof(*stream), GFP_KERNEL);
> +	if (!stream)
> +		return -ENOMEM;
> +
> +	gt->eu_stall->stream = stream;
> +	stream->gt = gt;
> +
> +	ret = xe_eu_stall_stream_init(stream, props);
> +	if (ret) {
> +		xe_gt_dbg(gt, "EU stall stream init failed : %d\n", ret);
> +		goto err_alloc;

This is wrong as pointed below. If this fails we jump to 'kfree(stream)'.

Also don't invent random label names. See
xe_oa_stream_open_ioctl_locked(): err_destroy is for destroy, err_free for
free etc.

So this should be goto err_free.

> +	}
> +
> +	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, stream, f_flags);
> +	if (stream_fd < 0) {
> +		ret = stream_fd;
> +		xe_gt_dbg(gt, "EU stall inode get fd failed : %d\n", ret);
> +		goto err_open;

goto err_destroy. see below.

> +	}
> +
> +	/* Take a reference on the driver that will be kept with stream_fd
> +	 * until its release.
> +	 */
> +	drm_dev_get(&gt->tile->xe->drm);
> +
> +	return stream_fd;
> +
> +err_open:
> +	free_eu_stall_data_buf(stream);
> +err_alloc:
> +	gt->eu_stall->stream = NULL;
> +	kfree(stream->xecore_buf);

This is wrong, stream->xecore_buf is allocated in xe_eu_stall_stream_init
and we are jumping here if xe_eu_stall_stream_init fails.

See xe_oa_stream_open_ioctl_locked() as an example for doing this unwinding
correctly. We need a 'destroy' function which will free stuff allocated in
xe_eu_stall_stream_init. And that function should be called from
close/release too.

Ideally, we should not have to peek inside these functions to see what is
being allocated there and then free them. The destroy function is the
wrapper which should do all the free's.

Or maybe if you want to skip destroy() we can do that too, but at least the
code here needs to be fixed.

> +	kfree(stream);

err_free label before this line. Should do kfree(stream) and
'gt->eu_stall->stream = NULL'.

> +	return ret;

So basically, without destroy(), this is something like:

	err_destroy:
		kfree(stream->xecore_buf);
		free_eu_stall_data_buf(stream);
	err_free:
		kfree(stream);
		gt->eu_stall->stream = NULL;
		return ret;

Not what you have above. And the code under err_destroy can go into a
destroy() function, but if you want we can skip that for now.


>  }
>
>  /**
> @@ -252,7 +601,7 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
>  {
>	struct xe_device *xe = to_xe_device(dev);
>	struct eu_stall_open_properties props = {};
> -	int ret, stream_fd;
> +	int ret;
>
>	if (xe_observation_paranoid && !perfmon_capable()) {
>		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
> @@ -263,6 +612,10 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
>		return -EPERM;
>	}
>
> +	/* Initialize and set default values */
> +	props.wait_num_reports = 1;
> +	props.sampling_rate_mult = 4;

What about props.gt? Can it also be initialized to gt[0], corresponding to
default gt_id 0, basically default gt if not specified in uapi is gt0?

> +
>	ret = xe_eu_stall_user_extensions(xe, data, &props);
>	if (ret)
>		return ret;
> @@ -272,9 +625,9 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
>		return -EINVAL;
>	}
>
> -	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
> -	if (stream_fd < 0)
> -		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
> +	mutex_lock(&props.gt->eu_stall->stream_lock);
> +	ret = xe_eu_stall_stream_open_locked(dev, &props, file);
> +	mutex_unlock(&props.gt->eu_stall->stream_lock);
>
> -	return stream_fd;
> +	return ret;
>  }
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
> index d514e78341d5..e42250c1d294 100644
> --- a/drivers/gpu/drm/xe/xe_eu_stall.h
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.h
> @@ -6,9 +6,10 @@
>  #ifndef __XE_EU_STALL_H__
>  #define __XE_EU_STALL_H__
>
> -#include <drm/drm_device.h>
> -#include <drm/drm_file.h>
> -#include <linux/types.h>
> +#include "xe_gt_types.h"
> +
> +int xe_eu_stall_init(struct xe_gt *gt);
> +void xe_eu_stall_fini(struct xe_gt *gt);
>
>  int xe_eu_stall_stream_open(struct drm_device *dev,
>			    u64 data,
> diff --git a/drivers/gpu/drm/xe/xe_gt.c b/drivers/gpu/drm/xe/xe_gt.c
> index 9fb8f1e678dc..ee5a16727300 100644
> --- a/drivers/gpu/drm/xe/xe_gt.c
> +++ b/drivers/gpu/drm/xe/xe_gt.c
> @@ -60,6 +60,7 @@
>  #include "xe_vm.h"
>  #include "xe_wa.h"
>  #include "xe_wopcm.h"
> +#include "xe_eu_stall.h"
>
>  static void gt_fini(struct drm_device *drm, void *arg)
>  {
> @@ -159,6 +160,7 @@ void xe_gt_remove(struct xe_gt *gt)
>		xe_hw_fence_irq_finish(&gt->fence_irq[i]);
>
>	xe_gt_disable_host_l2_vram(gt);
> +	xe_eu_stall_fini(gt);

Maybe move to the top of the function, so that fini happens in reverse
order to init?

>  }
>
>  static void gt_reset_worker(struct work_struct *w);
> @@ -625,6 +627,10 @@ int xe_gt_init(struct xe_gt *gt)
>
>	xe_gt_record_user_engines(gt);
>
> +	err = xe_eu_stall_init(gt);
> +	if (err)
> +		return err;
> +
>	return 0;
>  }
>
> diff --git a/drivers/gpu/drm/xe/xe_gt_types.h b/drivers/gpu/drm/xe/xe_gt_types.h
> index 6e66bf0e8b3f..833a1a67e9ae 100644
> --- a/drivers/gpu/drm/xe/xe_gt_types.h
> +++ b/drivers/gpu/drm/xe/xe_gt_types.h
> @@ -430,6 +430,9 @@ struct xe_gt {
>
>	/** @oa: oa observation subsystem per gt info */
>	struct xe_oa_gt oa;
> +
> +	/** @eu_stall: EU stall counters subsystem per gt info */
> +	struct xe_eu_stall_gt *eu_stall;

This needs a forward declaration for 'struct xe_eu_stall_gt'.

>  };
>
>  #endif
> --
> 2.48.1
>

Re: [PATCH v9 0/8] Add support for EU stall sampling

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:41 -0800, Harish Chegondi wrote:
>

Hi Harish,

> The following patch series add support for EU stall sampling,
> a new hardware feature first added in PVC and is being supported
> in XE2 and later architecture GPUs. This feature would enable
> capturing of EU stall data which include the IP address of the
> instruction stalled and various stall reason counts.
>
> Support for this feature is being added into Mesa:
> https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/30142
>
> New IGT tests for EU stall sampling are being added:
> https://patchwork.freedesktop.org/series/143030/
>
> This patch series has undergone basic testing with the new IGT tests.

Before posting the next version, could you please update the IGT to sync
with this version. And then include a "Test-with:" in the the next kernel
version, so that we can see some Eu Stall IGT's running in the pre-merge?

No need to fix all IGT issues yet, if you don't have the time now. That can
be done later. Just fix the IGT's enough for the tests to run and hopefully
pass, when we post new versions for the kernel series.

Thanks.
--
Ashutosh

>
> Thank You.
>
> v9: a. Split the big patch in v8 into two patches
>     b. Moved all drop data handling code into one patch
>     c. Several other code improvements as mentioned in the patches
> v8: a. Used div_u64() instead of / to fix 32-bit build issue.
>     b. Changed copyright year in new files to 2025.
>     c. Renamed struct drm_xe_eu_stall_data_pvc to struct xe_eu_stall_data_pvc
>     d. Renamed struct drm_xe_eu_stall_data_xe2 to struct xe_eu_stall_data_xe2
>
> v7: a. Renamed input property DRM_XE_EU_STALL_PROP_EVENT_REPORT_COUNT
>        to DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS to be consistent with
>        OA. Renamed the corresponding internal variables.
>     b. Fixed some commit messages based on review feedback.
>     c. Changed sampling_rates from a pointer to flexible array.
>
> v6: a. Changed the uAPI input to accept sampling rate in GPU cycles
>        instead of sampling rate multiplier.
>     b. Fix buffer wrap around over write bug (Matt Olson).
>     c. Include EU stall sampling rates information and per XeCore buffer size in the query information.
>
> v5: Addressed review feedback from v4 including
>     a. Removed DRM_XE_EU_STALL_PROP_POLL_PERIOD from the uAPI (Ashutosh)
>     b. Separated the patches for Xe_HPC and Xe2 (Matt R)
>     c. Moved read() returning -EIO into a separate patch
>     d. Removed spinlocks around set_bit() and clear_bit() (Matt R)
>     e. Renamed several variables, structures and enums (Ashutosh and
> Matt R)
>     f. Addressed other review feedback.
> v4: Addressed review feedback from v3 including
>     a. Split the patch into multiple patches (Matt R)
>     b. Added a new device query to get EU stall info (Ashutosh)
>     c. Renamed all Dss to xecore (Matt R)
>     d. Removed buffer size and disable at open input properties. (Matt R)
>     e. Removed the "_SHIFT" macros (Matt R)
>     f. Allocate the EU stall buffer only on system memory.
>     g. Changed the work arounds to OOB (Matt R)
>     h. Other review feedback.
> v3: a. Removed data header and changed read() to return -EIO when data is dropped by the HW.
>     b. Added a new DRM_XE_OBSERVATION_IOCTL_INFO to query EU stall data record info
>     c. Added struct drm_xe_eu_stall_data_pvc and struct drm_xe_eu_stall_data_xe2
>        to xe_drm.h. These declarations would help user space to parse the
>        EU stall data
>     d. Addressed other review comments from v2
> v2: Rename xe perf layer as xe observation layer (Ashutosh)
>
> Reviewed-by: Ben Olson <matthew.olson@intel.com>
> Acked-by: Felix Degrood <felix.j.degrood@intel.com>
> Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>
>
> Harish Chegondi (8):
>   drm/xe/topology: Add a function to find the index of the last enabled
>     DSS in a mask
>   drm/xe/uapi: Introduce API for EU stall sampling
>   drm/xe/eustall: Add support to init, enable and disable EU stall
>     sampling
>   drm/xe/eustall: Add support to read() and poll() EU stall data
>   drm/xe/eustall: Add support to handle dropped EU stall data
>   drm/xe/eustall: Add EU stall sampling support for Xe2
>   drm/xe/uapi: Add a device query to get EU stall sampling information
>   drm/xe/eustall: Add workaround 22016596838 which applies to PVC.
>
>  drivers/gpu/drm/xe/Makefile                |    1 +
>  drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h |   29 +
>  drivers/gpu/drm/xe/xe_eu_stall.c           | 1029 ++++++++++++++++++++
>  drivers/gpu/drm/xe/xe_eu_stall.h           |   21 +
>  drivers/gpu/drm/xe/xe_gt.c                 |    6 +
>  drivers/gpu/drm/xe/xe_gt_topology.h        |   13 +
>  drivers/gpu/drm/xe/xe_gt_types.h           |    3 +
>  drivers/gpu/drm/xe/xe_observation.c        |   14 +
>  drivers/gpu/drm/xe/xe_query.c              |   38 +
>  drivers/gpu/drm/xe/xe_trace.h              |   33 +
>  drivers/gpu/drm/xe/xe_wa_oob.rules         |    1 +
>  include/uapi/drm/xe_drm.h                  |   74 ++
>  12 files changed, 1262 insertions(+)
>  create mode 100644 drivers/gpu/drm/xe/regs/xe_eu_stall_regs.h
>  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.c
>  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.h
>
> --
> 2.48.1
>

Re: [PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 15:07:51 -0800, Dixit, Ashutosh wrote:
>
> > +static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
> > +					   struct eu_stall_open_properties *props)
> > +{
> > +	value = div_u64(value, 251);
> > +	if (value == 0 || value > 7) {
> > +		drm_dbg(&xe->drm, "Invalid EU stall sampling rate %llu\n", value);
> > +		return -EINVAL;
> > +	}
> > +	props->sampling_rate_mult = value;
> > +	return 0;
> > +}
> > +
> > +static int set_prop_eu_stall_wait_num_reports(struct xe_device *xe, u64 value,
> > +					      struct eu_stall_open_properties *props)
> > +{
> > +	unsigned int max_wait_num_reports;
> > +
> > +	max_wait_num_reports = num_data_rows(per_xecore_buf_size * XE_MAX_DSS_FUSE_BITS);
>
> This seems wrong. Instead of XE_MAX_DSS_FUSE_BITS, shouldn't we use the
> value returned by xe_gt_topology_mask_last_dss()?
>
> Note that a large value can result in the poll/read never getting
> unblocked!
>
> To solve this issue I think num_xecore should be maintained in struct
> xe_eu_stall_gt. Though let's see what happens to 'struct xe_device *' arg
> to these functions if we do this.

Also, even with num_xecore (instead of XE_MAX_DSS_FUSE_BITS), I think

      max_wait_num_reports = num_data_rows(per_xecore_buf_size * num_xecore)

is a very large value. If user specifies this value, we will almost
certainly start dropping data. So maybe max_wait_num_reports should be half
of this value?

Or do we just leave this max and let the user deal with -EIO returns?

Anyway something to think about.

Re: [PATCH v9 3/8] drm/xe/eustall: Add support to init, enable and disable EU stall sampling

[Harish Chegondi]

On Tue, Feb 11, 2025 at 09:33:55AM -0800, Dixit, Ashutosh wrote:
> On Mon, 10 Feb 2025 05:46:44 -0800, Harish Chegondi wrote:
> >
> 
Hi Ashutosh,
> Hi Harish,
> 
> > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > index 0ceb3091f81e..12afa9720971 100644
> > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > @@ -8,17 +8,57 @@
> >  #include <linux/poll.h>
> >  #include <linux/types.h>
> >
> > +#include <drm/drm_drv.h>
> >  #include <uapi/drm/xe_drm.h>
> >
> > +#include "xe_bo.h"
> >  #include "xe_device.h"
> >  #include "xe_eu_stall.h"
> > +#include "xe_force_wake.h"
> > +#include "xe_gt_mcr.h"
> >  #include "xe_gt_printk.h"
> >  #include "xe_gt_topology.h"
> >  #include "xe_macros.h"
> >  #include "xe_observation.h"
> > +#include "xe_pm.h"
> > +
> > +#include "regs/xe_eu_stall_regs.h"
> > +#include "regs/xe_gt_regs.h"
> > +
> > +#define POLL_PERIOD_MS	10
> >
> >  static size_t per_xecore_buf_size = SZ_512K;
> >
> > +struct per_xecore_buf {
> > +	/* Buffer vaddr */
> > +	u8 *vaddr;
> > +	/* Write pointer */
> > +	u32 write;
> > +	/* Read pointer */
> > +	u32 read;
> > +	/* lock to protect read and write pointers */
> > +	struct mutex ptr_lock;
> > +};
> > +
> > +struct xe_eu_stall_data_stream {
> > +	bool enabled;
> > +	size_t data_record_size;
> > +	size_t per_xecore_buf_size;
> > +	unsigned int wait_num_reports;
> > +	unsigned int sampling_rate_mult;
> > +
> > +	struct xe_gt *gt;
> > +	struct xe_bo *bo;
> > +	struct per_xecore_buf *xecore_buf;
> > +};
> > +
> > +struct xe_eu_stall_gt {
> > +	/* Lock to protect stream */
> > +	struct mutex stream_lock;
> > +	/* EU stall data stream */
> > +	struct xe_eu_stall_data_stream *stream;
> > +};
> > +
> >  /**
> >   * struct eu_stall_open_properties - EU stall sampling properties received
> >   *				     from user space at open.
> > @@ -33,6 +73,47 @@ struct eu_stall_open_properties {
> >	struct xe_gt *gt;
> >  };
> >
> > +/**
> > + * struct xe_eu_stall_data_pvc - EU stall data format for PVC
> > + *			Bits		Field
> > + * @ip_addr:		0  to 28	IP (addr)
> > + * @active_count:	29 to 36	active count
> > + * @other_count:	37 to 44	other count
> > + * @control_count:	45 to 52	control count
> > + * @pipestall_count:	53 to 60	pipestall count
> > + * @send_count:		61 to 68	send count
> > + * @dist_acc_count:	69 to 76	dist_acc count
> > + * @sbid_count:		77 to 84	sbid count
> > + * @sync_count:		85 to 92	sync count
> > + * @inst_fetch_count:	93 to 100	inst_fetch count
> > + * @unused_bits:	101 to 127	unused bits
> > + * @unused:		remaining	unused bytes
> > + */
> 
> I'd say delete this comment, it seems to be no zero extra information above
> what is already included in the struct below.
> 
> If you want to document the bit positions, add them on the same line as the
> struct field, e.g.:
> 
> 	__u64 active_count:8; /* bits 36:29 */

hooks scripts complain if I don't describe individual fields. I either
have to move the descriptions above each field or remove the description
of the structure above - "struct xe_eu_stall_data_pvc - EU stall data
format for PVC". Let me check if the hooks scripts complain if I
document the bit positions like you suggested.

> 
> > +struct xe_eu_stall_data_pvc {
> > +	__u64 ip_addr:29;
> > +	__u64 active_count:8;
> > +	__u64 other_count:8;
> > +	__u64 control_count:8;
> > +	__u64 pipestall_count:8;
> > +	__u64 send_count:8;
> > +	__u64 dist_acc_count:8;
> > +	__u64 sbid_count:8;
> > +	__u64 sync_count:8;
> > +	__u64 inst_fetch_count:8;
> > +	__u64 unused_bits:27;
> > +	__u64 unused[6];
> > +} __packed;
> > +
> > +static size_t xe_eu_stall_data_record_size(struct xe_device *xe)
> > +{
> > +	unsigned long record_size = 0;
> > +
> > +	if (xe->info.platform == XE_PVC)
> > +		record_size = sizeof(struct xe_eu_stall_data_pvc);
> > +
> > +	return record_size;
> > +}
> > +
> >  /**
> >   * num_data_rows - Return the number of EU stall data rows of 64B each
> >   *		   for a given data size.
> > @@ -44,6 +125,36 @@ static u32 num_data_rows(u32 data_size)
> >	return (data_size >> 6);
> >  }
> >
> > +/**
> > + * xe_eu_stall_init() - Allocate and initialize GT level EU stall data
> > + *			structure xe_eu_stall_gt within struct xe_gt.
> > + *
> > + * @gt: GT being initialized.
> > + *
> > + * Returns: zero on success or a negative error code.
> > + */
> > +int xe_eu_stall_init(struct xe_gt *gt)
> > +{
> > +	gt->eu_stall = kzalloc(sizeof(*gt->eu_stall), GFP_KERNEL);
> > +	if (!gt->eu_stall)
> > +		return -ENOMEM;
> > +
> > +	mutex_init(&gt->eu_stall->stream_lock);
> > +	return 0;
> > +}
> > +
> > +/**
> > + * xe_eu_stall_fini() - Clean up the GT level EU stall data
> > + *			structure xe_eu_stall_gt within struct xe_gt.
> > + *
> > + * @gt: GT being cleaned up.
> > + */
> > +void xe_eu_stall_fini(struct xe_gt *gt)
> > +{
> > +	mutex_destroy(&gt->eu_stall->stream_lock);
> > +	kfree(gt->eu_stall);
> > +}
> > +
> >  static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
> >					   struct eu_stall_open_properties *props)
> >  {
> > @@ -166,6 +277,120 @@ static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> >	return ret;
> >  }
> >
> > +static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
> > +{
> > +	if (stream->bo)
> > +		xe_bo_unpin_map_no_vm(stream->bo);
> > +}
> > +
> > +static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> > +				   u16 num_xecore)
> > +{
> > +	struct xe_tile *tile = stream->gt->tile;
> > +	struct xe_bo *bo;
> > +	u32 size;
> > +
> > +	size = stream->per_xecore_buf_size * num_xecore;
> > +
> > +	bo = xe_bo_create_pin_map_at_aligned(tile->xe, tile, NULL,
> > +					     size, ~0ull, ttm_bo_type_kernel,
> > +					     XE_BO_FLAG_SYSTEM | XE_BO_FLAG_GGTT, SZ_64);
> > +	if (IS_ERR(bo))
> > +		return PTR_ERR(bo);
> > +
> > +	XE_WARN_ON(!IS_ALIGNED(xe_bo_ggtt_addr(bo), SZ_64));
> > +	stream->bo = bo;
> > +
> > +	return 0;
> > +}
> > +
> > +static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > +{
> > +	u32 write_ptr_reg, write_ptr, read_ptr_reg, reg_value;
> > +	struct per_xecore_buf *xecore_buf;
> > +	struct xe_gt *gt = stream->gt;
> > +	u16 group, instance;
> > +	unsigned int fw_ref;
> > +	int xecore;
> > +
> > +	/* Take runtime pm ref and forcewake to disable RC6 */
> > +	xe_pm_runtime_get(gt_to_xe(gt));
> > +	fw_ref = xe_force_wake_get(gt_to_fw(gt), XE_FW_RENDER);
> > +	if (!xe_force_wake_ref_has_domain(fw_ref, XE_FW_RENDER)) {
> > +		xe_gt_err(gt, "Failed to get RENDER forcewake\n");
> > +		xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> 
> The above line should not be there.
I think you are correct. Not sure why there are several places in the xe
driver where xe_force_wake_put() is called if a forcewake ref doesn't
have a domain. It makes sense for XE_FORCEWAKE_ALL, as getting a
reference on XE_FORCEWAKE_ALL will only get reference on applicable
domains. Also I didn't use XE_FORCEWAKE_ALL as the all the EU stall
hardware is in the XE_FW_RENDER domain so don't need XE_FORCEWAKE_ALL.
> 
> > +		xe_pm_runtime_put(gt_to_xe(gt));
> > +		return -ETIMEDOUT;
> > +	}
> > +
> > +	for_each_dss_steering(xecore, gt, group, instance) {
> > +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> > +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > +		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
> > +		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> 
> My previous question regarding this is still unanswered: "Why do we need to
> do all this, read the write ptr reg and write to read ptr register? Can't
> we just set both read and write ptr to the start of the per xecore buf
> address (likely stream->bo ggtt_addr).

Hardware doesn't allow writes to the write pointer. I believe it may be
a security risk and therefore doesn't allow it. That's the reason I read
the write pointer and set the value to the read pointer.

> 
> > +		/* Initialize the read pointer to the write pointer */
> > +		xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> > +		write_ptr <<= 6;
> > +		write_ptr &= (stream->per_xecore_buf_size << 1) - 1;
> > +		xecore_buf = &stream->xecore_buf[xecore];
> > +		xecore_buf->write = write_ptr;
> > +		xecore_buf->read = write_ptr;
> > +	}
> > +	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
> > +				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
> 
> Please explain this mocs.uc_index business, as I mentioned in the prev version.
MOCS stands for Memory Object Control State is used to specify memory
attributes. MOCS is a set of registers with each register specifying a
certain combination of memory attributes. MOCS index is used to look up the set of
MOCS registers where the corresponding control parameters are specified.

Bits[3:9] in the control register indicate the MOCS programming that
should be applied to stall data eviction. As per the format, bit-0 is
reserved and bits 1 to 6 are for MOCS table index. Therefore the index
is shifted left by 1.

> 
> > +				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> > +						 stream->sampling_rate_mult));
> > +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_CTRL, reg_value);
> > +	/* GGTT addresses can never be > 32 bits */
> > +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE_UPPER, 0);
> > +	reg_value = xe_bo_ggtt_addr(stream->bo);
> > +	reg_value |= REG_FIELD_PREP(XEHPC_EUSTALL_BASE_XECORE_BUF_SZ, 2);
> 
> This "2" should be derived from per_xecore_buf_size or
> stream->per_xecore_buf_size by dividing by 256, as I previously indicated.

Even though the hardware allows the user to configure the buffer size to
128K/256K/512K, for simplicity we decided to use the highest buffer size
512K for which the register setting is 2. If the future I plan to send
out a patch that allows the user to change the buffer size via debugfs
as the user may choose to use a smaller buffer size for debug purpose.
In that patch I will add as you suggested. But for now, I think it
is not required to divide by 256.

> 
> > +	reg_value |= XEHPC_EUSTALL_BASE_ENABLE_SAMPLING;
> > +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, reg_value);
> > +
> > +	return 0;
> > +}
> > +
> > +static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > +				   struct eu_stall_open_properties *props)
> > +{
> > +	struct per_xecore_buf *xecore_buf;
> > +	u16 num_xecore, group, instance;
> > +	struct xe_gt *gt = stream->gt;
> > +	xe_dss_mask_t all_xecore;
> > +	u32 vaddr_offset;
> 
> Should probably be size_t
> 
> > +	int ret, xecore;
> > +
> > +	stream->sampling_rate_mult = props->sampling_rate_mult;
> > +	stream->wait_num_reports = props->wait_num_reports;
> > +	stream->per_xecore_buf_size = per_xecore_buf_size;
> > +	stream->data_record_size = xe_eu_stall_data_record_size(gt_to_xe(gt));
> > +
> > +	bitmap_or(all_xecore, gt->fuse_topo.g_dss_mask, gt->fuse_topo.c_dss_mask,
> > +		  XE_MAX_DSS_FUSE_BITS);
> > +	/*
> > +	 * Enabled subslices can be discontiguous. Find the maximum number of subslices
> > +	 * that are enabled.
> > +	 */
> > +	num_xecore = xe_gt_topology_mask_last_dss(all_xecore) + 1;
> > +
> > +	ret = alloc_eu_stall_data_buf(stream, num_xecore);
> > +	if (ret)
> > +		return ret;
> > +
> > +	stream->xecore_buf = kcalloc(num_xecore, sizeof(*stream->xecore_buf), GFP_KERNEL);
> > +	if (!stream->xecore_buf)
> > +		return -ENOMEM;
> 
> What about free_eu_stall_data_buf here?
> 
> The way to do this is: either the function succeeds, or if it fails, it
> frees all resources it allocates before returning.
Will fix it.
> 
> > +
> > +	for_each_dss_steering(xecore, gt, group, instance) {
> > +		xecore_buf = &stream->xecore_buf[xecore];
> > +		vaddr_offset = xecore * stream->per_xecore_buf_size;
> > +		xecore_buf->vaddr = stream->bo->vmap.vaddr + vaddr_offset;
> > +		mutex_init(&xecore_buf->ptr_lock);
> > +	}
> > +	return 0;
> > +}
> > +
> >  /**
> >   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> >   *
> > @@ -181,6 +406,49 @@ static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> >	return ret;
> >  }
> >
> > +static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
> > +{
> > +	int ret = 0;
> > +
> > +	if (stream->enabled)
> > +		return ret;
> > +
> > +	stream->enabled = true;
> > +
> > +	ret = xe_eu_stall_stream_enable(stream);
> > +	return ret;
> > +}
> > +
> > +static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
> > +{
> > +	struct xe_gt *gt = stream->gt;
> > +
> > +	if (!stream->enabled)
> > +		return 0;
> > +
> > +	stream->enabled = false;
> > +
> > +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> > +
> > +	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> > +	xe_pm_runtime_put(gt_to_xe(gt));
> > +
> > +	return 0;
> > +}
> > +
> > +static long xe_eu_stall_stream_ioctl_locked(struct xe_eu_stall_data_stream *stream,
> > +					    unsigned int cmd, unsigned long arg)
> > +{
> > +	switch (cmd) {
> > +	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> > +		return xe_eu_stall_enable_locked(stream);
> > +	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> > +		return xe_eu_stall_disable_locked(stream);
> > +	}
> > +
> > +	return -EINVAL;
> > +}
> > +
> >  /**
> >   * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
> >   *
> > @@ -195,14 +463,22 @@ static long xe_eu_stall_stream_ioctl(struct file *file,
> >				     unsigned int cmd,
> >				     unsigned long arg)
> >  {
> > -	switch (cmd) {
> > -	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> > -		return 0;
> > -	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> > -		return 0;
> > -	}
> > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > +	struct xe_gt *gt = stream->gt;
> > +	long ret;
> >
> > -	return -EINVAL;
> > +	mutex_lock(&gt->eu_stall->stream_lock);
> > +	ret = xe_eu_stall_stream_ioctl_locked(stream, cmd, arg);
> > +	mutex_unlock(&gt->eu_stall->stream_lock);
> > +
> > +	return ret;
> > +}
> > +
> > +static void
> > +xe_eu_stall_stream_close_locked(struct xe_eu_stall_data_stream *stream)
> > +{
> > +	xe_eu_stall_disable_locked(stream);
> > +	free_eu_stall_data_buf(stream);
> >  }
> 
> I don't see the point of this function since it is just called from one
> place xe_eu_stall_stream_close. You might as well put these 2 lines of code
> there.
Will remove this.
> 
> As suggested below we can have a xe_eu_stall_stream_destroy() which can be
> called from xe_eu_stall_stream_open_locked() and from
> xe_eu_stall_stream_close(). But optional.
> 
> >
> >  /**
> > @@ -215,6 +491,19 @@ static long xe_eu_stall_stream_ioctl(struct file *file,
> >   */
> >  static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
> >  {
> > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > +	struct xe_gt *gt = stream->gt;
> > +
> > +	mutex_lock(&gt->eu_stall->stream_lock);
> > +	xe_eu_stall_stream_close_locked(stream);
> > +	kfree(stream->xecore_buf);
> > +	kfree(stream);
> > +	gt->eu_stall->stream = NULL;
> 
> This sequence should generally be identical to the error unwind sequence in
> xe_eu_stall_stream_open_locked.
> 
> > +	mutex_unlock(&gt->eu_stall->stream_lock);
> > +
> > +	/* Release the reference the EU stall stream kept on the driver */
> > +	drm_dev_put(&gt->tile->xe->drm);
> > +
> >	return 0;
> >  }
> >
> > @@ -230,7 +519,67 @@ static const struct file_operations fops_eu_stall = {
> >
> >  static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
> >  {
> > -	return false;
> > +	return ((xe->info.platform == XE_PVC) ? true : false);
> 
> return xe->info.platform == XE_PVC;
A subsequent patch adds another check for xe2. So, I used the
conditional operator.
> 
> > +}
> > +
> > +/**
> > + * xe_eu_stall_stream_open_locked - Open a EU stall data stream FD.
> > + * @dev: drm device instance
> > + * @props: individually validated u64 property value pairs
> > + * @file: drm file
> > + *
> > + * Returns: zero on success or a negative error code.
> > + */
> > +static int
> > +xe_eu_stall_stream_open_locked(struct drm_device *dev,
> > +			       struct eu_stall_open_properties *props,
> > +			       struct drm_file *file)
> > +{
> > +	struct xe_eu_stall_data_stream *stream;
> > +	struct xe_gt *gt = props->gt;
> > +	unsigned long f_flags = 0;
> > +	int ret, stream_fd;
> > +
> > +	/* Only one session can be active at any time */
> > +	if (gt->eu_stall->stream) {
> > +		xe_gt_dbg(gt, "EU stall sampling session already active\n");
> > +		return -EBUSY;
> > +	}
> > +
> > +	stream = kzalloc(sizeof(*stream), GFP_KERNEL);
> > +	if (!stream)
> > +		return -ENOMEM;
> > +
> > +	gt->eu_stall->stream = stream;
> > +	stream->gt = gt;
> > +
> > +	ret = xe_eu_stall_stream_init(stream, props);
> > +	if (ret) {
> > +		xe_gt_dbg(gt, "EU stall stream init failed : %d\n", ret);
> > +		goto err_alloc;
> 
> This is wrong as pointed below. If this fails we jump to 'kfree(stream)'.
When I wrote this code initially, I may have tried to reduce the goto
labels considering the fact that kfree() checks if the input ptr is NULL
and returns if so.
> 
> Also don't invent random label names. See
> xe_oa_stream_open_ioctl_locked(): err_destroy is for destroy, err_free for
> free etc.
> 
> So this should be goto err_free.
Will change it. I have seen code where the label is named err_alloc to
undo an alloc. I think each developer names the labels differently.
> 
> > +	}
> > +
> > +	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, stream, f_flags);
> > +	if (stream_fd < 0) {
> > +		ret = stream_fd;
> > +		xe_gt_dbg(gt, "EU stall inode get fd failed : %d\n", ret);
> > +		goto err_open;
> 
> goto err_destroy. see below.
> 
> > +	}
> > +
> > +	/* Take a reference on the driver that will be kept with stream_fd
> > +	 * until its release.
> > +	 */
> > +	drm_dev_get(&gt->tile->xe->drm);
> > +
> > +	return stream_fd;
> > +
> > +err_open:
> > +	free_eu_stall_data_buf(stream);
> > +err_alloc:
> > +	gt->eu_stall->stream = NULL;
> > +	kfree(stream->xecore_buf);
> 
> This is wrong, stream->xecore_buf is allocated in xe_eu_stall_stream_init
> and we are jumping here if xe_eu_stall_stream_init fails.
I will change it. But considering the fact that kfree() has a NULL
check, this is not a bug.
> 
> See xe_oa_stream_open_ioctl_locked() as an example for doing this unwinding
> correctly. We need a 'destroy' function which will free stuff allocated in
> xe_eu_stall_stream_init. And that function should be called from
> close/release too.
> 
> Ideally, we should not have to peek inside these functions to see what is
> being allocated there and then free them. The destroy function is the
> wrapper which should do all the free's.
> 
> Or maybe if you want to skip destroy() we can do that too, but at least the
> code here needs to be fixed.
> 
> > +	kfree(stream);
> 
> err_free label before this line. Should do kfree(stream) and
> 'gt->eu_stall->stream = NULL'.
> 
> > +	return ret;
> 
> So basically, without destroy(), this is something like:
> 
> 	err_destroy:
> 		kfree(stream->xecore_buf);
> 		free_eu_stall_data_buf(stream);
> 	err_free:
> 		kfree(stream);
> 		gt->eu_stall->stream = NULL;
> 		return ret;
> 
> Not what you have above. And the code under err_destroy can go into a
> destroy() function, but if you want we can skip that for now.
> 
> 
> >  }
> >
> >  /**
> > @@ -252,7 +601,7 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
> >  {
> >	struct xe_device *xe = to_xe_device(dev);
> >	struct eu_stall_open_properties props = {};
> > -	int ret, stream_fd;
> > +	int ret;
> >
> >	if (xe_observation_paranoid && !perfmon_capable()) {
> >		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
> > @@ -263,6 +612,10 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
> >		return -EPERM;
> >	}
> >
> > +	/* Initialize and set default values */
> > +	props.wait_num_reports = 1;
> > +	props.sampling_rate_mult = 4;
> 
> What about props.gt? Can it also be initialized to gt[0], corresponding to
> default gt_id 0, basically default gt if not specified in uapi is gt0?

I had that initially, but there was a review comment in the first few
versions of this patch review, I think from Matt Roper that GT ID
should be mandatory from the user space.

> 
> > +
> >	ret = xe_eu_stall_user_extensions(xe, data, &props);
> >	if (ret)
> >		return ret;
> > @@ -272,9 +625,9 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
> >		return -EINVAL;
> >	}
> >
> > -	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
> > -	if (stream_fd < 0)
> > -		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
> > +	mutex_lock(&props.gt->eu_stall->stream_lock);
> > +	ret = xe_eu_stall_stream_open_locked(dev, &props, file);
> > +	mutex_unlock(&props.gt->eu_stall->stream_lock);
> >
> > -	return stream_fd;
> > +	return ret;
> >  }
> > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
> > index d514e78341d5..e42250c1d294 100644
> > --- a/drivers/gpu/drm/xe/xe_eu_stall.h
> > +++ b/drivers/gpu/drm/xe/xe_eu_stall.h
> > @@ -6,9 +6,10 @@
> >  #ifndef __XE_EU_STALL_H__
> >  #define __XE_EU_STALL_H__
> >
> > -#include <drm/drm_device.h>
> > -#include <drm/drm_file.h>
> > -#include <linux/types.h>
> > +#include "xe_gt_types.h"
> > +
> > +int xe_eu_stall_init(struct xe_gt *gt);
> > +void xe_eu_stall_fini(struct xe_gt *gt);
> >
> >  int xe_eu_stall_stream_open(struct drm_device *dev,
> >			    u64 data,
> > diff --git a/drivers/gpu/drm/xe/xe_gt.c b/drivers/gpu/drm/xe/xe_gt.c
> > index 9fb8f1e678dc..ee5a16727300 100644
> > --- a/drivers/gpu/drm/xe/xe_gt.c
> > +++ b/drivers/gpu/drm/xe/xe_gt.c
> > @@ -60,6 +60,7 @@
> >  #include "xe_vm.h"
> >  #include "xe_wa.h"
> >  #include "xe_wopcm.h"
> > +#include "xe_eu_stall.h"
> >
> >  static void gt_fini(struct drm_device *drm, void *arg)
> >  {
> > @@ -159,6 +160,7 @@ void xe_gt_remove(struct xe_gt *gt)
> >		xe_hw_fence_irq_finish(&gt->fence_irq[i]);
> >
> >	xe_gt_disable_host_l2_vram(gt);
> > +	xe_eu_stall_fini(gt);
> 
> Maybe move to the top of the function, so that fini happens in reverse
> order to init?
Okay.
> 
> >  }
> >
> >  static void gt_reset_worker(struct work_struct *w);
> > @@ -625,6 +627,10 @@ int xe_gt_init(struct xe_gt *gt)
> >
> >	xe_gt_record_user_engines(gt);
> >
> > +	err = xe_eu_stall_init(gt);
> > +	if (err)
> > +		return err;
> > +
> >	return 0;
> >  }
> >
> > diff --git a/drivers/gpu/drm/xe/xe_gt_types.h b/drivers/gpu/drm/xe/xe_gt_types.h
> > index 6e66bf0e8b3f..833a1a67e9ae 100644
> > --- a/drivers/gpu/drm/xe/xe_gt_types.h
> > +++ b/drivers/gpu/drm/xe/xe_gt_types.h
> > @@ -430,6 +430,9 @@ struct xe_gt {
> >
> >	/** @oa: oa observation subsystem per gt info */
> >	struct xe_oa_gt oa;
> > +
> > +	/** @eu_stall: EU stall counters subsystem per gt info */
> > +	struct xe_eu_stall_gt *eu_stall;
> 
> This needs a forward declaration for 'struct xe_eu_stall_gt'.

I thought so initially, but the compiler didn't complain. I guess because
eu_stall is a pointer and not an instance of struct xe_eu_stall_gt ?
> 
> >  };
> >
> >  #endif
> > --
> > 2.48.1
> >

Thank You
Harish.

Re: [PATCH v9 3/8] drm/xe/eustall: Add support to init, enable and disable EU stall sampling

[Dixit, Ashutosh]

On Tue, 11 Feb 2025 14:02:36 -0800, Harish Chegondi wrote:
>
> On Tue, Feb 11, 2025 at 09:33:55AM -0800, Dixit, Ashutosh wrote:
> > On Mon, 10 Feb 2025 05:46:44 -0800, Harish Chegondi wrote:
> > >
> >
> Hi Ashutosh,
> > Hi Harish,
> >
> > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > index 0ceb3091f81e..12afa9720971 100644
> > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > @@ -8,17 +8,57 @@
> > >  #include <linux/poll.h>
> > >  #include <linux/types.h>
> > >
> > > +#include <drm/drm_drv.h>
> > >  #include <uapi/drm/xe_drm.h>
> > >
> > > +#include "xe_bo.h"
> > >  #include "xe_device.h"
> > >  #include "xe_eu_stall.h"
> > > +#include "xe_force_wake.h"
> > > +#include "xe_gt_mcr.h"
> > >  #include "xe_gt_printk.h"
> > >  #include "xe_gt_topology.h"
> > >  #include "xe_macros.h"
> > >  #include "xe_observation.h"
> > > +#include "xe_pm.h"
> > > +
> > > +#include "regs/xe_eu_stall_regs.h"
> > > +#include "regs/xe_gt_regs.h"
> > > +
> > > +#define POLL_PERIOD_MS	10
> > >
> > >  static size_t per_xecore_buf_size = SZ_512K;
> > >
> > > +struct per_xecore_buf {
> > > +	/* Buffer vaddr */
> > > +	u8 *vaddr;
> > > +	/* Write pointer */
> > > +	u32 write;
> > > +	/* Read pointer */
> > > +	u32 read;
> > > +	/* lock to protect read and write pointers */
> > > +	struct mutex ptr_lock;
> > > +};
> > > +
> > > +struct xe_eu_stall_data_stream {
> > > +	bool enabled;
> > > +	size_t data_record_size;
> > > +	size_t per_xecore_buf_size;
> > > +	unsigned int wait_num_reports;
> > > +	unsigned int sampling_rate_mult;
> > > +
> > > +	struct xe_gt *gt;
> > > +	struct xe_bo *bo;
> > > +	struct per_xecore_buf *xecore_buf;
> > > +};
> > > +
> > > +struct xe_eu_stall_gt {
> > > +	/* Lock to protect stream */
> > > +	struct mutex stream_lock;
> > > +	/* EU stall data stream */
> > > +	struct xe_eu_stall_data_stream *stream;
> > > +};
> > > +
> > >  /**
> > >   * struct eu_stall_open_properties - EU stall sampling properties received
> > >   *				     from user space at open.
> > > @@ -33,6 +73,47 @@ struct eu_stall_open_properties {
> > >	struct xe_gt *gt;
> > >  };
> > >
> > > +/**
> > > + * struct xe_eu_stall_data_pvc - EU stall data format for PVC
> > > + *			Bits		Field
> > > + * @ip_addr:		0  to 28	IP (addr)
> > > + * @active_count:	29 to 36	active count
> > > + * @other_count:	37 to 44	other count
> > > + * @control_count:	45 to 52	control count
> > > + * @pipestall_count:	53 to 60	pipestall count
> > > + * @send_count:		61 to 68	send count
> > > + * @dist_acc_count:	69 to 76	dist_acc count
> > > + * @sbid_count:		77 to 84	sbid count
> > > + * @sync_count:		85 to 92	sync count
> > > + * @inst_fetch_count:	93 to 100	inst_fetch count
> > > + * @unused_bits:	101 to 127	unused bits
> > > + * @unused:		remaining	unused bytes
> > > + */
> >
> > I'd say delete this comment, it seems to be no zero extra information above
> > what is already included in the struct below.
> >
> > If you want to document the bit positions, add them on the same line as the
> > struct field, e.g.:
> >
> >	__u64 active_count:8; /* bits 36:29 */
>
> hooks scripts complain if I don't describe individual fields. I either
> have to move the descriptions above each field or remove the description
> of the structure above - "struct xe_eu_stall_data_pvc - EU stall data
> format for PVC". Let me check if the hooks scripts complain if I
> document the bit positions like you suggested.

Not sure about hooks, maybe because of kernel doc comment format? As long
as we don't have kernel doc comment format, might be ok. Do we want these
struct's to appear in documentation generated by kernel doc?

>
> >
> > > +struct xe_eu_stall_data_pvc {
> > > +	__u64 ip_addr:29;
> > > +	__u64 active_count:8;
> > > +	__u64 other_count:8;
> > > +	__u64 control_count:8;
> > > +	__u64 pipestall_count:8;
> > > +	__u64 send_count:8;
> > > +	__u64 dist_acc_count:8;
> > > +	__u64 sbid_count:8;
> > > +	__u64 sync_count:8;
> > > +	__u64 inst_fetch_count:8;
> > > +	__u64 unused_bits:27;
> > > +	__u64 unused[6];
> > > +} __packed;
> > > +
> > > +static size_t xe_eu_stall_data_record_size(struct xe_device *xe)
> > > +{
> > > +	unsigned long record_size = 0;
> > > +
> > > +	if (xe->info.platform == XE_PVC)
> > > +		record_size = sizeof(struct xe_eu_stall_data_pvc);
> > > +
> > > +	return record_size;
> > > +}
> > > +
> > >  /**
> > >   * num_data_rows - Return the number of EU stall data rows of 64B each
> > >   *		   for a given data size.
> > > @@ -44,6 +125,36 @@ static u32 num_data_rows(u32 data_size)
> > >	return (data_size >> 6);
> > >  }
> > >
> > > +/**
> > > + * xe_eu_stall_init() - Allocate and initialize GT level EU stall data
> > > + *			structure xe_eu_stall_gt within struct xe_gt.
> > > + *
> > > + * @gt: GT being initialized.
> > > + *
> > > + * Returns: zero on success or a negative error code.
> > > + */
> > > +int xe_eu_stall_init(struct xe_gt *gt)
> > > +{
> > > +	gt->eu_stall = kzalloc(sizeof(*gt->eu_stall), GFP_KERNEL);
> > > +	if (!gt->eu_stall)
> > > +		return -ENOMEM;
> > > +
> > > +	mutex_init(&gt->eu_stall->stream_lock);
> > > +	return 0;
> > > +}
> > > +
> > > +/**
> > > + * xe_eu_stall_fini() - Clean up the GT level EU stall data
> > > + *			structure xe_eu_stall_gt within struct xe_gt.
> > > + *
> > > + * @gt: GT being cleaned up.
> > > + */
> > > +void xe_eu_stall_fini(struct xe_gt *gt)
> > > +{
> > > +	mutex_destroy(&gt->eu_stall->stream_lock);
> > > +	kfree(gt->eu_stall);
> > > +}
> > > +
> > >  static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
> > >					   struct eu_stall_open_properties *props)
> > >  {
> > > @@ -166,6 +277,120 @@ static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > >	return ret;
> > >  }
> > >
> > > +static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
> > > +{
> > > +	if (stream->bo)
> > > +		xe_bo_unpin_map_no_vm(stream->bo);
> > > +}
> > > +
> > > +static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> > > +				   u16 num_xecore)
> > > +{
> > > +	struct xe_tile *tile = stream->gt->tile;
> > > +	struct xe_bo *bo;
> > > +	u32 size;
> > > +
> > > +	size = stream->per_xecore_buf_size * num_xecore;
> > > +
> > > +	bo = xe_bo_create_pin_map_at_aligned(tile->xe, tile, NULL,
> > > +					     size, ~0ull, ttm_bo_type_kernel,
> > > +					     XE_BO_FLAG_SYSTEM | XE_BO_FLAG_GGTT, SZ_64);
> > > +	if (IS_ERR(bo))
> > > +		return PTR_ERR(bo);
> > > +
> > > +	XE_WARN_ON(!IS_ALIGNED(xe_bo_ggtt_addr(bo), SZ_64));
> > > +	stream->bo = bo;
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > +{
> > > +	u32 write_ptr_reg, write_ptr, read_ptr_reg, reg_value;
> > > +	struct per_xecore_buf *xecore_buf;
> > > +	struct xe_gt *gt = stream->gt;
> > > +	u16 group, instance;
> > > +	unsigned int fw_ref;
> > > +	int xecore;
> > > +
> > > +	/* Take runtime pm ref and forcewake to disable RC6 */
> > > +	xe_pm_runtime_get(gt_to_xe(gt));
> > > +	fw_ref = xe_force_wake_get(gt_to_fw(gt), XE_FW_RENDER);
> > > +	if (!xe_force_wake_ref_has_domain(fw_ref, XE_FW_RENDER)) {
> > > +		xe_gt_err(gt, "Failed to get RENDER forcewake\n");
> > > +		xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> >
> > The above line should not be there.
> I think you are correct. Not sure why there are several places in the xe
> driver where xe_force_wake_put() is called if a forcewake ref doesn't
> have a domain. It makes sense for XE_FORCEWAKE_ALL, as getting a
> reference on XE_FORCEWAKE_ALL will only get reference on applicable
> domains. Also I didn't use XE_FORCEWAKE_ALL as the all the EU stall
> hardware is in the XE_FW_RENDER domain so don't need XE_FORCEWAKE_ALL.

Sorry, I thought I saw this line was not there in several places but now I
can't find it. So maybe what you could do is:

	xe_force_wake_put(gt_to_fw(gt), fw_ref);

Which is what seems to be done in these instances.

> >
> > > +		xe_pm_runtime_put(gt_to_xe(gt));
> > > +		return -ETIMEDOUT;
> > > +	}
> > > +
> > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> > > +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > > +		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
> > > +		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> >
> > My previous question regarding this is still unanswered: "Why do we need to
> > do all this, read the write ptr reg and write to read ptr register? Can't
> > we just set both read and write ptr to the start of the per xecore buf
> > address (likely stream->bo ggtt_addr).
>
> Hardware doesn't allow writes to the write pointer. I believe it may be
> a security risk and therefore doesn't allow it. That's the reason I read
> the write pointer and set the value to the read pointer.

OK, understood now. I thought the write pointer could be written by a
masked write, but I see that was disallowed later in Bspec.

>
> >
> > > +		/* Initialize the read pointer to the write pointer */
> > > +		xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> > > +		write_ptr <<= 6;
> > > +		write_ptr &= (stream->per_xecore_buf_size << 1) - 1;
> > > +		xecore_buf = &stream->xecore_buf[xecore];
> > > +		xecore_buf->write = write_ptr;
> > > +		xecore_buf->read = write_ptr;
> > > +	}
> > > +	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
> > > +				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
> >
> > Please explain this mocs.uc_index business, as I mentioned in the prev version.
> MOCS stands for Memory Object Control State is used to specify memory
> attributes. MOCS is a set of registers with each register specifying a
> certain combination of memory attributes. MOCS index is used to look up the set of
> MOCS registers where the corresponding control parameters are specified.
>
> Bits[3:9] in the control register indicate the MOCS programming that
> should be applied to stall data eviction. As per the format, bit-0 is
> reserved and bits 1 to 6 are for MOCS table index. Therefore the index
> is shifted left by 1.

OK, thanks.

>
> >
> > > +				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> > > +						 stream->sampling_rate_mult));
> > > +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_CTRL, reg_value);
> > > +	/* GGTT addresses can never be > 32 bits */
> > > +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE_UPPER, 0);
> > > +	reg_value = xe_bo_ggtt_addr(stream->bo);
> > > +	reg_value |= REG_FIELD_PREP(XEHPC_EUSTALL_BASE_XECORE_BUF_SZ, 2);
> >
> > This "2" should be derived from per_xecore_buf_size or
> > stream->per_xecore_buf_size by dividing by 256, as I previously indicated.
>
> Even though the hardware allows the user to configure the buffer size to
> 128K/256K/512K, for simplicity we decided to use the highest buffer size
> 512K for which the register setting is 2. If the future I plan to send
> out a patch that allows the user to change the buffer size via debugfs
> as the user may choose to use a smaller buffer size for debug purpose.
> In that patch I will add as you suggested. But for now, I think it
> is not required to divide by 256.

I think we should show the relationship between "2" and 512K in the code,
so the connection is clear. Also in case someone changes the default
per_xecore_buf_size value and things break.

Can just do something like:

	reg_value |= REG_FIELD_PREP(XEHPC_EUSTALL_BASE_XECORE_BUF_SZ,
					stream->per_xecore_buf_size / 256);

Or define a variable.

You will need to / 256 even for debugfs. Though I am not sure if we should
define a property or debugfs. We'll see.

>
> >
> > > +	reg_value |= XEHPC_EUSTALL_BASE_ENABLE_SAMPLING;
> > > +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, reg_value);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > +				   struct eu_stall_open_properties *props)
> > > +{
> > > +	struct per_xecore_buf *xecore_buf;
> > > +	u16 num_xecore, group, instance;
> > > +	struct xe_gt *gt = stream->gt;
> > > +	xe_dss_mask_t all_xecore;
> > > +	u32 vaddr_offset;
> >
> > Should probably be size_t
> >
> > > +	int ret, xecore;
> > > +
> > > +	stream->sampling_rate_mult = props->sampling_rate_mult;
> > > +	stream->wait_num_reports = props->wait_num_reports;
> > > +	stream->per_xecore_buf_size = per_xecore_buf_size;
> > > +	stream->data_record_size = xe_eu_stall_data_record_size(gt_to_xe(gt));
> > > +
> > > +	bitmap_or(all_xecore, gt->fuse_topo.g_dss_mask, gt->fuse_topo.c_dss_mask,
> > > +		  XE_MAX_DSS_FUSE_BITS);
> > > +	/*
> > > +	 * Enabled subslices can be discontiguous. Find the maximum number of subslices
> > > +	 * that are enabled.
> > > +	 */
> > > +	num_xecore = xe_gt_topology_mask_last_dss(all_xecore) + 1;
> > > +
> > > +	ret = alloc_eu_stall_data_buf(stream, num_xecore);
> > > +	if (ret)
> > > +		return ret;
> > > +
> > > +	stream->xecore_buf = kcalloc(num_xecore, sizeof(*stream->xecore_buf), GFP_KERNEL);
> > > +	if (!stream->xecore_buf)
> > > +		return -ENOMEM;
> >
> > What about free_eu_stall_data_buf here?
> >
> > The way to do this is: either the function succeeds, or if it fails, it
> > frees all resources it allocates before returning.
> Will fix it.
> >
> > > +
> > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > +		xecore_buf = &stream->xecore_buf[xecore];
> > > +		vaddr_offset = xecore * stream->per_xecore_buf_size;
> > > +		xecore_buf->vaddr = stream->bo->vmap.vaddr + vaddr_offset;
> > > +		mutex_init(&xecore_buf->ptr_lock);
> > > +	}
> > > +	return 0;
> > > +}
> > > +
> > >  /**
> > >   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> > >   *
> > > @@ -181,6 +406,49 @@ static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> > >	return ret;
> > >  }
> > >
> > > +static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
> > > +{
> > > +	int ret = 0;
> > > +
> > > +	if (stream->enabled)
> > > +		return ret;
> > > +
> > > +	stream->enabled = true;
> > > +
> > > +	ret = xe_eu_stall_stream_enable(stream);
> > > +	return ret;
> > > +}
> > > +
> > > +static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
> > > +{
> > > +	struct xe_gt *gt = stream->gt;
> > > +
> > > +	if (!stream->enabled)
> > > +		return 0;
> > > +
> > > +	stream->enabled = false;
> > > +
> > > +	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> > > +
> > > +	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> > > +	xe_pm_runtime_put(gt_to_xe(gt));
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static long xe_eu_stall_stream_ioctl_locked(struct xe_eu_stall_data_stream *stream,
> > > +					    unsigned int cmd, unsigned long arg)
> > > +{
> > > +	switch (cmd) {
> > > +	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> > > +		return xe_eu_stall_enable_locked(stream);
> > > +	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> > > +		return xe_eu_stall_disable_locked(stream);
> > > +	}
> > > +
> > > +	return -EINVAL;
> > > +}
> > > +
> > >  /**
> > >   * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
> > >   *
> > > @@ -195,14 +463,22 @@ static long xe_eu_stall_stream_ioctl(struct file *file,
> > >				     unsigned int cmd,
> > >				     unsigned long arg)
> > >  {
> > > -	switch (cmd) {
> > > -	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> > > -		return 0;
> > > -	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> > > -		return 0;
> > > -	}
> > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > +	struct xe_gt *gt = stream->gt;
> > > +	long ret;
> > >
> > > -	return -EINVAL;
> > > +	mutex_lock(&gt->eu_stall->stream_lock);
> > > +	ret = xe_eu_stall_stream_ioctl_locked(stream, cmd, arg);
> > > +	mutex_unlock(&gt->eu_stall->stream_lock);
> > > +
> > > +	return ret;
> > > +}
> > > +
> > > +static void
> > > +xe_eu_stall_stream_close_locked(struct xe_eu_stall_data_stream *stream)
> > > +{
> > > +	xe_eu_stall_disable_locked(stream);
> > > +	free_eu_stall_data_buf(stream);
> > >  }
> >
> > I don't see the point of this function since it is just called from one
> > place xe_eu_stall_stream_close. You might as well put these 2 lines of code
> > there.
> Will remove this.
> >
> > As suggested below we can have a xe_eu_stall_stream_destroy() which can be
> > called from xe_eu_stall_stream_open_locked() and from
> > xe_eu_stall_stream_close(). But optional.
> >
> > >
> > >  /**
> > > @@ -215,6 +491,19 @@ static long xe_eu_stall_stream_ioctl(struct file *file,
> > >   */
> > >  static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
> > >  {
> > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > +	struct xe_gt *gt = stream->gt;
> > > +
> > > +	mutex_lock(&gt->eu_stall->stream_lock);
> > > +	xe_eu_stall_stream_close_locked(stream);
> > > +	kfree(stream->xecore_buf);
> > > +	kfree(stream);
> > > +	gt->eu_stall->stream = NULL;
> >
> > This sequence should generally be identical to the error unwind sequence in
> > xe_eu_stall_stream_open_locked.
> >
> > > +	mutex_unlock(&gt->eu_stall->stream_lock);
> > > +
> > > +	/* Release the reference the EU stall stream kept on the driver */
> > > +	drm_dev_put(&gt->tile->xe->drm);
> > > +
> > >	return 0;
> > >  }
> > >
> > > @@ -230,7 +519,67 @@ static const struct file_operations fops_eu_stall = {
> > >
> > >  static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
> > >  {
> > > -	return false;
> > > +	return ((xe->info.platform == XE_PVC) ? true : false);
> >
> > return xe->info.platform == XE_PVC;
> A subsequent patch adds another check for xe2. So, I used the
> conditional operator.

You don't need the conditional operator there either. So conditional
operator needs to go.

> >
> > > +}
> > > +
> > > +/**
> > > + * xe_eu_stall_stream_open_locked - Open a EU stall data stream FD.
> > > + * @dev: drm device instance
> > > + * @props: individually validated u64 property value pairs
> > > + * @file: drm file
> > > + *
> > > + * Returns: zero on success or a negative error code.
> > > + */
> > > +static int
> > > +xe_eu_stall_stream_open_locked(struct drm_device *dev,
> > > +			       struct eu_stall_open_properties *props,
> > > +			       struct drm_file *file)
> > > +{
> > > +	struct xe_eu_stall_data_stream *stream;
> > > +	struct xe_gt *gt = props->gt;
> > > +	unsigned long f_flags = 0;
> > > +	int ret, stream_fd;
> > > +
> > > +	/* Only one session can be active at any time */
> > > +	if (gt->eu_stall->stream) {
> > > +		xe_gt_dbg(gt, "EU stall sampling session already active\n");
> > > +		return -EBUSY;
> > > +	}
> > > +
> > > +	stream = kzalloc(sizeof(*stream), GFP_KERNEL);
> > > +	if (!stream)
> > > +		return -ENOMEM;
> > > +
> > > +	gt->eu_stall->stream = stream;
> > > +	stream->gt = gt;
> > > +
> > > +	ret = xe_eu_stall_stream_init(stream, props);
> > > +	if (ret) {
> > > +		xe_gt_dbg(gt, "EU stall stream init failed : %d\n", ret);
> > > +		goto err_alloc;
> >
> > This is wrong as pointed below. If this fails we jump to 'kfree(stream)'.
> When I wrote this code initially, I may have tried to reduce the goto
> labels considering the fact that kfree() checks if the input ptr is NULL
> and returns if so.
> >
> > Also don't invent random label names. See
> > xe_oa_stream_open_ioctl_locked(): err_destroy is for destroy, err_free for
> > free etc.
> >
> > So this should be goto err_free.
> Will change it. I have seen code where the label is named err_alloc to
> undo an alloc. I think each developer names the labels differently.
> >
> > > +	}
> > > +
> > > +	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, stream, f_flags);
> > > +	if (stream_fd < 0) {
> > > +		ret = stream_fd;
> > > +		xe_gt_dbg(gt, "EU stall inode get fd failed : %d\n", ret);
> > > +		goto err_open;
> >
> > goto err_destroy. see below.
> >
> > > +	}
> > > +
> > > +	/* Take a reference on the driver that will be kept with stream_fd
> > > +	 * until its release.
> > > +	 */
> > > +	drm_dev_get(&gt->tile->xe->drm);
> > > +
> > > +	return stream_fd;
> > > +
> > > +err_open:
> > > +	free_eu_stall_data_buf(stream);
> > > +err_alloc:
> > > +	gt->eu_stall->stream = NULL;
> > > +	kfree(stream->xecore_buf);
> >
> > This is wrong, stream->xecore_buf is allocated in xe_eu_stall_stream_init
> > and we are jumping here if xe_eu_stall_stream_init fails.
> I will change it. But considering the fact that kfree() has a NULL
> check, this is not a bug.

OK, but still to keep things clean, let's undo things in the correct order.

> >
> > See xe_oa_stream_open_ioctl_locked() as an example for doing this unwinding
> > correctly. We need a 'destroy' function which will free stuff allocated in
> > xe_eu_stall_stream_init. And that function should be called from
> > close/release too.
> >
> > Ideally, we should not have to peek inside these functions to see what is
> > being allocated there and then free them. The destroy function is the
> > wrapper which should do all the free's.
> >
> > Or maybe if you want to skip destroy() we can do that too, but at least the
> > code here needs to be fixed.
> >
> > > +	kfree(stream);
> >
> > err_free label before this line. Should do kfree(stream) and
> > 'gt->eu_stall->stream = NULL'.
> >
> > > +	return ret;
> >
> > So basically, without destroy(), this is something like:
> >
> >	err_destroy:
> >		kfree(stream->xecore_buf);
> >		free_eu_stall_data_buf(stream);
> >	err_free:
> >		kfree(stream);
> >		gt->eu_stall->stream = NULL;
> >		return ret;
> >
> > Not what you have above. And the code under err_destroy can go into a
> > destroy() function, but if you want we can skip that for now.
> >
> >
> > >  }
> > >
> > >  /**
> > > @@ -252,7 +601,7 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
> > >  {
> > >	struct xe_device *xe = to_xe_device(dev);
> > >	struct eu_stall_open_properties props = {};
> > > -	int ret, stream_fd;
> > > +	int ret;
> > >
> > >	if (xe_observation_paranoid && !perfmon_capable()) {
> > >		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
> > > @@ -263,6 +612,10 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
> > >		return -EPERM;
> > >	}
> > >
> > > +	/* Initialize and set default values */
> > > +	props.wait_num_reports = 1;
> > > +	props.sampling_rate_mult = 4;
> >
> > What about props.gt? Can it also be initialized to gt[0], corresponding to
> > default gt_id 0, basically default gt if not specified in uapi is gt0?
>
> I had that initially, but there was a review comment in the first few
> versions of this patch review, I think from Matt Roper that GT ID
> should be mandatory from the user space.

But why? Anyway either way is ok, so let's decide one way or another and go
with it. I think I prefer default gt_id 0 (rather than a required
parameter), but otherwise is ok too.

>
> >
> > > +
> > >	ret = xe_eu_stall_user_extensions(xe, data, &props);
> > >	if (ret)
> > >		return ret;
> > > @@ -272,9 +625,9 @@ int xe_eu_stall_stream_open(struct drm_device *dev,
> > >		return -EINVAL;
> > >	}
> > >
> > > -	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
> > > -	if (stream_fd < 0)
> > > -		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
> > > +	mutex_lock(&props.gt->eu_stall->stream_lock);
> > > +	ret = xe_eu_stall_stream_open_locked(dev, &props, file);
> > > +	mutex_unlock(&props.gt->eu_stall->stream_lock);
> > >
> > > -	return stream_fd;
> > > +	return ret;
> > >  }
> > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
> > > index d514e78341d5..e42250c1d294 100644
> > > --- a/drivers/gpu/drm/xe/xe_eu_stall.h
> > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.h
> > > @@ -6,9 +6,10 @@
> > >  #ifndef __XE_EU_STALL_H__
> > >  #define __XE_EU_STALL_H__
> > >
> > > -#include <drm/drm_device.h>
> > > -#include <drm/drm_file.h>
> > > -#include <linux/types.h>
> > > +#include "xe_gt_types.h"
> > > +
> > > +int xe_eu_stall_init(struct xe_gt *gt);
> > > +void xe_eu_stall_fini(struct xe_gt *gt);
> > >
> > >  int xe_eu_stall_stream_open(struct drm_device *dev,
> > >			    u64 data,
> > > diff --git a/drivers/gpu/drm/xe/xe_gt.c b/drivers/gpu/drm/xe/xe_gt.c
> > > index 9fb8f1e678dc..ee5a16727300 100644
> > > --- a/drivers/gpu/drm/xe/xe_gt.c
> > > +++ b/drivers/gpu/drm/xe/xe_gt.c
> > > @@ -60,6 +60,7 @@
> > >  #include "xe_vm.h"
> > >  #include "xe_wa.h"
> > >  #include "xe_wopcm.h"
> > > +#include "xe_eu_stall.h"
> > >
> > >  static void gt_fini(struct drm_device *drm, void *arg)
> > >  {
> > > @@ -159,6 +160,7 @@ void xe_gt_remove(struct xe_gt *gt)
> > >		xe_hw_fence_irq_finish(&gt->fence_irq[i]);
> > >
> > >	xe_gt_disable_host_l2_vram(gt);
> > > +	xe_eu_stall_fini(gt);
> >
> > Maybe move to the top of the function, so that fini happens in reverse
> > order to init?
> Okay.
> >
> > >  }
> > >
> > >  static void gt_reset_worker(struct work_struct *w);
> > > @@ -625,6 +627,10 @@ int xe_gt_init(struct xe_gt *gt)
> > >
> > >	xe_gt_record_user_engines(gt);
> > >
> > > +	err = xe_eu_stall_init(gt);
> > > +	if (err)
> > > +		return err;
> > > +
> > >	return 0;
> > >  }
> > >
> > > diff --git a/drivers/gpu/drm/xe/xe_gt_types.h b/drivers/gpu/drm/xe/xe_gt_types.h
> > > index 6e66bf0e8b3f..833a1a67e9ae 100644
> > > --- a/drivers/gpu/drm/xe/xe_gt_types.h
> > > +++ b/drivers/gpu/drm/xe/xe_gt_types.h
> > > @@ -430,6 +430,9 @@ struct xe_gt {
> > >
> > >	/** @oa: oa observation subsystem per gt info */
> > >	struct xe_oa_gt oa;
> > > +
> > > +	/** @eu_stall: EU stall counters subsystem per gt info */
> > > +	struct xe_eu_stall_gt *eu_stall;
> >
> > This needs a forward declaration for 'struct xe_eu_stall_gt'.
>
> I thought so initially, but the compiler didn't complain. I guess because
> eu_stall is a pointer and not an instance of struct xe_eu_stall_gt ?

I thought forward declarations are used for pointers (you can't have
forward declarations if you have real structs, rather than pointer to
struct). So we need that I think.

> >
> > >  };
> > >
> > >  #endif
> > > --
> > > 2.48.1
> > >
>
> Thank You
> Harish.

✗ Xe.CI.Full: failure for Add support for EU stall sampling

[Patchwork]

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

== Series Details ==

Series: Add support for EU stall sampling
URL   : https://patchwork.freedesktop.org/series/144609/
State : failure

== Summary ==

CI Bug Log - changes from xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237_full -> xe-pw-144609v1_full
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with xe-pw-144609v1_full absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in xe-pw-144609v1_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 (4 -> 4)
------------------------------

  No changes in participating hosts

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

  Here are the unknown changes that may have been introduced in xe-pw-144609v1_full:

### IGT changes ###

#### Possible regressions ####

  * igt@kms_color@deep-color:
    - shard-bmg:          [PASS][1] -> [INCOMPLETE][2]
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-6/igt@kms_color@deep-color.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-1/igt@kms_color@deep-color.html

  * igt@kms_color@deep-color@pipe-d-dp-2-ctm:
    - shard-bmg:          NOTRUN -> [INCOMPLETE][3]
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-1/igt@kms_color@deep-color@pipe-d-dp-2-ctm.html

  
New tests
---------

  New tests have been introduced between xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237_full and xe-pw-144609v1_full:

### New IGT tests (2) ###

  * igt@kms_cursor_edge_walk@64x64-top-bottom@pipe-a-hdmi-a-1:
    - Statuses : 1 pass(s)
    - Exec time: [3.25] s

  * igt@kms_cursor_edge_walk@64x64-top-bottom@pipe-d-hdmi-a-1:
    - Statuses : 1 pass(s)
    - Exec time: [3.19] s

  

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

  Here are the changes found in xe-pw-144609v1_full that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@kms_big_fb@x-tiled-max-hw-stride-64bpp-rotate-180-hflip-async-flip:
    - shard-adlp:         [PASS][4] -> [DMESG-FAIL][5] ([Intel XE#1033])
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@kms_big_fb@x-tiled-max-hw-stride-64bpp-rotate-180-hflip-async-flip.html
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-3/igt@kms_big_fb@x-tiled-max-hw-stride-64bpp-rotate-180-hflip-async-flip.html

  * igt@kms_bw@connected-linear-tiling-2-displays-1920x1080p:
    - shard-bmg:          [PASS][6] -> [SKIP][7] ([Intel XE#2314] / [Intel XE#2894])
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-8/igt@kms_bw@connected-linear-tiling-2-displays-1920x1080p.html
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-6/igt@kms_bw@connected-linear-tiling-2-displays-1920x1080p.html
    - shard-dg2-set2:     [PASS][8] -> [SKIP][9] ([Intel XE#2191])
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-466/igt@kms_bw@connected-linear-tiling-2-displays-1920x1080p.html
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_bw@connected-linear-tiling-2-displays-1920x1080p.html

  * igt@kms_ccs@crc-sprite-planes-basic-y-tiled-gen12-rc-ccs@pipe-d-dp-4:
    - shard-dg2-set2:     NOTRUN -> [SKIP][10] ([Intel XE#455] / [Intel XE#787]) +12 other tests skip
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_ccs@crc-sprite-planes-basic-y-tiled-gen12-rc-ccs@pipe-d-dp-4.html

  * igt@kms_ccs@missing-ccs-buffer-yf-tiled-ccs@pipe-b-dp-4:
    - shard-dg2-set2:     NOTRUN -> [SKIP][11] ([Intel XE#787]) +38 other tests skip
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_ccs@missing-ccs-buffer-yf-tiled-ccs@pipe-b-dp-4.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-d-dp-4:
    - shard-dg2-set2:     NOTRUN -> [INCOMPLETE][12] ([Intel XE#4010])
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-436/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-d-dp-4.html

  * igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs@pipe-d-hdmi-a-3:
    - shard-bmg:          NOTRUN -> [SKIP][13] ([Intel XE#2652] / [Intel XE#787]) +11 other tests skip
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-6/igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs@pipe-d-hdmi-a-3.html

  * igt@kms_cdclk@plane-scaling@pipe-b-dp-4:
    - shard-dg2-set2:     NOTRUN -> [SKIP][14] ([Intel XE#1152]) +3 other tests skip
   [14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_cdclk@plane-scaling@pipe-b-dp-4.html

  * igt@kms_cursor_crc@cursor-suspend:
    - shard-bmg:          [PASS][15] -> [DMESG-WARN][16] ([Intel XE#4172]) +14 other tests dmesg-warn
   [15]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-6/igt@kms_cursor_crc@cursor-suspend.html
   [16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-1/igt@kms_cursor_crc@cursor-suspend.html

  * igt@kms_cursor_crc@cursor-suspend@pipe-a-hdmi-a-1:
    - shard-adlp:         [PASS][17] -> [DMESG-WARN][18] ([Intel XE#4173]) +2 other tests dmesg-warn
   [17]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-9/igt@kms_cursor_crc@cursor-suspend@pipe-a-hdmi-a-1.html
   [18]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-6/igt@kms_cursor_crc@cursor-suspend@pipe-a-hdmi-a-1.html

  * igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic:
    - shard-bmg:          [PASS][19] -> [SKIP][20] ([Intel XE#2291]) +3 other tests skip
   [19]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-1/igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic.html
   [20]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-4/igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic.html

  * igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size:
    - shard-dg2-set2:     [PASS][21] -> [SKIP][22] ([Intel XE#309]) +7 other tests skip
   [21]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-435/igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size.html
   [22]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size.html

  * igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@ad-hdmi-a6-dp4:
    - shard-dg2-set2:     NOTRUN -> [FAIL][23] ([Intel XE#301])
   [23]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@ad-hdmi-a6-dp4.html

  * igt@kms_flip@2x-flip-vs-expired-vblank@cd-hdmi-a6-dp4:
    - shard-dg2-set2:     [PASS][24] -> [FAIL][25] ([Intel XE#301])
   [24]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-435/igt@kms_flip@2x-flip-vs-expired-vblank@cd-hdmi-a6-dp4.html
   [25]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_flip@2x-flip-vs-expired-vblank@cd-hdmi-a6-dp4.html

  * igt@kms_flip@2x-flip-vs-suspend-interruptible@cd-dp2-hdmi-a3:
    - shard-bmg:          NOTRUN -> [DMESG-WARN][26] ([Intel XE#4172]) +2 other tests dmesg-warn
   [26]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-5/igt@kms_flip@2x-flip-vs-suspend-interruptible@cd-dp2-hdmi-a3.html

  * igt@kms_flip@2x-flip-vs-wf_vblank-interruptible@cd-hdmi-a6-dp4:
    - shard-dg2-set2:     NOTRUN -> [DMESG-WARN][27] ([Intel XE#1033]) +5 other tests dmesg-warn
   [27]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_flip@2x-flip-vs-wf_vblank-interruptible@cd-hdmi-a6-dp4.html

  * igt@kms_flip@2x-plain-flip-fb-recreate:
    - shard-bmg:          [PASS][28] -> [SKIP][29] ([Intel XE#2316]) +8 other tests skip
   [28]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-2/igt@kms_flip@2x-plain-flip-fb-recreate.html
   [29]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-6/igt@kms_flip@2x-plain-flip-fb-recreate.html

  * igt@kms_flip@2x-plain-flip-ts-check-interruptible:
    - shard-dg2-set2:     [PASS][30] -> [SKIP][31] ([Intel XE#310]) +4 other tests skip
   [30]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-435/igt@kms_flip@2x-plain-flip-ts-check-interruptible.html
   [31]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_flip@2x-plain-flip-ts-check-interruptible.html

  * igt@kms_flip@flip-vs-expired-vblank:
    - shard-bmg:          [PASS][32] -> [FAIL][33] ([Intel XE#3321]) +1 other test fail
   [32]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-6/igt@kms_flip@flip-vs-expired-vblank.html
   [33]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-4/igt@kms_flip@flip-vs-expired-vblank.html

  * igt@kms_flip@flip-vs-expired-vblank@d-dp2:
    - shard-bmg:          NOTRUN -> [FAIL][34] ([Intel XE#3321]) +3 other tests fail
   [34]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-4/igt@kms_flip@flip-vs-expired-vblank@d-dp2.html

  * igt@kms_flip@plain-flip-ts-check-interruptible@a-hdmi-a1:
    - shard-adlp:         [PASS][35] -> [FAIL][36] ([Intel XE#2882]) +1 other test fail
   [35]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@kms_flip@plain-flip-ts-check-interruptible@a-hdmi-a1.html
   [36]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-3/igt@kms_flip@plain-flip-ts-check-interruptible@a-hdmi-a1.html

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-indfb-pgflip-blt:
    - shard-dg2-set2:     [PASS][37] -> [DMESG-WARN][38] ([Intel XE#1033]) +1 other test dmesg-warn
   [37]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-indfb-pgflip-blt.html
   [38]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-indfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-render:
    - shard-dg2-set2:     [PASS][39] -> [SKIP][40] ([Intel XE#656]) +4 other tests skip
   [39]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-435/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-render.html
   [40]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-render.html

  * igt@kms_plane_scaling@intel-max-src-size@pipe-a-dp-4:
    - shard-dg2-set2:     NOTRUN -> [DMESG-WARN][41] ([Intel XE#4212])
   [41]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_plane_scaling@intel-max-src-size@pipe-a-dp-4.html

  * igt@kms_pm_rpm@modeset-non-lpsp:
    - shard-dg2-set2:     [PASS][42] -> [SKIP][43] ([Intel XE#836])
   [42]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-466/igt@kms_pm_rpm@modeset-non-lpsp.html
   [43]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_pm_rpm@modeset-non-lpsp.html

  * igt@kms_setmode@clone-exclusive-crtc:
    - shard-bmg:          [PASS][44] -> [SKIP][45] ([Intel XE#1435])
   [44]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-1/igt@kms_setmode@clone-exclusive-crtc.html
   [45]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-4/igt@kms_setmode@clone-exclusive-crtc.html
    - shard-dg2-set2:     [PASS][46] -> [SKIP][47] ([Intel XE#455])
   [46]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-435/igt@kms_setmode@clone-exclusive-crtc.html
   [47]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_setmode@clone-exclusive-crtc.html

  * igt@xe_live_ktest@xe_bo@xe_ccs_migrate_kunit:
    - shard-bmg:          NOTRUN -> [SKIP][48] ([Intel XE#2229])
   [48]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-4/igt@xe_live_ktest@xe_bo@xe_ccs_migrate_kunit.html

  * igt@xe_live_ktest@xe_mocs:
    - shard-bmg:          [PASS][49] -> [SKIP][50] ([Intel XE#1192]) +1 other test skip
   [49]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-7/igt@xe_live_ktest@xe_mocs.html
   [50]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-2/igt@xe_live_ktest@xe_mocs.html

  * igt@xe_pm@s3-vm-bind-prefetch:
    - shard-bmg:          [PASS][51] -> [DMESG-WARN][52] ([Intel XE#4172] / [Intel XE#569])
   [51]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-6/igt@xe_pm@s3-vm-bind-prefetch.html
   [52]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-1/igt@xe_pm@s3-vm-bind-prefetch.html

  
#### Possible fixes ####

  * igt@kms_bw@connected-linear-tiling-2-displays-3840x2160p:
    - shard-dg2-set2:     [SKIP][53] ([Intel XE#2191]) -> [PASS][54]
   [53]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_bw@connected-linear-tiling-2-displays-3840x2160p.html
   [54]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_bw@connected-linear-tiling-2-displays-3840x2160p.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-a-dp-4:
    - shard-dg2-set2:     [INCOMPLETE][55] ([Intel XE#1727] / [Intel XE#3113] / [Intel XE#3124] / [Intel XE#4010]) -> [PASS][56]
   [55]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-466/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-a-dp-4.html
   [56]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-436/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-a-dp-4.html

  * igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions-varying-size:
    - shard-bmg:          [SKIP][57] ([Intel XE#2291]) -> [PASS][58] +4 other tests pass
   [57]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-4/igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions-varying-size.html
   [58]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-5/igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions-varying-size.html

  * igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions:
    - shard-dg2-set2:     [SKIP][59] ([Intel XE#309]) -> [PASS][60] +2 other tests pass
   [59]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions.html
   [60]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_cursor_legacy@cursorb-vs-flipa-atomic-transitions.html

  * igt@kms_display_modes@extended-mode-basic:
    - shard-dg2-set2:     [SKIP][61] ([Intel XE#455]) -> [PASS][62]
   [61]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_display_modes@extended-mode-basic.html
   [62]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_display_modes@extended-mode-basic.html

  * igt@kms_dither@fb-8bpc-vs-panel-6bpc:
    - shard-bmg:          [SKIP][63] ([Intel XE#1340]) -> [PASS][64]
   [63]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-6/igt@kms_dither@fb-8bpc-vs-panel-6bpc.html
   [64]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-4/igt@kms_dither@fb-8bpc-vs-panel-6bpc.html

  * igt@kms_dp_aux_dev:
    - shard-dg2-set2:     [SKIP][65] ([Intel XE#3009]) -> [PASS][66]
   [65]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_dp_aux_dev.html
   [66]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_dp_aux_dev.html

  * igt@kms_flip@2x-flip-vs-dpms:
    - shard-bmg:          [SKIP][67] ([Intel XE#2316]) -> [PASS][68] +3 other tests pass
   [67]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-4/igt@kms_flip@2x-flip-vs-dpms.html
   [68]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-5/igt@kms_flip@2x-flip-vs-dpms.html

  * igt@kms_flip@2x-flip-vs-expired-vblank@ab-dp2-hdmi-a3:
    - shard-bmg:          [FAIL][69] ([Intel XE#3321]) -> [PASS][70] +1 other test pass
   [69]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-1/igt@kms_flip@2x-flip-vs-expired-vblank@ab-dp2-hdmi-a3.html
   [70]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-8/igt@kms_flip@2x-flip-vs-expired-vblank@ab-dp2-hdmi-a3.html

  * igt@kms_flip@2x-flip-vs-expired-vblank@bd-hdmi-a6-dp4:
    - shard-dg2-set2:     [FAIL][71] ([Intel XE#301]) -> [PASS][72]
   [71]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-435/igt@kms_flip@2x-flip-vs-expired-vblank@bd-hdmi-a6-dp4.html
   [72]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_flip@2x-flip-vs-expired-vblank@bd-hdmi-a6-dp4.html

  * igt@kms_flip@2x-plain-flip-fb-recreate:
    - shard-dg2-set2:     [SKIP][73] ([Intel XE#310]) -> [PASS][74] +3 other tests pass
   [73]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_flip@2x-plain-flip-fb-recreate.html
   [74]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_flip@2x-plain-flip-fb-recreate.html

  * igt@kms_flip@wf_vblank-ts-check-interruptible@d-hdmi-a6:
    - shard-dg2-set2:     [DMESG-WARN][75] ([Intel XE#1033]) -> [PASS][76] +9 other tests pass
   [75]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_flip@wf_vblank-ts-check-interruptible@d-hdmi-a6.html
   [76]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_flip@wf_vblank-ts-check-interruptible@d-hdmi-a6.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc:
    - shard-dg2-set2:     [SKIP][77] ([Intel XE#656]) -> [PASS][78] +3 other tests pass
   [77]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc.html
   [78]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc.html

  * igt@kms_joiner@basic-force-big-joiner:
    - shard-bmg:          [SKIP][79] ([Intel XE#3012]) -> [PASS][80]
   [79]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-6/igt@kms_joiner@basic-force-big-joiner.html
   [80]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-1/igt@kms_joiner@basic-force-big-joiner.html

  * igt@kms_joiner@invalid-modeset-force-big-joiner:
    - shard-dg2-set2:     [SKIP][81] -> [PASS][82]
   [81]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_joiner@invalid-modeset-force-big-joiner.html
   [82]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_joiner@invalid-modeset-force-big-joiner.html

  * igt@kms_setmode@invalid-clone-single-crtc-stealing:
    - shard-bmg:          [SKIP][83] ([Intel XE#1435]) -> [PASS][84]
   [83]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-4/igt@kms_setmode@invalid-clone-single-crtc-stealing.html
   [84]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-5/igt@kms_setmode@invalid-clone-single-crtc-stealing.html

  * igt@kms_universal_plane@cursor-fb-leak@pipe-c-edp-1:
    - shard-lnl:          [FAIL][85] ([Intel XE#899]) -> [PASS][86]
   [85]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-lnl-5/igt@kms_universal_plane@cursor-fb-leak@pipe-c-edp-1.html
   [86]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-lnl-6/igt@kms_universal_plane@cursor-fb-leak@pipe-c-edp-1.html

  * igt@kms_vblank@ts-continuation-suspend:
    - shard-adlp:         [DMESG-WARN][87] ([Intel XE#2953]) -> [PASS][88] +1 other test pass
   [87]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-6/igt@kms_vblank@ts-continuation-suspend.html
   [88]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-9/igt@kms_vblank@ts-continuation-suspend.html

  * igt@xe_compute_preempt@compute-preempt-many@engine-drm_xe_engine_class_compute:
    - shard-lnl:          [FAIL][89] ([Intel XE#4278]) -> [PASS][90] +1 other test pass
   [89]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-lnl-3/igt@xe_compute_preempt@compute-preempt-many@engine-drm_xe_engine_class_compute.html
   [90]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-lnl-7/igt@xe_compute_preempt@compute-preempt-many@engine-drm_xe_engine_class_compute.html

  * igt@xe_exec_basic@many-execqueues-bindexecqueue-userptr-rebind:
    - shard-bmg:          [DMESG-WARN][91] ([Intel XE#4172]) -> [PASS][92] +2 other tests pass
   [91]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-2/igt@xe_exec_basic@many-execqueues-bindexecqueue-userptr-rebind.html
   [92]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-6/igt@xe_exec_basic@many-execqueues-bindexecqueue-userptr-rebind.html

  * igt@xe_exec_threads@threads-hang-rebind:
    - shard-dg2-set2:     [DMESG-WARN][93] ([Intel XE#3876]) -> [PASS][94]
   [93]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@xe_exec_threads@threads-hang-rebind.html
   [94]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@xe_exec_threads@threads-hang-rebind.html

  * igt@xe_fault_injection@inject-fault-probe-function-xe_wa_init:
    - shard-adlp:         [DMESG-WARN][95] ([Intel XE#4173]) -> [PASS][96]
   [95]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@xe_fault_injection@inject-fault-probe-function-xe_wa_init.html
   [96]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-6/igt@xe_fault_injection@inject-fault-probe-function-xe_wa_init.html

  * igt@xe_live_ktest@xe_bo:
    - shard-bmg:          [SKIP][97] ([Intel XE#1192]) -> [PASS][98]
   [97]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-6/igt@xe_live_ktest@xe_bo.html
   [98]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-4/igt@xe_live_ktest@xe_bo.html

  
#### Warnings ####

  * igt@kms_ccs@bad-rotation-90-y-tiled-gen12-mc-ccs@pipe-d-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][99] ([Intel XE#455] / [Intel XE#787]) -> [SKIP][100] ([Intel XE#787]) +12 other tests skip
   [99]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_ccs@bad-rotation-90-y-tiled-gen12-mc-ccs@pipe-d-hdmi-a-6.html
   [100]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_ccs@bad-rotation-90-y-tiled-gen12-mc-ccs@pipe-d-hdmi-a-6.html

  * igt@kms_ccs@missing-ccs-buffer-y-tiled-gen12-rc-ccs@pipe-d-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][101] ([Intel XE#787]) -> [SKIP][102] ([Intel XE#455] / [Intel XE#787]) +7 other tests skip
   [101]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-466/igt@kms_ccs@missing-ccs-buffer-y-tiled-gen12-rc-ccs@pipe-d-hdmi-a-6.html
   [102]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_ccs@missing-ccs-buffer-y-tiled-gen12-rc-ccs@pipe-d-hdmi-a-6.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs:
    - shard-dg2-set2:     [INCOMPLETE][103] ([Intel XE#1727] / [Intel XE#3124] / [Intel XE#4010]) -> [INCOMPLETE][104] ([Intel XE#4010])
   [103]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-466/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs.html
   [104]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-436/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs.html

  * igt@kms_content_protection@legacy:
    - shard-bmg:          [FAIL][105] ([Intel XE#1178]) -> [SKIP][106] ([Intel XE#2341])
   [105]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-4/igt@kms_content_protection@legacy.html
   [106]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-6/igt@kms_content_protection@legacy.html

  * igt@kms_cursor_legacy@cursorb-vs-flipa-legacy:
    - shard-dg2-set2:     [SKIP][107] ([Intel XE#309]) -> [DMESG-WARN][108] ([Intel XE#1033]) +1 other test dmesg-warn
   [107]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_cursor_legacy@cursorb-vs-flipa-legacy.html
   [108]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_cursor_legacy@cursorb-vs-flipa-legacy.html

  * igt@kms_flip@2x-flip-vs-expired-vblank-interruptible:
    - shard-bmg:          [SKIP][109] ([Intel XE#2316]) -> [FAIL][110] ([Intel XE#3321])
   [109]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-4/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible.html
   [110]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-5/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible.html
    - shard-dg2-set2:     [SKIP][111] ([Intel XE#310]) -> [FAIL][112] ([Intel XE#301])
   [111]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible.html
   [112]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible.html

  * igt@kms_flip@2x-flip-vs-suspend-interruptible:
    - shard-bmg:          [SKIP][113] ([Intel XE#2316]) -> [DMESG-WARN][114] ([Intel XE#4172])
   [113]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-4/igt@kms_flip@2x-flip-vs-suspend-interruptible.html
   [114]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-5/igt@kms_flip@2x-flip-vs-suspend-interruptible.html

  * igt@kms_flip@2x-flip-vs-wf_vblank-interruptible:
    - shard-dg2-set2:     [SKIP][115] ([Intel XE#310]) -> [DMESG-WARN][116] ([Intel XE#1033])
   [115]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_flip@2x-flip-vs-wf_vblank-interruptible.html
   [116]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_flip@2x-flip-vs-wf_vblank-interruptible.html

  * igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff:
    - shard-dg2-set2:     [SKIP][117] ([Intel XE#656]) -> [SKIP][118] ([Intel XE#651]) +16 other tests skip
   [117]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff.html
   [118]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-spr-indfb-fullscreen:
    - shard-dg2-set2:     [SKIP][119] ([Intel XE#651]) -> [SKIP][120] ([Intel XE#656]) +12 other tests skip
   [119]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-466/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-spr-indfb-fullscreen.html
   [120]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-spr-indfb-fullscreen.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-render:
    - shard-bmg:          [SKIP][121] ([Intel XE#4141]) -> [SKIP][122] ([Intel XE#2312]) +5 other tests skip
   [121]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-7/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-render.html
   [122]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-4/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-shrfb-msflip-blt:
    - shard-dg2-set2:     [SKIP][123] ([Intel XE#656]) -> [DMESG-WARN][124] ([Intel XE#1033]) +1 other test dmesg-warn
   [123]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-shrfb-msflip-blt.html
   [124]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-shrfb-msflip-blt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render:
    - shard-bmg:          [SKIP][125] ([Intel XE#2312]) -> [SKIP][126] ([Intel XE#4141]) +7 other tests skip
   [125]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-6/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render.html
   [126]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-1/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-cur-indfb-move:
    - shard-bmg:          [SKIP][127] ([Intel XE#2311]) -> [SKIP][128] ([Intel XE#2312]) +15 other tests skip
   [127]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-8/igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-cur-indfb-move.html
   [128]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-6/igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-cur-indfb-move.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-indfb-plflip-blt:
    - shard-bmg:          [SKIP][129] ([Intel XE#2312]) -> [SKIP][130] ([Intel XE#2311]) +12 other tests skip
   [129]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-indfb-plflip-blt.html
   [130]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-1/igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-indfb-plflip-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-cur-indfb-onoff:
    - shard-dg2-set2:     [SKIP][131] ([Intel XE#653]) -> [SKIP][132] ([Intel XE#656]) +17 other tests skip
   [131]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-466/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-cur-indfb-onoff.html
   [132]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-464/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-cur-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-onoff:
    - shard-bmg:          [SKIP][133] ([Intel XE#2312]) -> [SKIP][134] ([Intel XE#2313]) +15 other tests skip
   [133]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-onoff.html
   [134]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-5/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-cur-indfb-onoff:
    - shard-bmg:          [SKIP][135] ([Intel XE#2313]) -> [SKIP][136] ([Intel XE#2312]) +20 other tests skip
   [135]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-1/igt@kms_frontbuffer_tracking@psr-2p-primscrn-cur-indfb-onoff.html
   [136]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-6/igt@kms_frontbuffer_tracking@psr-2p-primscrn-cur-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-blt:
    - shard-dg2-set2:     [SKIP][137] ([Intel XE#656]) -> [SKIP][138] ([Intel XE#653]) +13 other tests skip
   [137]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-blt.html
   [138]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-435/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-blt.html

  * igt@kms_hdr@brightness-with-hdr:
    - shard-bmg:          [SKIP][139] ([Intel XE#3374] / [Intel XE#3544]) -> [SKIP][140] ([Intel XE#3544])
   [139]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-bmg-8/igt@kms_hdr@brightness-with-hdr.html
   [140]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-bmg-6/igt@kms_hdr@brightness-with-hdr.html

  * igt@kms_plane_scaling@intel-max-src-size:
    - shard-dg2-set2:     [DMESG-WARN][141] ([Intel XE#2705] / [Intel XE#4212]) -> [DMESG-WARN][142] ([Intel XE#4212])
   [141]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-dg2-464/igt@kms_plane_scaling@intel-max-src-size.html
   [142]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-dg2-466/igt@kms_plane_scaling@intel-max-src-size.html

  * igt@xe_module_load@load:
    - shard-adlp:         ([PASS][143], [PASS][144], [PASS][145], [PASS][146], [PASS][147], [SKIP][148], [PASS][149], [PASS][150], [PASS][151], [PASS][152], [PASS][153], [PASS][154], [PASS][155], [PASS][156], [PASS][157], [PASS][158], [PASS][159], [PASS][160], [PASS][161], [PASS][162], [PASS][163], [PASS][164], [PASS][165], [PASS][166], [PASS][167], [PASS][168]) ([Intel XE#378]) -> ([PASS][169], [PASS][170], [PASS][171], [PASS][172], [PASS][173], [PASS][174], [PASS][175], [PASS][176], [PASS][177], [PASS][178], [PASS][179], [PASS][180], [PASS][181], [PASS][182], [SKIP][183], [PASS][184], [PASS][185], [PASS][186], [PASS][187], [PASS][188], [PASS][189], [DMESG-WARN][190], [PASS][191], [PASS][192], [PASS][193], [PASS][194]) ([Intel XE#378] / [Intel XE#4173])
   [143]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-9/igt@xe_module_load@load.html
   [144]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-9/igt@xe_module_load@load.html
   [145]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-9/igt@xe_module_load@load.html
   [146]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-2/igt@xe_module_load@load.html
   [147]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-2/igt@xe_module_load@load.html
   [148]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-3/igt@xe_module_load@load.html
   [149]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-3/igt@xe_module_load@load.html
   [150]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-3/igt@xe_module_load@load.html
   [151]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-6/igt@xe_module_load@load.html
   [152]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@xe_module_load@load.html
   [153]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@xe_module_load@load.html
   [154]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-3/igt@xe_module_load@load.html
   [155]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-3/igt@xe_module_load@load.html
   [156]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@xe_module_load@load.html
   [157]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@xe_module_load@load.html
   [158]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@xe_module_load@load.html
   [159]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-6/igt@xe_module_load@load.html
   [160]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-6/igt@xe_module_load@load.html
   [161]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-6/igt@xe_module_load@load.html
   [162]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@xe_module_load@load.html
   [163]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-8/igt@xe_module_load@load.html
   [164]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-6/igt@xe_module_load@load.html
   [165]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-2/igt@xe_module_load@load.html
   [166]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-2/igt@xe_module_load@load.html
   [167]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-9/igt@xe_module_load@load.html
   [168]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237/shard-adlp-3/igt@xe_module_load@load.html
   [169]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-2/igt@xe_module_load@load.html
   [170]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-2/igt@xe_module_load@load.html
   [171]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-2/igt@xe_module_load@load.html
   [172]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-2/igt@xe_module_load@load.html
   [173]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-3/igt@xe_module_load@load.html
   [174]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-6/igt@xe_module_load@load.html
   [175]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-3/igt@xe_module_load@load.html
   [176]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-8/igt@xe_module_load@load.html
   [177]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-2/igt@xe_module_load@load.html
   [178]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-6/igt@xe_module_load@load.html
   [179]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-8/igt@xe_module_load@load.html
   [180]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-6/igt@xe_module_load@load.html
   [181]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-6/igt@xe_module_load@load.html
   [182]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-6/igt@xe_module_load@load.html
   [183]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-8/igt@xe_module_load@load.html
   [184]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-9/igt@xe_module_load@load.html
   [185]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-8/igt@xe_module_load@load.html
   [186]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-8/igt@xe_module_load@load.html
   [187]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-3/igt@xe_module_load@load.html
   [188]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-3/igt@xe_module_load@load.html
   [189]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-8/igt@xe_module_load@load.html
   [190]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-8/igt@xe_module_load@load.html
   [191]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-8/igt@xe_module_load@load.html
   [192]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-9/igt@xe_module_load@load.html
   [193]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-3/igt@xe_module_load@load.html
   [194]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-144609v1/shard-adlp-6/igt@xe_module_load@load.html

  
  [Intel XE#1033]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1033
  [Intel XE#1152]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1152
  [Intel XE#1178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1178
  [Intel XE#1192]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1192
  [Intel XE#1340]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1340
  [Intel XE#1435]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1435
  [Intel XE#1727]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1727
  [Intel XE#2191]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2191
  [Intel XE#2229]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2229
  [Intel XE#2291]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2291
  [Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
  [Intel XE#2312]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2312
  [Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
  [Intel XE#2314]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2314
  [Intel XE#2316]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2316
  [Intel XE#2341]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2341
  [Intel XE#2652]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2652
  [Intel XE#2705]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2705
  [Intel XE#2882]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2882
  [Intel XE#2894]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2894
  [Intel XE#2953]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2953
  [Intel XE#3009]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3009
  [Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
  [Intel XE#3012]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3012
  [Intel XE#309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/309
  [Intel XE#310]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/310
  [Intel XE#3113]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3113
  [Intel XE#3124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3124
  [Intel XE#3321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3321
  [Intel XE#3374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3374
  [Intel XE#3544]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3544
  [Intel XE#378]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/378
  [Intel XE#3876]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3876
  [Intel XE#4010]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4010
  [Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141
  [Intel XE#4172]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4172
  [Intel XE#4173]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4173
  [Intel XE#4212]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4212
  [Intel XE#4278]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4278
  [Intel XE#455]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/455
  [Intel XE#569]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/569
  [Intel XE#651]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/651
  [Intel XE#653]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/653
  [Intel XE#656]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/656
  [Intel XE#787]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/787
  [Intel XE#836]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/836
  [Intel XE#899]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/899


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

  * Linux: xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237 -> xe-pw-144609v1

  IGT_8227: 8227
  xe-2629-656e731586e568a8633c0bd16d28dcec8d67f237: 656e731586e568a8633c0bd16d28dcec8d67f237
  xe-pw-144609v1: 144609v1

== Logs ==

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

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

Re: [PATCH v9 4/8] drm/xe/eustall: Add support to read() and poll() EU stall data

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:45 -0800, Harish Chegondi wrote:
>

Hi Harish,

> Implement the EU stall sampling APIs to read() and poll() EU stall data.
> A work function periodically polls the EU stall data buffer write pointer
> registers to look for any new data and caches the write pointer. The read
> function compares the cached read and write pointers and copies any new
> data to the user space.
>
> v9:  New patch split from the previous patch.
>      Used *_delayed_work functions instead of hrtimer
>      Addressed the review feedback in read and poll functions
>
> Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> ---
>  drivers/gpu/drm/xe/xe_eu_stall.c | 267 ++++++++++++++++++++++++++++++-
>  drivers/gpu/drm/xe/xe_trace.h    |  33 ++++
>  2 files changed, 298 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> index 12afa9720971..53f17aac7d3b 100644
> --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> @@ -21,6 +21,7 @@
>  #include "xe_macros.h"
>  #include "xe_observation.h"
>  #include "xe_pm.h"
> +#include "xe_trace.h"
>
>  #include "regs/xe_eu_stall_regs.h"
>  #include "regs/xe_gt_regs.h"
> @@ -41,7 +42,9 @@ struct per_xecore_buf {
>  };
>
>  struct xe_eu_stall_data_stream {
> +	bool pollin;
>	bool enabled;
> +	wait_queue_head_t poll_wq;
>	size_t data_record_size;
>	size_t per_xecore_buf_size;
>	unsigned int wait_num_reports;
> @@ -50,6 +53,8 @@ struct xe_eu_stall_data_stream {
>	struct xe_gt *gt;
>	struct xe_bo *bo;
>	struct per_xecore_buf *xecore_buf;
> +	struct delayed_work buf_poll_work;
> +	struct workqueue_struct *buf_poll_wq;
>  };
>
>  struct xe_eu_stall_gt {
> @@ -256,6 +261,190 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
>	return 0;
>  }
>
> +/**
> + * buf_data_size - Calculate the number of bytes in a circular buffer
> + *		   given the read and write pointers and the size of
> + *		   the buffer.
> + *
> + * @buf_size: Size of the circular buffer
> + * @read_ptr: Read pointer with an additional overflow bit
> + * @write_ptr: Write pointer with an additional overflow bit
> + *
> + * Since the read and write pointers have an additional overflow bit,
> + * this function calculates the offsets from the pointers and use the
> + * offsets to calculate the data size in the buffer.
> + *
> + * Returns: number of bytes of data in the buffer
> + */
> +static u32 buf_data_size(size_t buf_size, u32 read_ptr, u32 write_ptr)
> +{
> +	u32 read_offset, write_offset, size = 0;
> +
> +	if (read_ptr == write_ptr)
> +		goto exit;
> +
> +	read_offset = read_ptr & (buf_size - 1);
> +	write_offset = write_ptr & (buf_size - 1);
> +
> +	if (write_offset > read_offset)
> +		size = write_offset - read_offset;
> +	else
> +		size = buf_size - read_offset + write_offset;
> +exit:
> +	return size;
> +}

Looks good now :)

> +
> +/**
> + * eu_stall_data_buf_poll - Poll for EU stall data in the buffer.
> + *
> + * @stream: xe EU stall data stream instance
> + *
> + * Returns: true if the EU stall buffer contains minimum stall data as
> + *	    specified by the event report count, else false.
> + */
> +static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> +{
> +	u32 read_ptr, write_ptr_reg, write_ptr, total_data = 0;
> +	u32 buf_size = stream->per_xecore_buf_size;
> +	struct per_xecore_buf *xecore_buf;
> +	struct xe_gt *gt = stream->gt;
> +	bool min_data_present = false;
> +	u16 group, instance;
> +	unsigned int xecore;

u32 and move above to u32 line?

> +
> +	for_each_dss_steering(xecore, gt, group, instance) {
> +		xecore_buf = &stream->xecore_buf[xecore];
> +		mutex_lock(&xecore_buf->ptr_lock);

One thing I am wondering about is: do we really need these per xecore_buf
locks? How about moving ptr_lock into xe_eu_stall_data_stream and just
cover for_each_dss_steering() calls with the ptr lock. Because the polling
thread runs every 10 ms, this should give plenty of time for the polling
thread and the reads to go through, even with lock contention. And it will
eliminate all these locks and the locking/unlocking overhead.

> +		read_ptr = xecore_buf->read;
> +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT,
> +						       group, instance);
> +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> +		write_ptr <<= 6;
> +		write_ptr &= ((buf_size << 1) - 1);
> +		if (write_ptr != read_ptr && !min_data_present) {

Don't need to check for 'write_ptr != read_ptr' here, it's already
happening in buf_data_size.

> +			total_data += buf_data_size(buf_size, read_ptr, write_ptr);
> +			/*
> +			 * Check if there are at least minimum number of stall data
> +			 * rows for poll() to indicate that the data is present.
> +			 * Each stall data row is 64B (cacheline size).
> +			 */

I'd say this comment is not needed and should be removed, the code below is
clear enough.

> +			if (num_data_rows(total_data) >= stream->wait_num_reports)
> +				min_data_present = true;
> +		}
> +		xecore_buf->write = write_ptr;
> +		mutex_unlock(&xecore_buf->ptr_lock);
> +	}
> +	return min_data_present;
> +}
> +
> +static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> +				     char __user *buf, size_t count,
> +				     size_t *total_data_size, struct xe_gt *gt,
> +				     u16 group, u16 instance, unsigned int xecore)
> +{
> +	size_t read_data_size, copy_size, buf_size, data_record_size;
> +	u32 read_ptr_reg, read_ptr, write_ptr;
> +	u8 *xecore_start_vaddr, *read_vaddr;
> +	struct per_xecore_buf *xecore_buf;
> +	u32 read_offset, write_offset;
> +	int ret = 0;
> +
> +	/* Hardware increments the read and write pointers such that they can
> +	 * overflow into one additional bit. For example, a 256KB size buffer
> +	 * offset pointer needs 18 bits. But HW uses 19 bits for the read and
> +	 * write pointers. This technique avoids wasting a slot in the buffer.
> +	 * Read and write offsets are calculated from the pointers in order to
> +	 * check if the write pointer has wrapped around the array.
> +	 */
> +	xecore_buf = &stream->xecore_buf[xecore];
> +	mutex_lock(&xecore_buf->ptr_lock);
> +	xecore_start_vaddr = xecore_buf->vaddr;
> +	read_ptr = xecore_buf->read;
> +	write_ptr = xecore_buf->write;
> +	buf_size = stream->per_xecore_buf_size;
> +	data_record_size = stream->data_record_size;
> +
> +	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> +	/* Read only the data that the user space buffer can accommodate */
> +	if ((*total_data_size + read_data_size) > count) {
> +		read_data_size = count - *total_data_size;
> +		read_data_size = (read_data_size / data_record_size) * data_record_size;
> +	}

As I said, my preferred way of writing this is as follows. Isn't this cleaner?

	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
	XE_WARN_ON(count >= *total_size);
	read_data_size = min_t(size_t, count - *total_size, read_data_size);
	read_data_size = ALIGN_DOWN(read_data_size, data_record_size);

Since data_record_size has to be a power of 2 for this to work (which it
is), I would even put a

	xe_assert(xe, is_power_of_2(record_size));

in xe_eu_stall_data_record_size().


> +	if (read_data_size == 0)
> +		goto exit;
> +
> +	read_offset = read_ptr & (buf_size - 1);
> +	write_offset = write_ptr & (buf_size - 1);
> +	read_vaddr = xecore_start_vaddr + read_offset;
> +
> +	if (write_offset > read_offset) {
> +		if (copy_to_user((buf + *total_data_size), read_vaddr, read_data_size)) {

internal brackets not needed     ^

> +			ret = -EFAULT;
> +			goto exit;
> +		}
> +	} else {
> +		if (read_data_size >= (buf_size - read_offset))

internal brackets not needed          ^

> +			copy_size = buf_size - read_offset;
> +		else
> +			copy_size = read_data_size;

if (write_offset < read_offset) how is this 'else' ever possible? So
shouldn't copy_size just be set unconditionally to 'buf_size -
read_offset'?

> +		if (copy_to_user((buf + *total_data_size), read_vaddr, copy_size)) {

internal brackets not needed     ^

> +			ret = -EFAULT;
> +			goto exit;
> +		}
> +		if (copy_to_user((buf + *total_data_size + copy_size),

internal brackets not needed     ^

> +				 xecore_start_vaddr, read_data_size - copy_size)) {
> +			ret = -EFAULT;
> +			goto exit;
> +		}
> +	}
> +
> +	*total_data_size += read_data_size;
> +	read_ptr += read_data_size;

Because there is an overflow bit we can just add without worrying about
wraparound?

> +
> +	/* Read pointer can overflow into one additional bit */
> +	read_ptr &= (buf_size << 1) - 1;
> +	read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, (read_ptr >> 6));
> +	read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> +	xecore_buf->read = read_ptr;
> +	trace_xe_eu_stall_data_read(group, instance, read_ptr, write_ptr,
> +				    read_offset, write_offset, *total_data_size);
> +exit:
> +	mutex_unlock(&xecore_buf->ptr_lock);
> +	return ret;
> +}
> +
> +/**
> + * xe_eu_stall_stream_read_locked - copy EU stall counters data from the
> + *				    per xecore buffers to the userspace buffer
> + * @stream: A stream opened for EU stall count metrics
> + * @file: An xe EU stall data stream file
> + * @buf: destination buffer given by userspace
> + * @count: the number of bytes userspace wants to read
> + *
> + * Returns: Number of bytes copied or a negative error code
> + * If we've successfully copied any data then reporting that takes
> + * precedence over any internal error status, so the data isn't lost.
> + */
> +static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *stream,
> +					      struct file *file, char __user *buf,
> +					      size_t count)
> +{
> +	struct xe_gt *gt = stream->gt;
> +	size_t total_size = 0;
> +	u16 group, instance;
> +	unsigned int xecore;
> +	int ret = 0;
> +
> +	for_each_dss_steering(xecore, gt, group, instance) {
> +		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> +						gt, group, instance, xecore);
> +		if (ret || count == total_size)
> +			break;
> +	}
> +	return total_size ?: (ret ?: -EAGAIN);
> +}
> +
>  /**
>   * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
>   *
> @@ -272,7 +461,35 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
>  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
>				       size_t count, loff_t *ppos)
>  {
> -	ssize_t ret = 0;
> +	struct xe_eu_stall_data_stream *stream = file->private_data;
> +	struct xe_gt *gt = stream->gt;
> +	ssize_t ret;
> +
> +	if (count == 0)
> +		return -EINVAL;

I believe we need to also handle the fact that count might not be a
multiple of record_size. The easiest way to handle this seems to be right
here:
	ssize_t aligned_count = ALIGN_DOWN(count, stream->data_record_size);

And used aligned_count rather than count in xe_eu_stall_stream_read_locked
calls. So that we don't have to worry about this in later function calls.

So above will become:

	if (aligned_count == 0)
		return -EINVAL;

Unless there is a minimum user buffer size we want to support, in that case
this becomes:

	if (aligned_count < minimum_user_buffer_size)
		return -EINVAL;

But to me looks like a good value for minimum_user_buffer_size is not
available.

Anyway, better to handle this degenerate case here itself.

> +
> +	if (!stream->enabled) {
> +		xe_gt_dbg(gt, "EU stall data stream not enabled to read\n");
> +		return -EINVAL;
> +	}
> +
> +	if (!(file->f_flags & O_NONBLOCK)) {
> +		do {
> +			ret = wait_event_interruptible(stream->poll_wq, stream->pollin);
> +			if (ret)
> +				return -EINTR;
> +
> +			mutex_lock(&gt->eu_stall->stream_lock);
> +			ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> +			mutex_unlock(&gt->eu_stall->stream_lock);
> +		} while (ret == -EAGAIN);
> +	} else {
> +		mutex_lock(&gt->eu_stall->stream_lock);
> +		ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> +		mutex_unlock(&gt->eu_stall->stream_lock);
> +	}
> +
> +	stream->pollin = false;

Carry over comment from previous rev: this breaks if user buffer is smaller
than available data. But this is a corner case so let's fix this after the
initial merge.

Let's put it a list of to be done's in the cover letter to do after we
merge in the next revision.

>
>	return ret;
>  }
> @@ -281,6 +498,7 @@ static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
>  {
>	if (stream->bo)
>		xe_bo_unpin_map_no_vm(stream->bo);
> +	destroy_workqueue(stream->buf_poll_wq);

Don't put this here in free_eu_stall_data_buf, put this in the caller of
this function, like the destroy/close function.

>  }
>
>  static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> @@ -351,6 +569,21 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
>	return 0;
>  }
>
> +static void eu_stall_data_buf_poll_work_fn(struct work_struct *work)
> +{
> +	struct xe_eu_stall_data_stream *stream =
> +		container_of(work, typeof(*stream), buf_poll_work.work);
> +
> +	if (eu_stall_data_buf_poll(stream)) {
> +		stream->pollin = true;
> +		wake_up(&stream->poll_wq);
> +	}
> +	if (stream->enabled)

See comment at xe_eu_stall_disable_locked. If we do
cancel_delayed_work_sync there, I think this stream->enabled check might
not be needed here. Also see comments at cancel_work_sync in
kernel/workqueue.c.

Could you please check and see if it works out. xe_guc_ct.c (and
xe_gt_tlb_invalidation.c) seem to be doing that.

> +		queue_delayed_work(stream->buf_poll_wq,
> +				   &stream->buf_poll_work,
> +				   msecs_to_jiffies(POLL_PERIOD_MS));
> +}
> +
>  static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
>				   struct eu_stall_open_properties *props)
>  {
> @@ -361,6 +594,11 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
>	u32 vaddr_offset;
>	int ret, xecore;
>
> +	init_waitqueue_head(&stream->poll_wq);
> +	INIT_DELAYED_WORK(&stream->buf_poll_work, eu_stall_data_buf_poll_work_fn);
> +	stream->buf_poll_wq = alloc_ordered_workqueue("xe_eu_stall", 0);
> +	if (!stream->buf_poll_wq)
> +		return -ENOMEM;

Now we also need to destroy_workqueue during error unwinding (see comments
regarding this in Patch 3).

>	stream->sampling_rate_mult = props->sampling_rate_mult;
>	stream->wait_num_reports = props->wait_num_reports;
>	stream->per_xecore_buf_size = per_xecore_buf_size;
> @@ -391,6 +629,19 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
>	return 0;
>  }
>
> +static __poll_t xe_eu_stall_stream_poll_locked(struct xe_eu_stall_data_stream *stream,
> +					       struct file *file, poll_table *wait)
> +{
> +	__poll_t events = 0;
> +
> +	poll_wait(file, &stream->poll_wq, wait);
> +
> +	if (stream->pollin)
> +		events |= EPOLLIN;
> +
> +	return events;
> +}
> +
>  /**
>   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
>   *
> @@ -401,7 +652,13 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
>   */
>  static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
>  {
> -	__poll_t ret = 0;
> +	struct xe_eu_stall_data_stream *stream = file->private_data;
> +	struct xe_gt *gt = stream->gt;
> +	__poll_t ret;
> +
> +	mutex_lock(&gt->eu_stall->stream_lock);
> +	ret = xe_eu_stall_stream_poll_locked(stream, file, wait);
> +	mutex_unlock(&gt->eu_stall->stream_lock);
>
>	return ret;
>  }
> @@ -416,6 +673,9 @@ static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
>	stream->enabled = true;
>
>	ret = xe_eu_stall_stream_enable(stream);
> +	queue_delayed_work(stream->buf_poll_wq,

A blank line before this line would be nice.

> +			   &stream->buf_poll_work,
> +			   msecs_to_jiffies(POLL_PERIOD_MS));
>	return ret;
>  }
>
> @@ -429,6 +689,9 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
>	stream->enabled = false;
>
>	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> +	/* Check for any new EU stall data one last time */
> +	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);

I am not sure if this is needed, especially if we use
cancel_delayed_work_sync.

> +	flush_delayed_work(&stream->buf_poll_work);

I think here we should use cancel_delayed_work_sync() instead. See
e.g. xe_guc_ct.c (and also maybe xe_gt_tlb_invalidation.c).

>
>	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
>	xe_pm_runtime_put(gt_to_xe(gt));
> diff --git a/drivers/gpu/drm/xe/xe_trace.h b/drivers/gpu/drm/xe/xe_trace.h
> index d5281de04d54..1cc6bfc34ccb 100644
> --- a/drivers/gpu/drm/xe/xe_trace.h
> +++ b/drivers/gpu/drm/xe/xe_trace.h
> @@ -427,6 +427,39 @@ DEFINE_EVENT(xe_pm_runtime, xe_pm_runtime_get_ioctl,
>	     TP_ARGS(xe, caller)
>  );
>
> +TRACE_EVENT(xe_eu_stall_data_read,
> +	    TP_PROTO(u8 slice, u8 subslice,
> +		     u32 read_ptr, u32 write_ptr,
> +		     u32 read_offset, u32 write_offset,
> +		     size_t total_size),
> +	    TP_ARGS(slice, subslice, read_ptr, write_ptr,
> +		    read_offset, write_offset, total_size),
> +
> +	    TP_STRUCT__entry(__field(u8, slice)
> +			     __field(u8, subslice)
> +			     __field(u32, read_ptr)
> +			     __field(u32, write_ptr)
> +			     __field(u32, read_offset)
> +			     __field(u32, write_offset)
> +			     __field(size_t, total_size)
> +			     ),
> +
> +	    TP_fast_assign(__entry->slice = slice;
> +			   __entry->subslice = subslice;
> +			   __entry->read_ptr = read_ptr;
> +			   __entry->write_ptr = write_ptr;
> +			   __entry->read_offset = read_offset;
> +			   __entry->write_offset = write_offset;
> +			   __entry->total_size = total_size;
> +			   ),
> +
> +	    TP_printk("slice:%u subslice:%u readptr:0x%x writeptr:0x%x read off:%u write off:%u size:%zu ",
> +		      __entry->slice, __entry->subslice,
> +		      __entry->read_ptr, __entry->write_ptr,
> +		      __entry->read_offset, __entry->write_offset,
> +		      __entry->total_size)
> +);
> +
>  #endif
>
>  /* This part must be outside protection */
> --
> 2.48.1
>

Re: [PATCH v9 6/8] drm/xe/eustall: Add EU stall sampling support for Xe2

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:47 -0800, Harish Chegondi wrote:
>
> Add EU stall sampling support for Xe2 architecture GPUs - LNL and BMG.
> EU stall data format for LNL and BMG is different from that of PVC.
>
> v9: Use GRAPHICS_VER() check instead of platform
>
> v8: Renamed struct drm_xe_eu_stall_data_xe2 to struct xe_eu_stall_data_xe2
>     since it is a local structure.
>
> Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> ---
>  drivers/gpu/drm/xe/xe_eu_stall.c | 51 ++++++++++++++++++++++++++++++--
>  1 file changed, 48 insertions(+), 3 deletions(-)
>
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> index 428267010805..52f8f40ba9a6 100644
> --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> @@ -113,12 +113,51 @@ struct xe_eu_stall_data_pvc {
>	__u64 unused[6];
>  } __packed;
>
> +/**
> + * struct xe_eu_stall_data_xe2 - EU stall data format for LNL, BMG
> + *			Bits		Field
> + * @ip_addr:		0  to 28	IP (addr)
> + * @tdr_count:		29 to 36	Tdr count
> + * @other_count:	37 to 44	other count
> + * @control_count:	45 to 52	control count
> + * @pipestall_count:	53 to 60	pipestall count
> + * @send_count:		61 to 68	send count
> + * @dist_acc_count:	69 to 76	dist_acc count
> + * @sbid_count:		77 to 84	sbid count
> + * @sync_count:		85 to 92	sync count
> + * @inst_fetch_count:	93 to 100	inst_fetch count
> + * @active_count:	101 to 108	Active count
> + * @ex_id:		109 to 111	Exid
> + * @end_flag:		112		EndFlag (is always 1)
> + * @unused_bits:	113 to 127	unused bits
> + * @unused:		remaining	unused bytes
> + */

Same comment about this header as for Patch 3/8.

> +struct xe_eu_stall_data_xe2 {
> +	__u64 ip_addr:29;
> +	__u64 tdr_count:8;
> +	__u64 other_count:8;
> +	__u64 control_count:8;
> +	__u64 pipestall_count:8;
> +	__u64 send_count:8;
> +	__u64 dist_acc_count:8;
> +	__u64 sbid_count:8;
> +	__u64 sync_count:8;
> +	__u64 inst_fetch_count:8;
> +	__u64 active_count:8;
> +	__u64 ex_id:3;
> +	__u64 end_flag:1;
> +	__u64 unused_bits:15;
> +	__u64 unused[6];
> +} __packed;
> +
>  static size_t xe_eu_stall_data_record_size(struct xe_device *xe)
>  {
>	unsigned long record_size = 0;
>
>	if (xe->info.platform == XE_PVC)
>		record_size = sizeof(struct xe_eu_stall_data_pvc);
> +	else if (GRAPHICS_VER(xe) >= 20)
> +		record_size = sizeof(struct xe_eu_stall_data_xe2);
>

In Patch 4/8, I am suggesting adding the following here:

	xe_assert(xe, is_power_of_2(record_size));

Even a BUILD_BUG_ON() might work, since we are dealing with sizeof.

>	return record_size;
>  }
> @@ -345,10 +384,16 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
>
>  static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
>  {
> +	struct xe_device *xe = gt_to_xe(gt);
>	u32 write_ptr_reg;
>
> -	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
> -	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
> +	/* On PVC, the overflow bit has to be cleared by writing 1 to it.
> +	 * On other GPUs, the bit has to be cleared by writing 0 to it.

s/On other GPUs/On Xe2+/

> +	 */
> +	if (GRAPHICS_VER(xe) >= 20)
> +		write_ptr_reg = _MASKED_BIT_DISABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
> +	else
> +		write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
>
>	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
>  }
> @@ -821,7 +866,7 @@ static const struct file_operations fops_eu_stall = {
>
>  static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
>  {
> -	return ((xe->info.platform == XE_PVC) ? true : false);
> +	return ((xe->info.platform == XE_PVC || GRAPHICS_VER(xe) >= 20) ? true : false);

return xe->info.platform == XE_PVC || GRAPHICS_VER(xe) >= 20;

No brackets needed. I forgot but num_data_rows() also has unneeded brackets
after 'return'.

>  }
>
>  /**
> --
> 2.48.1
>

Re: [PATCH v9 8/8] drm/xe/eustall: Add workaround 22016596838 which applies to PVC.

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:49 -0800, Harish Chegondi wrote:
>
> Add PVC workaround 22016596838 that disables EU DOP gating
> during EU stall sampling.
>
> Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> ---
>  drivers/gpu/drm/xe/xe_eu_stall.c   | 10 ++++++++++
>  drivers/gpu/drm/xe/xe_wa_oob.rules |  1 +
>  2 files changed, 11 insertions(+)
>
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> index 4dce58f60405..6acb87a25f78 100644
> --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> @@ -9,6 +9,7 @@
>  #include <linux/types.h>
>
>  #include <drm/drm_drv.h>
> +#include <generated/xe_wa_oob.h>
>  #include <uapi/drm/xe_drm.h>
>
>  #include "xe_bo.h"
> @@ -22,6 +23,7 @@
>  #include "xe_observation.h"
>  #include "xe_pm.h"
>  #include "xe_trace.h"
> +#include "xe_wa.h"
>
>  #include "regs/xe_eu_stall_regs.h"
>  #include "regs/xe_gt_regs.h"
> @@ -658,6 +660,10 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
>		return -ETIMEDOUT;
>	}
>
> +	if (XE_WA(gt, 22016596838))
> +		xe_gt_mcr_multicast_write(gt, ROW_CHICKEN2,
> +					  _MASKED_BIT_ENABLE(DISABLE_DOP_GATING));
> +
>	for_each_dss_steering(xecore, gt, group, instance) {
>		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
>		/* Clear any drop bits set and not cleared in the previous session. */
> @@ -816,6 +822,10 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
>	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);
>	flush_delayed_work(&stream->buf_poll_work);
>
> +	if (XE_WA(gt, 22016596838))
> +		xe_gt_mcr_multicast_write(gt, ROW_CHICKEN2,
> +					  _MASKED_BIT_DISABLE(DISABLE_DOP_GATING));
> +
>	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
>	xe_pm_runtime_put(gt_to_xe(gt));
>
> diff --git a/drivers/gpu/drm/xe/xe_wa_oob.rules b/drivers/gpu/drm/xe/xe_wa_oob.rules
> index 228436532282..8e2cae7f7135 100644
> --- a/drivers/gpu/drm/xe/xe_wa_oob.rules
> +++ b/drivers/gpu/drm/xe/xe_wa_oob.rules
> @@ -5,6 +5,7 @@
>  22011391025	PLATFORM(DG2)
>  22012727170	SUBPLATFORM(DG2, G11)
>  22012727685	SUBPLATFORM(DG2, G11)
> +22016596838	PLATFORM(PVC)
>  18020744125	PLATFORM(PVC)
>  1509372804	PLATFORM(PVC), GRAPHICS_STEP(A0, C0)
>  1409600907	GRAPHICS_VERSION_RANGE(1200, 1250)

I am assuming:

* 22016596838 is the correct lineage bug number for this
* It is ok to do the enable/disable DOP gating in EU stall enable/disable,
  rather than in say stream_init/stream_close.

With this, this lgtm:

Reviewed-by: Ashutosh Dixit <ashutosh.dixit@intel.com>

Re: [PATCH v9 7/8] drm/xe/uapi: Add a device query to get EU stall sampling information

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:48 -0800, Harish Chegondi wrote:
>
> User space can get the EU stall data record size, EU stall capabilities,
> EU stall sampling rates, and per XeCore buffer size with query IOCTL
> DRM_IOCTL_XE_DEVICE_QUERY with .query set to DRM_XE_DEVICE_QUERY_EU_STALL.
> A struct drm_xe_query_eu_stall will be returned to the user space along
> with an array of supported sampling rates sorted in the fastest sampling
> rate first order. sampling_rates in struct drm_xe_query_eu_stall will
> point to the array of sampling rates.
>
> Any capabilities in EU stall sampling as of this patch are considered
> as base capabilities. New capability bits will be added for any new
> functionality added later.
>
> v9: Move reserved fields above num_sampling_rates in
>     struct drm_xe_query_eu_stall.
> v7: Change sampling_rates from a pointer to flexible array.
> v6: Include EU stall sampling rates information and
>     per XeCore buffer size in the query information.
>
> Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> ---
>  drivers/gpu/drm/xe/xe_eu_stall.c | 43 ++++++++++++++++++++++++++++++--
>  drivers/gpu/drm/xe/xe_eu_stall.h |  4 +++
>  drivers/gpu/drm/xe/xe_query.c    | 38 ++++++++++++++++++++++++++++
>  include/uapi/drm/xe_drm.h        | 40 +++++++++++++++++++++++++++--
>  4 files changed, 121 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> index 52f8f40ba9a6..4dce58f60405 100644
> --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> @@ -150,9 +150,48 @@ struct xe_eu_stall_data_xe2 {
>	__u64 unused[6];
>  } __packed;
>
> -static size_t xe_eu_stall_data_record_size(struct xe_device *xe)
> +const u64 eu_stall_sampling_rates[] = {251, 251 * 2, 251 * 3, 251 * 4, 251 * 5, 251 * 6, 251 * 7};
> +
> +/**
> + * xe_eu_stall_get_sampling_rates - get EU stall sampling rates information.
> + *
> + * @num_rates_ptr: Pointer to a u32 to return the number of sampling rates.
> + * @rates_ptr: double u64 pointer to point to an array of sampling rates.
> + *
> + * Stores the number of sampling rates and pointer to the array of
> + * sampling rates in the input pointers.
> + *
> + * Returns: Size of the EU stall sampling rates array.
> + */
> +size_t xe_eu_stall_get_sampling_rates(u32 *num_rates_ptr, const u64 **rates_ptr)

Just name these function arguments num_rates and rates. No need for _ptr,
it's obvious they are pointers.

> +{
> +	*num_rates_ptr = ARRAY_SIZE(eu_stall_sampling_rates);
> +	*rates_ptr = eu_stall_sampling_rates;
> +
> +	return sizeof(eu_stall_sampling_rates);
> +}
> +
> +/**
> + * xe_eu_stall_get_per_xecore_buf_size - get per XeCore buffer size.
> + *
> + * Returns: The per XeCore buffer size used to allocate the per GT
> + *	    EU stall data buffer.
> + */
> +size_t xe_eu_stall_get_per_xecore_buf_size(void)
> +{
> +	return per_xecore_buf_size;
> +}
> +
> +/**
> + * xe_eu_stall_data_record_size - get EU stall data record size.
> + *
> + * @xe: Pointer to a Xe device.
> + *
> + * Returns: EU stall data record size.
> + */
> +size_t xe_eu_stall_data_record_size(struct xe_device *xe)
>  {
> -	unsigned long record_size = 0;
> +	size_t record_size = 0;

This line should not be there in this patch. It should be fixed in the
previous patch where it was introduced.

>
>	if (xe->info.platform == XE_PVC)
>		record_size = sizeof(struct xe_eu_stall_data_pvc);
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
> index e42250c1d294..c612fbaf2901 100644
> --- a/drivers/gpu/drm/xe/xe_eu_stall.h
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.h
> @@ -8,6 +8,10 @@
>
>  #include "xe_gt_types.h"
>
> +size_t xe_eu_stall_get_per_xecore_buf_size(void);
> +size_t xe_eu_stall_data_record_size(struct xe_device *xe);
> +size_t xe_eu_stall_get_sampling_rates(u32 *num_rates_ptr,
> +				      const u64 **rates_ptr);

num_rates/rates

>  int xe_eu_stall_init(struct xe_gt *gt);
>  void xe_eu_stall_fini(struct xe_gt *gt);
>
> diff --git a/drivers/gpu/drm/xe/xe_query.c b/drivers/gpu/drm/xe/xe_query.c
> index 042f87a688e7..2402bb6b221c 100644
> --- a/drivers/gpu/drm/xe/xe_query.c
> +++ b/drivers/gpu/drm/xe/xe_query.c
> @@ -16,6 +16,7 @@
>  #include "regs/xe_gt_regs.h"
>  #include "xe_bo.h"
>  #include "xe_device.h"
> +#include "xe_eu_stall.h"
>  #include "xe_exec_queue.h"
>  #include "xe_force_wake.h"
>  #include "xe_ggtt.h"
> @@ -726,6 +727,42 @@ static int query_pxp_status(struct xe_device *xe, struct drm_xe_device_query *qu
>	return 0;
>  }
>
> +static int query_eu_stall(struct xe_device *xe,
> +			  struct drm_xe_device_query *query)
> +{
> +	void __user *query_ptr = u64_to_user_ptr(query->data);
> +	struct drm_xe_query_eu_stall *info;
> +	size_t size, array_size;
> +	const u64 *rates_ptr;

rates, no ptr.

> +	u32 num_rates;
> +	int ret;
> +
> +	array_size = xe_eu_stall_get_sampling_rates(&num_rates, &rates_ptr);
> +	size = sizeof(struct drm_xe_query_eu_stall) + array_size;
> +
> +	if (query->size == 0) {
> +		query->size = size;
> +		return 0;
> +	} else if (XE_IOCTL_DBG(xe, query->size != size)) {
> +		return -EINVAL;
> +	}
> +
> +	info = kzalloc(size, GFP_KERNEL);
> +	if (!info)
> +		return -ENOMEM;
> +
> +	info->num_sampling_rates = num_rates;
> +	info->capabilities = DRM_XE_EU_STALL_CAPS_BASE;
> +	info->record_size = xe_eu_stall_data_record_size(xe);
> +	info->per_xecore_buf_size = xe_eu_stall_get_per_xecore_buf_size();
> +	memcpy(info->sampling_rates, rates_ptr, array_size);
> +
> +	ret = copy_to_user(query_ptr, info, size);
> +	kfree(info);
> +
> +	return ret ? -EFAULT : 0;
> +}
> +
>  static int (* const xe_query_funcs[])(struct xe_device *xe,
>				      struct drm_xe_device_query *query) = {
>	query_engines,
> @@ -738,6 +775,7 @@ static int (* const xe_query_funcs[])(struct xe_device *xe,
>	query_uc_fw_version,
>	query_oa_units,
>	query_pxp_status,
> +	query_eu_stall,
>  };
>
>  int xe_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> diff --git a/include/uapi/drm/xe_drm.h b/include/uapi/drm/xe_drm.h
> index 1d79621f267b..c2c0983a9f2a 100644
> --- a/include/uapi/drm/xe_drm.h
> +++ b/include/uapi/drm/xe_drm.h
> @@ -735,6 +735,7 @@ struct drm_xe_device_query {
>  #define DRM_XE_DEVICE_QUERY_UC_FW_VERSION	7
>  #define DRM_XE_DEVICE_QUERY_OA_UNITS		8
>  #define DRM_XE_DEVICE_QUERY_PXP_STATUS		9
> +#define DRM_XE_DEVICE_QUERY_EU_STALL		10
>	/** @query: The type of data to query */
>	__u32 query;
>
> @@ -1873,8 +1874,8 @@ enum drm_xe_eu_stall_property_id {
>	DRM_XE_EU_STALL_PROP_GT_ID = 1,
>
>	/**
> -	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate
> -	 * in GPU cycles.
> +	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate in
> +	 * GPU cycles from @sampling_rates in struct @drm_xe_query_eu_stall
>	 */
>	DRM_XE_EU_STALL_PROP_SAMPLE_RATE,
>
> @@ -1886,6 +1887,41 @@ enum drm_xe_eu_stall_property_id {
>	DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS,
>  };
>
> +/**
> + * struct drm_xe_query_eu_stall - Information about EU stall sampling.
> + *
> + * If a query is made with a struct @drm_xe_device_query where .query
> + * is equal to @DRM_XE_DEVICE_QUERY_EU_STALL, then the reply uses
> + * struct @drm_xe_query_eu_stall in .data.
> + */
> +struct drm_xe_query_eu_stall {
> +	/** @extensions: Pointer to the first extension struct, if any */
> +	__u64 extensions;
> +
> +	/** @capabilities: EU stall capabilities bit-mask */
> +	__u64 capabilities;
> +#define DRM_XE_EU_STALL_CAPS_BASE		(1 << 0)
> +
> +	/** @record_size: size of each EU stall data record */
> +	__u64 record_size;
> +
> +	/** @per_xecore_buf_size: Per XeCore buffer size */

/** @per_xecore_buf_size: internal per xecore buffer size */

> +	__u64 per_xecore_buf_size;

Sorry to bring this up again. I previously missed that the term 'dss' is
already present in xe_drm.h. So not sure we can't just call this
per_dss_buf_size? Or do we want to introduce a new 'xecore' term here.

Could we quickly check with Matt Roper about this. xecore is ok too, but
now we are introducing two different names for the same thing.

> +
> +	/** @reserved: Reserved */
> +	__u64 reserved[5];
> +
> +	/** @num_sampling_rates: Number of sampling rates supported */

/** @num_sampling_rates: number of entries in @sampling_rates array */

> +	__u64 num_sampling_rates;
> +
> +	/**
> +	 * @sampling_rates: Flexible array of sampling rates
> +	 * sorted in the fastest to slowest order.
> +	 * Sampling rates are specified in GPU clock cycles.
> +	 */
> +	__u64 sampling_rates[];
> +};
> +
>  #if defined(__cplusplus)
>  }
>  #endif
> --
> 2.48.1
>

Also, incidentally, this eu stall query will need to be added to IGT too,
some time.

I will take another look in the next revision of this patch too, but since
the comments here are nits, after addressing/fixing those, this is:

Reviewed-by: Ashutosh Dixit <ashutosh.dixit@intel.com>

Re: [PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Harish Chegondi]

On Mon, Feb 10, 2025 at 03:07:51PM -0800, Dixit, Ashutosh wrote:
> On Mon, 10 Feb 2025 05:46:43 -0800, Harish Chegondi wrote:
> >
> 
Hi Ashutosh,
> Hi Harish,
> 
> > A new hardware feature first introduced in PVC gives capability to
> > periodically sample EU stall state and record counts for different stall
> > reasons, on a per IP basis, aggregate across all EUs in a subslice and
> > record the samples in a buffer in each subslice. Eventually, the aggregated
> > data is written out to a buffer in the memory. This feature is also
> > supported in XE2 and later architecture GPUs.
> >
> > Use an existing IOCTL - DRM_IOCTL_XE_OBSERVATION as the interface into the
> > driver from the user space to do initial setup and obtain a file descriptor
> > for the EU stall data stream.  Input parameter to the IOCTL is a struct
> > drm_xe_observation_param in which observation_type should be set to
> > DRM_XE_OBSERVATION_TYPE_EU_STALL, observation_op should be
> > DRM_XE_OBSERVATION_OP_STREAM_OPEN and param should point to a chain of
> > drm_xe_ext_set_property structures in which each structure has a pair of
> > property and value. The EU stall sampling input properties are defined in
> > drm_xe_eu_stall_property_id enum.
> >
> > With the file descriptor obtained from DRM_IOCTL_XE_OBSERVATION, user space
> > can enable and disable EU stall sampling with the IOCTLs:
> > DRM_XE_OBSERVATION_IOCTL_ENABLE and DRM_XE_OBSERVATION_IOCTL_DISABLE.
> > User space can also call poll() to check for availability of data in the
> > buffer. The data can be read with read(). Finally, the file descriptor
> > can be closed with close().
> >
> > v9: Changed some u32 to unsigned int.
> >     Moved some code around as per review feedback from v8.
> > v8: Used div_u64 instead of / to fix 32-bit build issue.
> >     Changed copyright year in xe_eu_stall.c/h to 2025.
> > v7: Renamed input property DRM_XE_EU_STALL_PROP_EVENT_REPORT_COUNT
> >     to DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS to be consistent with
> >     OA. Renamed the corresponding internal variables.
> >     Fixed some commit messages based on review feedback.
> > v6: Change the input sampling rate to GPU cycles instead of
> >     GPU cycles multiplier.
> >
> > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > ---
> >  drivers/gpu/drm/xe/Makefile         |   1 +
> >  drivers/gpu/drm/xe/xe_eu_stall.c    | 280 ++++++++++++++++++++++++++++
> >  drivers/gpu/drm/xe/xe_eu_stall.h    |  16 ++
> >  drivers/gpu/drm/xe/xe_observation.c |  14 ++
> >  include/uapi/drm/xe_drm.h           |  38 ++++
> >  5 files changed, 349 insertions(+)
> >  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.c
> >  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.h
> >
> > diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
> > index be73362ef334..05bcb9941c38 100644
> > --- a/drivers/gpu/drm/xe/Makefile
> > +++ b/drivers/gpu/drm/xe/Makefile
> > @@ -33,6 +33,7 @@ xe-y += xe_bb.o \
> >	xe_device_sysfs.o \
> >	xe_dma_buf.o \
> >	xe_drm_client.o \
> > +	xe_eu_stall.o \
> >	xe_exec.o \
> >	xe_exec_queue.o \
> >	xe_execlist.o \
> > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > new file mode 100644
> > index 000000000000..0ceb3091f81e
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > @@ -0,0 +1,280 @@
> > +// SPDX-License-Identifier: MIT
> > +/*
> > + * Copyright © 2025 Intel Corporation
> > + */
> > +
> > +#include <linux/anon_inodes.h>
> > +#include <linux/fs.h>
> > +#include <linux/poll.h>
> > +#include <linux/types.h>
> > +
> > +#include <uapi/drm/xe_drm.h>
> > +
> > +#include "xe_device.h"
> > +#include "xe_eu_stall.h"
> > +#include "xe_gt_printk.h"
> > +#include "xe_gt_topology.h"
> > +#include "xe_macros.h"
> > +#include "xe_observation.h"
> > +
> > +static size_t per_xecore_buf_size = SZ_512K;
> > +
> > +/**
> > + * struct eu_stall_open_properties - EU stall sampling properties received
> > + *				     from user space at open.
> > + * @sampling_rate_mult: EU stall sampling rate multiplier.
> > + *			HW will sample every (sampling_rate_mult x 251) cycles.
> > + * @wait_num_reports: Minimum number of EU stall data reports to unblock poll().
> > + * @gt: GT on which EU stall data will be captured.
> > + */
> > +struct eu_stall_open_properties {
> > +	unsigned int sampling_rate_mult;
> > +	unsigned int wait_num_reports;
> 
> I already said no need to be so specific. Just use int or u32 as types for
> these.
Okay, will try to change these back to u8/u32 in the next version.
> 
> > +	struct xe_gt *gt;
> > +};
> > +
> > +/**
> > + * num_data_rows - Return the number of EU stall data rows of 64B each
> > + *		   for a given data size.
> > + *
> > + * @data_size: EU stall data size
> > + */
> > +static u32 num_data_rows(u32 data_size)
> > +{
> > +	return (data_size >> 6);
> > +}
> > +
> > +static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
> > +					   struct eu_stall_open_properties *props)
> > +{
> > +	value = div_u64(value, 251);
> > +	if (value == 0 || value > 7) {
> > +		drm_dbg(&xe->drm, "Invalid EU stall sampling rate %llu\n", value);
> > +		return -EINVAL;
> > +	}
> > +	props->sampling_rate_mult = value;
> > +	return 0;
> > +}
> > +
> > +static int set_prop_eu_stall_wait_num_reports(struct xe_device *xe, u64 value,
> > +					      struct eu_stall_open_properties *props)
> > +{
> > +	unsigned int max_wait_num_reports;
> > +
> > +	max_wait_num_reports = num_data_rows(per_xecore_buf_size * XE_MAX_DSS_FUSE_BITS);
> 
> This seems wrong. Instead of XE_MAX_DSS_FUSE_BITS, shouldn't we use the
> value returned by xe_gt_topology_mask_last_dss()?
Yes you are correct. But not xe_gt_topology_mask_last_dss() as it would
only return the last DSS and the DSSes can be discontiguous. We should
use the absolute number of DSSes * buffer size. I can move this
validation to xe_eu_stall_stream_init() where we can do a 
bitmap_weight(all_xecore) to find the actual number of DSSes and return
EINVAL if invalid input. I did a simple validation here as I wasn't sure
if it is worth doing the extra validation.
> 
> Note that a large value can result in the poll/read never getting
> unblocked!
> 
> To solve this issue I think num_xecore should be maintained in struct
> xe_eu_stall_gt. Though let's see what happens to 'struct xe_device *' arg
> to these functions if we do this.
Probably not required if this validation is done in
xe_eu_stall_stream_init() added in the next patch as I described above.
> 
> > +	if (value == 0 || value > max_wait_num_reports) {
> > +		drm_dbg(&xe->drm, "Invalid EU stall event report count %llu\n", value);
> > +		drm_dbg(&xe->drm, "Minimum event report count is 1, maximum is %u\n",
> > +			max_wait_num_reports);
> > +		return -EINVAL;
> > +	}
> > +	props->wait_num_reports = value;
> > +	return 0;
> > +}
> > +
> > +static int set_prop_eu_stall_gt_id(struct xe_device *xe, u64 value,
> > +				   struct eu_stall_open_properties *props)
> > +{
> > +	if (value >= xe->info.gt_count) {
> > +		drm_dbg(&xe->drm, "Invalid GT ID %llu for EU stall sampling\n", value);
> > +		return -EINVAL;
> > +	}
> > +	props->gt = xe_device_get_gt(xe, value);
> > +	return 0;
> > +}
> > +
> > +typedef int (*set_eu_stall_property_fn)(struct xe_device *xe, u64 value,
> > +					struct eu_stall_open_properties *props);
> > +
> > +static const set_eu_stall_property_fn xe_set_eu_stall_property_funcs[] = {
> > +	[DRM_XE_EU_STALL_PROP_SAMPLE_RATE] = set_prop_eu_stall_sampling_rate,
> > +	[DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS] = set_prop_eu_stall_wait_num_reports,
> > +	[DRM_XE_EU_STALL_PROP_GT_ID] = set_prop_eu_stall_gt_id,
> > +};
> > +
> > +static int xe_eu_stall_user_ext_set_property(struct xe_device *xe, u64 extension,
> > +					     struct eu_stall_open_properties *props)
> > +{
> > +	u64 __user *address = u64_to_user_ptr(extension);
> > +	struct drm_xe_ext_set_property ext;
> > +	int err;
> > +	u32 idx;
> > +
> > +	err = __copy_from_user(&ext, address, sizeof(ext));
> > +	if (XE_IOCTL_DBG(xe, err))
> > +		return -EFAULT;
> > +
> > +	if (XE_IOCTL_DBG(xe, ext.property >= ARRAY_SIZE(xe_set_eu_stall_property_funcs)) ||
> > +	    XE_IOCTL_DBG(xe, ext.pad))
> > +		return -EINVAL;
> > +
> > +	idx = array_index_nospec(ext.property, ARRAY_SIZE(xe_set_eu_stall_property_funcs));
> > +	return xe_set_eu_stall_property_funcs[idx](xe, ext.value, props);
> > +}
> > +
> > +typedef int (*xe_eu_stall_user_extension_fn)(struct xe_device *xe, u64 extension,
> > +					     struct eu_stall_open_properties *props);
> > +static const xe_eu_stall_user_extension_fn xe_eu_stall_user_extension_funcs[] = {
> > +	[DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY] = xe_eu_stall_user_ext_set_property,
> > +};
> > +
> > +static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > +				       struct eu_stall_open_properties *props)
> 
> What is the reason for not using the ext_number argument here, which is
> used in both exec_queue_user_extensions and in xe_oa_user_extensions?

When I reused this code from the OA code it didn't have the ext_number.
I will check that out and make the change.
> 
> The reason for ext_number is that the extensions can be chained in a loop,
> which can cause an infinite loop in the kernel when parsing these
> extensions. ext_number is used to break out of these potential infinite
> loops.
> 
> > +{
> > +	u64 __user *address = u64_to_user_ptr(extension);
> > +	struct drm_xe_user_extension ext;
> > +	int err;
> > +	u32 idx;
> > +
> > +	err = __copy_from_user(&ext, address, sizeof(ext));
> > +	if (XE_IOCTL_DBG(xe, err))
> > +		return -EFAULT;
> > +
> > +	if (XE_IOCTL_DBG(xe, ext.pad) ||
> > +	    XE_IOCTL_DBG(xe, ext.name >= ARRAY_SIZE(xe_eu_stall_user_extension_funcs)))
> > +		return -EINVAL;
> > +
> > +	idx = array_index_nospec(ext.name, ARRAY_SIZE(xe_eu_stall_user_extension_funcs));
> > +	err = xe_eu_stall_user_extension_funcs[idx](xe, extension, props);
> > +	if (XE_IOCTL_DBG(xe, err))
> > +		return err;
> > +
> > +	if (ext.next_extension)
> > +		return xe_eu_stall_user_extensions(xe, ext.next_extension, props);
> > +
> > +	return 0;
> > +}
> > +
> > +/**
> > + * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> > + *
> > + * @file: An xe EU stall data stream file
> > + * @buf: destination buffer given by userspace
> > + * @count: the number of bytes userspace wants to read
> > + * @ppos: (inout) file seek position (unused)
> > + *
> > + * Userspace must enable the EU stall stream with DRM_XE_OBSERVATION_IOCTL_ENABLE
> > + * before calling read().
> 
> We can just retain these two lines of comment. See below.
> 
> > + *
> > + * Returns: The number of bytes copied or a negative error code on failure.
> > + */
> > +static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > +				       size_t count, loff_t *ppos)
> > +{
> > +	ssize_t ret = 0;
> > +
> > +	return ret;
> > +}
> > +
> > +/**
> > + * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> > + *
> > + * @file: An xe EU stall data stream file
> > + * @wait: Poll table
> > + *
> > + * Returns: Bit mask of returned events.
> > + */
> > +static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> > +{
> > +	__poll_t ret = 0;
> > +
> > +	return ret;
> > +}
> > +
> > +/**
> > + * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
> > + *
> > + * @file: An xe EU stall data stream file
> > + * @cmd: the ioctl request
> > + * @arg: the ioctl data
> > + *
> > + * Returns: zero on success or a negative error code.
> > + *	    -EINVAL for an unknown ioctl request.
> > + */
> > +static long xe_eu_stall_stream_ioctl(struct file *file,
> > +				     unsigned int cmd,
> > +				     unsigned long arg)
> > +{
> > +	switch (cmd) {
> > +	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> > +		return 0;
> > +	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> > +		return 0;
> > +	}
> > +
> > +	return -EINVAL;
> 
> Just return 0 or -EINVAL in this patch since you are going to add locking
> in a later patch.
You mean remove the switch statement completely and just return 0 or
EINVAL? The intention of this switch statement is to specify the two
IOCTLs that will be supported in the uAPI.
> 
> > +}
> > +
> > +/**
> > + * xe_eu_stall_stream_close - handles userspace close() of a EU stall data
> > + *			      stream file.
> > + * @inode: anonymous inode associated with file
> > + * @file: An xe EU stall data stream file
> > + *
> > + * Cleans up any resources associated with an open EU stall data stream file.
> > + */
> 
> As I said before, these comments are completely redundant. These are
> standard file_operations. There are one million instances of these in the
> kernel, all of them have exactly the same arguments.
> 
> If you have anything specific to EU stall here, we can leave it. Otherwise
> I'd still say get rid of them.
> 
> Or get rid them now and send a patch later to add them, we can review that
> patch later, if you really think they add value. They were included in
> i915_perf.c, but I don't think they should be in Xe.
> 
> If you think these comments should be there, let's get a second opinion,
> from one of the maintainers.
> 
Okay, will get feedback from a maintainer and will update.
> > +static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
> > +{
> > +	return 0;
> > +}
> > +
> > +static const struct file_operations fops_eu_stall = {
> > +	.owner		= THIS_MODULE,
> > +	.llseek		= noop_llseek,
> > +	.release	= xe_eu_stall_stream_close,
> > +	.poll		= xe_eu_stall_stream_poll,
> > +	.read		= xe_eu_stall_stream_read,
> > +	.unlocked_ioctl = xe_eu_stall_stream_ioctl,
> > +	.compat_ioctl   = xe_eu_stall_stream_ioctl,
> > +};
> > +
> > +static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
> > +{
> > +	return false;
> > +}
> > +
> > +/**
> > + * xe_eu_stall_stream_open - Open a xe EU stall data stream fd
> > + *
> > + * @dev: DRM device pointer
> > + * @data: pointer to first struct @drm_xe_ext_set_property in
> > + *	  the chain of input properties from the user space.
> > + * @file: DRM file pointer
> > + *
> > + * This function opens a EU stall data stream with input properties from
> > + * the user space.
> > + *
> > + * Returns: EU stall data stream fd on success or a negative error code.
> > + */
> > +int xe_eu_stall_stream_open(struct drm_device *dev,
> > +			    u64 data,
> > +			    struct drm_file *file)
> > +{
> > +	struct xe_device *xe = to_xe_device(dev);
> > +	struct eu_stall_open_properties props = {};
> > +	int ret, stream_fd;
> > +
> > +	if (xe_observation_paranoid && !perfmon_capable()) {
> > +		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
> > +		return -EACCES;
> > +	}
> > +	if (!has_eu_stall_sampling_support(xe)) {
> > +		xe_gt_dbg(props.gt, "EU stall monitoring is not supported on this platform\n");
> > +		return -EPERM;
> 
> I think we are using -ENODEV for this, at least in OA.
Okay.
> 
> > +	}
> 
> Move this has_eu_stall_sampling_support at the top, this should be even
> before the perfmon_capable check.
Will move.
> 
> > +
> > +	ret = xe_eu_stall_user_extensions(xe, data, &props);
> > +	if (ret)
> > +		return ret;
> > +
> > +	if (!props.gt) {
> > +		drm_dbg(&xe->drm, "GT ID not provided for EU stall sampling\n");
> > +		return -EINVAL;
> > +	}
> 
> This check is not needed. props.gt cannot be NULL the way
> set_prop_eu_stall_gt_id is implemented.
If the user doesn't pass a GT ID, it will be NULL.
> 
> If you need it, use xe_assert(props->gt) in set_prop_eu_stall_gt_id.
> 
> > +
> > +	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
> > +	if (stream_fd < 0)
> > +		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
> > +
> > +	return stream_fd;
> > +}
> > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
> > new file mode 100644
> > index 000000000000..d514e78341d5
> > --- /dev/null
> > +++ b/drivers/gpu/drm/xe/xe_eu_stall.h
> > @@ -0,0 +1,16 @@
> > +/* SPDX-License-Identifier: MIT */
> > +/*
> > + * Copyright © 2025 Intel Corporation
> > + */
> > +
> > +#ifndef __XE_EU_STALL_H__
> > +#define __XE_EU_STALL_H__
> > +
> > +#include <drm/drm_device.h>
> > +#include <drm/drm_file.h>
> > +#include <linux/types.h>
> 
> Because these lines are replaced in a future patch with '#include
> "xe_gt_types.h"', just do that in this patch itself.
Okay.
> 
> Also, as I said, I am not going to focus too much on the patches, only the
> final code, but in general, if you are deleting lines in these initial
> patches, think hard about why you need delete those lines and what you
> could do differently.
> 
> > +
> > +int xe_eu_stall_stream_open(struct drm_device *dev,
> > +			    u64 data,
> > +			    struct drm_file *file);
> > +#endif
> > diff --git a/drivers/gpu/drm/xe/xe_observation.c b/drivers/gpu/drm/xe/xe_observation.c
> > index 8ec1b84cbb9e..cca661de60ac 100644
> > --- a/drivers/gpu/drm/xe/xe_observation.c
> > +++ b/drivers/gpu/drm/xe/xe_observation.c
> > @@ -9,6 +9,7 @@
> >  #include <uapi/drm/xe_drm.h>
> >
> >  #include "xe_oa.h"
> > +#include "xe_eu_stall.h"
> >  #include "xe_observation.h"
> >
> >  u32 xe_observation_paranoid = true;
> > @@ -29,6 +30,17 @@ static int xe_oa_ioctl(struct drm_device *dev, struct drm_xe_observation_param *
> >	}
> >  }
> >
> > +static int xe_eu_stall_ioctl(struct drm_device *dev, struct drm_xe_observation_param *arg,
> > +			     struct drm_file *file)
> > +{
> > +	switch (arg->observation_op) {
> > +	case DRM_XE_OBSERVATION_OP_STREAM_OPEN:
> > +		return xe_eu_stall_stream_open(dev, arg->param, file);
> > +	default:
> > +		return -EINVAL;
> > +	}
> > +}
> > +
> >  /**
> >   * xe_observation_ioctl - The top level observation layer ioctl
> >   * @dev: @drm_device
> > @@ -51,6 +63,8 @@ int xe_observation_ioctl(struct drm_device *dev, void *data, struct drm_file *fi
> >	switch (arg->observation_type) {
> >	case DRM_XE_OBSERVATION_TYPE_OA:
> >		return xe_oa_ioctl(dev, arg, file);
> > +	case DRM_XE_OBSERVATION_TYPE_EU_STALL:
> > +		return xe_eu_stall_ioctl(dev, arg, file);
> >	default:
> >		return -EINVAL;
> >	}
> > diff --git a/include/uapi/drm/xe_drm.h b/include/uapi/drm/xe_drm.h
> > index 892f54d3aa09..1d79621f267b 100644
> > --- a/include/uapi/drm/xe_drm.h
> > +++ b/include/uapi/drm/xe_drm.h
> > @@ -1496,6 +1496,8 @@ struct drm_xe_wait_user_fence {
> >  enum drm_xe_observation_type {
> >	/** @DRM_XE_OBSERVATION_TYPE_OA: OA observation stream type */
> >	DRM_XE_OBSERVATION_TYPE_OA,
> > +	/** @DRM_XE_OBSERVATION_TYPE_EU_STALL: EU stall sampling observation stream type */
> > +	DRM_XE_OBSERVATION_TYPE_EU_STALL,
> >  };
> >
> >  /**
> > @@ -1848,6 +1850,42 @@ enum drm_xe_pxp_session_type {
> >  /* ID of the protected content session managed by Xe when PXP is active */
> >  #define DRM_XE_PXP_HWDRM_DEFAULT_SESSION 0xf
> >
> > +/**
> > + * enum drm_xe_eu_stall_property_id - EU stall sampling input property ids.
> > + *
> > + * These properties are passed to the driver at open as a chain of
> > + * @drm_xe_ext_set_property structures with @property set to these
> > + * properties' enums and @value set to the corresponding values of these
> > + * properties. @drm_xe_user_extension base.name should be set to
> > + * @DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY.
> > + *
> > + * With the file descriptor obtained from open, user space must enable
> > + * the EU stall stream fd with @DRM_XE_OBSERVATION_IOCTL_ENABLE before
> > + * calling read(). EIO errno from read() indicates HW dropped data
> > + * due to full buffer.
> > + */
> > +enum drm_xe_eu_stall_property_id {
> > +#define DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY		0
> > +	/**
> > +	 * @DRM_XE_EU_STALL_PROP_GT_ID: @gt_id of the GT on which
> > +	 * EU stall data will be captured.
> > +	 */
> > +	DRM_XE_EU_STALL_PROP_GT_ID = 1,
> > +
> > +	/**
> > +	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate
> > +	 * in GPU cycles.
> > +	 */
> > +	DRM_XE_EU_STALL_PROP_SAMPLE_RATE,
> > +
> > +	/**
> > +	 * @DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS: Minimum number of
> > +	 * EU stall data reports to be present in the kernel buffer
> > +	 * before unblocking poll or read that is blocked.
> 
> before unblocking a blocked poll or read
Okay
> 
> > +	 */
> > +	DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS,
> > +};
> > +
> >  #if defined(__cplusplus)
> >  }
> >  #endif
> > --
> > 2.48.1
> >

Thank you
Harish.

Re: [PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Dixit, Ashutosh]

On Wed, 12 Feb 2025 15:54:41 -0800, Harish Chegondi wrote:
>
> On Mon, Feb 10, 2025 at 03:07:51PM -0800, Dixit, Ashutosh wrote:
> > On Mon, 10 Feb 2025 05:46:43 -0800, Harish Chegondi wrote:
> > >
> >
> Hi Ashutosh,
> > Hi Harish,
> >
> > > A new hardware feature first introduced in PVC gives capability to
> > > periodically sample EU stall state and record counts for different stall
> > > reasons, on a per IP basis, aggregate across all EUs in a subslice and
> > > record the samples in a buffer in each subslice. Eventually, the aggregated
> > > data is written out to a buffer in the memory. This feature is also
> > > supported in XE2 and later architecture GPUs.
> > >
> > > Use an existing IOCTL - DRM_IOCTL_XE_OBSERVATION as the interface into the
> > > driver from the user space to do initial setup and obtain a file descriptor
> > > for the EU stall data stream.  Input parameter to the IOCTL is a struct
> > > drm_xe_observation_param in which observation_type should be set to
> > > DRM_XE_OBSERVATION_TYPE_EU_STALL, observation_op should be
> > > DRM_XE_OBSERVATION_OP_STREAM_OPEN and param should point to a chain of
> > > drm_xe_ext_set_property structures in which each structure has a pair of
> > > property and value. The EU stall sampling input properties are defined in
> > > drm_xe_eu_stall_property_id enum.
> > >
> > > With the file descriptor obtained from DRM_IOCTL_XE_OBSERVATION, user space
> > > can enable and disable EU stall sampling with the IOCTLs:
> > > DRM_XE_OBSERVATION_IOCTL_ENABLE and DRM_XE_OBSERVATION_IOCTL_DISABLE.
> > > User space can also call poll() to check for availability of data in the
> > > buffer. The data can be read with read(). Finally, the file descriptor
> > > can be closed with close().
> > >
> > > v9: Changed some u32 to unsigned int.
> > >     Moved some code around as per review feedback from v8.
> > > v8: Used div_u64 instead of / to fix 32-bit build issue.
> > >     Changed copyright year in xe_eu_stall.c/h to 2025.
> > > v7: Renamed input property DRM_XE_EU_STALL_PROP_EVENT_REPORT_COUNT
> > >     to DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS to be consistent with
> > >     OA. Renamed the corresponding internal variables.
> > >     Fixed some commit messages based on review feedback.
> > > v6: Change the input sampling rate to GPU cycles instead of
> > >     GPU cycles multiplier.
> > >
> > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > ---
> > >  drivers/gpu/drm/xe/Makefile         |   1 +
> > >  drivers/gpu/drm/xe/xe_eu_stall.c    | 280 ++++++++++++++++++++++++++++
> > >  drivers/gpu/drm/xe/xe_eu_stall.h    |  16 ++
> > >  drivers/gpu/drm/xe/xe_observation.c |  14 ++
> > >  include/uapi/drm/xe_drm.h           |  38 ++++
> > >  5 files changed, 349 insertions(+)
> > >  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.c
> > >  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.h
> > >
> > > diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
> > > index be73362ef334..05bcb9941c38 100644
> > > --- a/drivers/gpu/drm/xe/Makefile
> > > +++ b/drivers/gpu/drm/xe/Makefile
> > > @@ -33,6 +33,7 @@ xe-y += xe_bb.o \
> > >	xe_device_sysfs.o \
> > >	xe_dma_buf.o \
> > >	xe_drm_client.o \
> > > +	xe_eu_stall.o \
> > >	xe_exec.o \
> > >	xe_exec_queue.o \
> > >	xe_execlist.o \
> > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > new file mode 100644
> > > index 000000000000..0ceb3091f81e
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > @@ -0,0 +1,280 @@
> > > +// SPDX-License-Identifier: MIT
> > > +/*
> > > + * Copyright © 2025 Intel Corporation
> > > + */
> > > +
> > > +#include <linux/anon_inodes.h>
> > > +#include <linux/fs.h>
> > > +#include <linux/poll.h>
> > > +#include <linux/types.h>
> > > +
> > > +#include <uapi/drm/xe_drm.h>
> > > +
> > > +#include "xe_device.h"
> > > +#include "xe_eu_stall.h"
> > > +#include "xe_gt_printk.h"
> > > +#include "xe_gt_topology.h"
> > > +#include "xe_macros.h"
> > > +#include "xe_observation.h"
> > > +
> > > +static size_t per_xecore_buf_size = SZ_512K;
> > > +
> > > +/**
> > > + * struct eu_stall_open_properties - EU stall sampling properties received
> > > + *				     from user space at open.
> > > + * @sampling_rate_mult: EU stall sampling rate multiplier.
> > > + *			HW will sample every (sampling_rate_mult x 251) cycles.
> > > + * @wait_num_reports: Minimum number of EU stall data reports to unblock poll().
> > > + * @gt: GT on which EU stall data will be captured.
> > > + */
> > > +struct eu_stall_open_properties {
> > > +	unsigned int sampling_rate_mult;
> > > +	unsigned int wait_num_reports;
> >
> > I already said no need to be so specific. Just use int or u32 as types for
> > these.
> Okay, will try to change these back to u8/u32 in the next version.

Use int or u32, not u8.

> >
> > > +	struct xe_gt *gt;
> > > +};
> > > +
> > > +/**
> > > + * num_data_rows - Return the number of EU stall data rows of 64B each
> > > + *		   for a given data size.
> > > + *
> > > + * @data_size: EU stall data size
> > > + */
> > > +static u32 num_data_rows(u32 data_size)
> > > +{
> > > +	return (data_size >> 6);
> > > +}
> > > +
> > > +static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
> > > +					   struct eu_stall_open_properties *props)
> > > +{
> > > +	value = div_u64(value, 251);
> > > +	if (value == 0 || value > 7) {
> > > +		drm_dbg(&xe->drm, "Invalid EU stall sampling rate %llu\n", value);
> > > +		return -EINVAL;
> > > +	}
> > > +	props->sampling_rate_mult = value;
> > > +	return 0;
> > > +}
> > > +
> > > +static int set_prop_eu_stall_wait_num_reports(struct xe_device *xe, u64 value,
> > > +					      struct eu_stall_open_properties *props)
> > > +{
> > > +	unsigned int max_wait_num_reports;
> > > +
> > > +	max_wait_num_reports = num_data_rows(per_xecore_buf_size * XE_MAX_DSS_FUSE_BITS);
> >
> > This seems wrong. Instead of XE_MAX_DSS_FUSE_BITS, shouldn't we use the
> > value returned by xe_gt_topology_mask_last_dss()?
> Yes you are correct. But not xe_gt_topology_mask_last_dss() as it would
> only return the last DSS and the DSSes can be discontiguous. We should
> use the absolute number of DSSes * buffer size. I can move this
> validation to xe_eu_stall_stream_init() where we can do a
> bitmap_weight(all_xecore) to find the actual number of DSSes and return
> EINVAL if invalid input. I did a simple validation here as I wasn't sure
> if it is worth doing the extra validation.
> >
> > Note that a large value can result in the poll/read never getting
> > unblocked!
> >
> > To solve this issue I think num_xecore should be maintained in struct
> > xe_eu_stall_gt. Though let's see what happens to 'struct xe_device *' arg
> > to these functions if we do this.
> Probably not required if this validation is done in
> xe_eu_stall_stream_init() added in the next patch as I described above.

OK, we can do that. But in that case just check for 0 below, remove all the
drm_dbg's and also remove max_wait_num_reports, since that will be
validated in xe_eu_stall_stream_init(). So that we are not doing any
invalid validation here and correcting it later. Maybe even check for 0 in
xe_eu_stall_stream_init. You can add xe_gt_dbg's there if needed, or even
create a small new function.

Actually I was wrong in saying "num_xecore should be maintained in struct
xe_eu_stall_gt" because xe_eu_stall_stream_open() is a device level
function so only xe_device is available there not xe_gt. So if we were to
store num_xecore, we'd need to create a new device level xe_eu_stall struct
and put num_xecore there. This is also device level information. E.g. OA
has both device and gt level structs.

So depends on you. But we can do xe_eu_stall_stream_init for now.

> >
> > > +	if (value == 0 || value > max_wait_num_reports) {
> > > +		drm_dbg(&xe->drm, "Invalid EU stall event report count %llu\n", value);
> > > +		drm_dbg(&xe->drm, "Minimum event report count is 1, maximum is %u\n",
> > > +			max_wait_num_reports);
> > > +		return -EINVAL;
> > > +	}
> > > +	props->wait_num_reports = value;
> > > +	return 0;
> > > +}
> > > +
> > > +static int set_prop_eu_stall_gt_id(struct xe_device *xe, u64 value,
> > > +				   struct eu_stall_open_properties *props)
> > > +{
> > > +	if (value >= xe->info.gt_count) {
> > > +		drm_dbg(&xe->drm, "Invalid GT ID %llu for EU stall sampling\n", value);
> > > +		return -EINVAL;
> > > +	}
> > > +	props->gt = xe_device_get_gt(xe, value);
> > > +	return 0;
> > > +}
> > > +
> > > +typedef int (*set_eu_stall_property_fn)(struct xe_device *xe, u64 value,
> > > +					struct eu_stall_open_properties *props);
> > > +
> > > +static const set_eu_stall_property_fn xe_set_eu_stall_property_funcs[] = {
> > > +	[DRM_XE_EU_STALL_PROP_SAMPLE_RATE] = set_prop_eu_stall_sampling_rate,
> > > +	[DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS] = set_prop_eu_stall_wait_num_reports,
> > > +	[DRM_XE_EU_STALL_PROP_GT_ID] = set_prop_eu_stall_gt_id,
> > > +};
> > > +
> > > +static int xe_eu_stall_user_ext_set_property(struct xe_device *xe, u64 extension,
> > > +					     struct eu_stall_open_properties *props)
> > > +{
> > > +	u64 __user *address = u64_to_user_ptr(extension);
> > > +	struct drm_xe_ext_set_property ext;
> > > +	int err;
> > > +	u32 idx;
> > > +
> > > +	err = __copy_from_user(&ext, address, sizeof(ext));
> > > +	if (XE_IOCTL_DBG(xe, err))
> > > +		return -EFAULT;
> > > +
> > > +	if (XE_IOCTL_DBG(xe, ext.property >= ARRAY_SIZE(xe_set_eu_stall_property_funcs)) ||
> > > +	    XE_IOCTL_DBG(xe, ext.pad))
> > > +		return -EINVAL;
> > > +
> > > +	idx = array_index_nospec(ext.property, ARRAY_SIZE(xe_set_eu_stall_property_funcs));
> > > +	return xe_set_eu_stall_property_funcs[idx](xe, ext.value, props);
> > > +}
> > > +
> > > +typedef int (*xe_eu_stall_user_extension_fn)(struct xe_device *xe, u64 extension,
> > > +					     struct eu_stall_open_properties *props);
> > > +static const xe_eu_stall_user_extension_fn xe_eu_stall_user_extension_funcs[] = {
> > > +	[DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY] = xe_eu_stall_user_ext_set_property,
> > > +};
> > > +
> > > +static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > > +				       struct eu_stall_open_properties *props)
> >
> > What is the reason for not using the ext_number argument here, which is
> > used in both exec_queue_user_extensions and in xe_oa_user_extensions?
>
> When I reused this code from the OA code it didn't have the ext_number.
> I will check that out and make the change.
> >
> > The reason for ext_number is that the extensions can be chained in a loop,
> > which can cause an infinite loop in the kernel when parsing these
> > extensions. ext_number is used to break out of these potential infinite
> > loops.
> >
> > > +{
> > > +	u64 __user *address = u64_to_user_ptr(extension);
> > > +	struct drm_xe_user_extension ext;
> > > +	int err;
> > > +	u32 idx;
> > > +
> > > +	err = __copy_from_user(&ext, address, sizeof(ext));
> > > +	if (XE_IOCTL_DBG(xe, err))
> > > +		return -EFAULT;
> > > +
> > > +	if (XE_IOCTL_DBG(xe, ext.pad) ||
> > > +	    XE_IOCTL_DBG(xe, ext.name >= ARRAY_SIZE(xe_eu_stall_user_extension_funcs)))
> > > +		return -EINVAL;
> > > +
> > > +	idx = array_index_nospec(ext.name, ARRAY_SIZE(xe_eu_stall_user_extension_funcs));
> > > +	err = xe_eu_stall_user_extension_funcs[idx](xe, extension, props);
> > > +	if (XE_IOCTL_DBG(xe, err))
> > > +		return err;
> > > +
> > > +	if (ext.next_extension)
> > > +		return xe_eu_stall_user_extensions(xe, ext.next_extension, props);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +/**
> > > + * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> > > + *
> > > + * @file: An xe EU stall data stream file
> > > + * @buf: destination buffer given by userspace
> > > + * @count: the number of bytes userspace wants to read
> > > + * @ppos: (inout) file seek position (unused)
> > > + *
> > > + * Userspace must enable the EU stall stream with DRM_XE_OBSERVATION_IOCTL_ENABLE
> > > + * before calling read().
> >
> > We can just retain these two lines of comment. See below.
> >
> > > + *
> > > + * Returns: The number of bytes copied or a negative error code on failure.
> > > + */
> > > +static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > > +				       size_t count, loff_t *ppos)
> > > +{
> > > +	ssize_t ret = 0;
> > > +
> > > +	return ret;
> > > +}
> > > +
> > > +/**
> > > + * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> > > + *
> > > + * @file: An xe EU stall data stream file
> > > + * @wait: Poll table
> > > + *
> > > + * Returns: Bit mask of returned events.
> > > + */
> > > +static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> > > +{
> > > +	__poll_t ret = 0;
> > > +
> > > +	return ret;
> > > +}
> > > +
> > > +/**
> > > + * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
> > > + *
> > > + * @file: An xe EU stall data stream file
> > > + * @cmd: the ioctl request
> > > + * @arg: the ioctl data
> > > + *
> > > + * Returns: zero on success or a negative error code.
> > > + *	    -EINVAL for an unknown ioctl request.
> > > + */
> > > +static long xe_eu_stall_stream_ioctl(struct file *file,
> > > +				     unsigned int cmd,
> > > +				     unsigned long arg)
> > > +{
> > > +	switch (cmd) {
> > > +	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> > > +		return 0;
> > > +	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> > > +		return 0;
> > > +	}
> > > +
> > > +	return -EINVAL;
> >
> > Just return 0 or -EINVAL in this patch since you are going to add locking
> > in a later patch.
> You mean remove the switch statement completely and just return 0 or
> EINVAL? The intention of this switch statement is to specify the two
> IOCTLs that will be supported in the uAPI.

Each patch just has to compile and pass checkpatch. You can add the switch
statement in the later patch which adds locking, in
xe_eu_stall_stream_ioctl_locked (to avoid unnecessary code movement, see
deleted lines in that patch).

> >
> > > +}
> > > +
> > > +/**
> > > + * xe_eu_stall_stream_close - handles userspace close() of a EU stall data
> > > + *			      stream file.
> > > + * @inode: anonymous inode associated with file
> > > + * @file: An xe EU stall data stream file
> > > + *
> > > + * Cleans up any resources associated with an open EU stall data stream file.
> > > + */
> >
> > As I said before, these comments are completely redundant. These are
> > standard file_operations. There are one million instances of these in the
> > kernel, all of them have exactly the same arguments.
> >
> > If you have anything specific to EU stall here, we can leave it. Otherwise
> > I'd still say get rid of them.
> >
> > Or get rid them now and send a patch later to add them, we can review that
> > patch later, if you really think they add value. They were included in
> > i915_perf.c, but I don't think they should be in Xe.
> >
> > If you think these comments should be there, let's get a second opinion,
> > from one of the maintainers.
> >
> Okay, will get feedback from a maintainer and will update.
> > > +static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
> > > +{
> > > +	return 0;
> > > +}
> > > +
> > > +static const struct file_operations fops_eu_stall = {
> > > +	.owner		= THIS_MODULE,
> > > +	.llseek		= noop_llseek,
> > > +	.release	= xe_eu_stall_stream_close,
> > > +	.poll		= xe_eu_stall_stream_poll,
> > > +	.read		= xe_eu_stall_stream_read,
> > > +	.unlocked_ioctl = xe_eu_stall_stream_ioctl,
> > > +	.compat_ioctl   = xe_eu_stall_stream_ioctl,
> > > +};
> > > +
> > > +static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
> > > +{
> > > +	return false;
> > > +}
> > > +
> > > +/**
> > > + * xe_eu_stall_stream_open - Open a xe EU stall data stream fd
> > > + *
> > > + * @dev: DRM device pointer
> > > + * @data: pointer to first struct @drm_xe_ext_set_property in
> > > + *	  the chain of input properties from the user space.
> > > + * @file: DRM file pointer
> > > + *
> > > + * This function opens a EU stall data stream with input properties from
> > > + * the user space.
> > > + *
> > > + * Returns: EU stall data stream fd on success or a negative error code.
> > > + */
> > > +int xe_eu_stall_stream_open(struct drm_device *dev,
> > > +			    u64 data,
> > > +			    struct drm_file *file)
> > > +{
> > > +	struct xe_device *xe = to_xe_device(dev);
> > > +	struct eu_stall_open_properties props = {};
> > > +	int ret, stream_fd;
> > > +
> > > +	if (xe_observation_paranoid && !perfmon_capable()) {
> > > +		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
> > > +		return -EACCES;
> > > +	}
> > > +	if (!has_eu_stall_sampling_support(xe)) {
> > > +		xe_gt_dbg(props.gt, "EU stall monitoring is not supported on this platform\n");
> > > +		return -EPERM;
> >
> > I think we are using -ENODEV for this, at least in OA.
> Okay.
> >
> > > +	}
> >
> > Move this has_eu_stall_sampling_support at the top, this should be even
> > before the perfmon_capable check.
> Will move.
> >
> > > +
> > > +	ret = xe_eu_stall_user_extensions(xe, data, &props);
> > > +	if (ret)
> > > +		return ret;
> > > +
> > > +	if (!props.gt) {
> > > +		drm_dbg(&xe->drm, "GT ID not provided for EU stall sampling\n");
> > > +		return -EINVAL;
> > > +	}
> >
> > This check is not needed. props.gt cannot be NULL the way
> > set_prop_eu_stall_gt_id is implemented.
> If the user doesn't pass a GT ID, it will be NULL.

Yeah I commented on this later. Depends on whether we use a default gt_id
of 0 or not.

> >
> > If you need it, use xe_assert(props->gt) in set_prop_eu_stall_gt_id.
> >
> > > +
> > > +	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
> > > +	if (stream_fd < 0)
> > > +		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
> > > +
> > > +	return stream_fd;
> > > +}
> > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
> > > new file mode 100644
> > > index 000000000000..d514e78341d5
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.h
> > > @@ -0,0 +1,16 @@
> > > +/* SPDX-License-Identifier: MIT */
> > > +/*
> > > + * Copyright © 2025 Intel Corporation
> > > + */
> > > +
> > > +#ifndef __XE_EU_STALL_H__
> > > +#define __XE_EU_STALL_H__
> > > +
> > > +#include <drm/drm_device.h>
> > > +#include <drm/drm_file.h>
> > > +#include <linux/types.h>
> >
> > Because these lines are replaced in a future patch with '#include
> > "xe_gt_types.h"', just do that in this patch itself.
> Okay.
> >
> > Also, as I said, I am not going to focus too much on the patches, only the
> > final code, but in general, if you are deleting lines in these initial
> > patches, think hard about why you need delete those lines and what you
> > could do differently.
> >
> > > +
> > > +int xe_eu_stall_stream_open(struct drm_device *dev,
> > > +			    u64 data,
> > > +			    struct drm_file *file);
> > > +#endif
> > > diff --git a/drivers/gpu/drm/xe/xe_observation.c b/drivers/gpu/drm/xe/xe_observation.c
> > > index 8ec1b84cbb9e..cca661de60ac 100644
> > > --- a/drivers/gpu/drm/xe/xe_observation.c
> > > +++ b/drivers/gpu/drm/xe/xe_observation.c
> > > @@ -9,6 +9,7 @@
> > >  #include <uapi/drm/xe_drm.h>
> > >
> > >  #include "xe_oa.h"
> > > +#include "xe_eu_stall.h"
> > >  #include "xe_observation.h"
> > >
> > >  u32 xe_observation_paranoid = true;
> > > @@ -29,6 +30,17 @@ static int xe_oa_ioctl(struct drm_device *dev, struct drm_xe_observation_param *
> > >	}
> > >  }
> > >
> > > +static int xe_eu_stall_ioctl(struct drm_device *dev, struct drm_xe_observation_param *arg,
> > > +			     struct drm_file *file)
> > > +{
> > > +	switch (arg->observation_op) {
> > > +	case DRM_XE_OBSERVATION_OP_STREAM_OPEN:
> > > +		return xe_eu_stall_stream_open(dev, arg->param, file);
> > > +	default:
> > > +		return -EINVAL;
> > > +	}
> > > +}
> > > +
> > >  /**
> > >   * xe_observation_ioctl - The top level observation layer ioctl
> > >   * @dev: @drm_device
> > > @@ -51,6 +63,8 @@ int xe_observation_ioctl(struct drm_device *dev, void *data, struct drm_file *fi
> > >	switch (arg->observation_type) {
> > >	case DRM_XE_OBSERVATION_TYPE_OA:
> > >		return xe_oa_ioctl(dev, arg, file);
> > > +	case DRM_XE_OBSERVATION_TYPE_EU_STALL:
> > > +		return xe_eu_stall_ioctl(dev, arg, file);
> > >	default:
> > >		return -EINVAL;
> > >	}
> > > diff --git a/include/uapi/drm/xe_drm.h b/include/uapi/drm/xe_drm.h
> > > index 892f54d3aa09..1d79621f267b 100644
> > > --- a/include/uapi/drm/xe_drm.h
> > > +++ b/include/uapi/drm/xe_drm.h
> > > @@ -1496,6 +1496,8 @@ struct drm_xe_wait_user_fence {
> > >  enum drm_xe_observation_type {
> > >	/** @DRM_XE_OBSERVATION_TYPE_OA: OA observation stream type */
> > >	DRM_XE_OBSERVATION_TYPE_OA,
> > > +	/** @DRM_XE_OBSERVATION_TYPE_EU_STALL: EU stall sampling observation stream type */
> > > +	DRM_XE_OBSERVATION_TYPE_EU_STALL,
> > >  };
> > >
> > >  /**
> > > @@ -1848,6 +1850,42 @@ enum drm_xe_pxp_session_type {
> > >  /* ID of the protected content session managed by Xe when PXP is active */
> > >  #define DRM_XE_PXP_HWDRM_DEFAULT_SESSION 0xf
> > >
> > > +/**
> > > + * enum drm_xe_eu_stall_property_id - EU stall sampling input property ids.
> > > + *
> > > + * These properties are passed to the driver at open as a chain of
> > > + * @drm_xe_ext_set_property structures with @property set to these
> > > + * properties' enums and @value set to the corresponding values of these
> > > + * properties. @drm_xe_user_extension base.name should be set to
> > > + * @DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY.
> > > + *
> > > + * With the file descriptor obtained from open, user space must enable
> > > + * the EU stall stream fd with @DRM_XE_OBSERVATION_IOCTL_ENABLE before
> > > + * calling read(). EIO errno from read() indicates HW dropped data
> > > + * due to full buffer.
> > > + */
> > > +enum drm_xe_eu_stall_property_id {
> > > +#define DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY		0
> > > +	/**
> > > +	 * @DRM_XE_EU_STALL_PROP_GT_ID: @gt_id of the GT on which
> > > +	 * EU stall data will be captured.
> > > +	 */
> > > +	DRM_XE_EU_STALL_PROP_GT_ID = 1,
> > > +
> > > +	/**
> > > +	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate
> > > +	 * in GPU cycles.
> > > +	 */
> > > +	DRM_XE_EU_STALL_PROP_SAMPLE_RATE,
> > > +
> > > +	/**
> > > +	 * @DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS: Minimum number of
> > > +	 * EU stall data reports to be present in the kernel buffer
> > > +	 * before unblocking poll or read that is blocked.
> >
> > before unblocking a blocked poll or read
> Okay
> >
> > > +	 */
> > > +	DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS,
> > > +};
> > > +
> > >  #if defined(__cplusplus)
> > >  }
> > >  #endif
> > > --
> > > 2.48.1
> > >
>
> Thank you
> Harish.

Re: [PATCH v9 5/8] drm/xe/eustall: Add support to handle dropped EU stall data

[Dixit, Ashutosh]

On Mon, 10 Feb 2025 05:46:46 -0800, Harish Chegondi wrote:
>

Hi Harish,

> If the user space doesn't read the EU stall data fast enough,
> it is possible that the EU stall data buffer can get filled,
> and if the hardware wants to write more data, it simply drops
> data due to unavailable buffer space. In that case, hardware
> sets a bit in a register. If the driver detects data drop,
> the driver read() returns -EIO error to let the user space
> know that HW has dropped data. The -EIO error is returned
> even if there is EU stall data in the buffer. A subsequent
> read by the user space returns the remaining EU stall data.
>
> v9:  Move all data drop handling code to this patch

Good, separating out makes this easier to review. I would actually make
this the last patch, but anyway it's ok as is too.

>      Clear all drop data bits before returning -EIO.
>
> Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> ---
>  drivers/gpu/drm/xe/xe_eu_stall.c | 39 ++++++++++++++++++++++++++++++++
>  1 file changed, 39 insertions(+)
>
> diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> index 53f17aac7d3b..428267010805 100644
> --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> @@ -53,6 +53,10 @@ struct xe_eu_stall_data_stream {
>	struct xe_gt *gt;
>	struct xe_bo *bo;
>	struct per_xecore_buf *xecore_buf;
> +	struct {
> +		bool reported_to_user;
> +		xe_dss_mask_t mask;
> +	} data_drop;
>	struct delayed_work buf_poll_work;
>	struct workqueue_struct *buf_poll_wq;
>  };
> @@ -331,12 +335,24 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
>			if (num_data_rows(total_data) >= stream->wait_num_reports)
>				min_data_present = true;
>		}
> +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> +			set_bit(xecore, stream->data_drop.mask);
>		xecore_buf->write = write_ptr;
>		mutex_unlock(&xecore_buf->ptr_lock);
>	}
>	return min_data_present;
>  }
>
> +static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
> +{
> +	u32 write_ptr_reg;
> +
> +	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
> +	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
> +
> +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
> +}
> +
>  static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
>				     char __user *buf, size_t count,
>				     size_t *total_data_size, struct xe_gt *gt,
> @@ -436,6 +452,22 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
>	unsigned int xecore;
>	int ret = 0;
>
> +	if (bitmap_weight(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS)) {
> +		if (!stream->data_drop.reported_to_user) {
> +			for_each_dss_steering(xecore, gt, group, instance) {
> +				if (test_bit(xecore, stream->data_drop.mask)) {
> +					clear_dropped_eviction_line_bit(gt, group, instance);
> +					clear_bit(xecore, stream->data_drop.mask);
> +				}
> +			}

This is not making any sense. How can we clear_dropped_eviction_line_bit
before reading the data? The HW will set it right back up.

At least the code in the previous version made some sense. So we should at
least go back to that and review that. Though it also had issue with how
many times -EIO is returned etc.

The other issue is the locking. As I suggested in my comments on Patch 4/8,
I don't think we need a per xecore_buf lock, just one ptr_lock for reading
all the DSS's. And then we can use that here too.

But at least let's get something sane for review first.

> +			stream->data_drop.reported_to_user = true;
> +			xe_gt_dbg(gt, "EU stall data dropped in XeCores: %*pb\n",
> +				  XE_MAX_DSS_FUSE_BITS, stream->data_drop.mask);
> +			return -EIO;
> +		}
> +		stream->data_drop.reported_to_user = false;
> +	}
> +
>	for_each_dss_steering(xecore, gt, group, instance) {
>		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
>						gt, group, instance, xecore);
> @@ -457,6 +489,7 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
>   * before calling read().
>   *
>   * Returns: The number of bytes copied or a negative error code on failure.
> + *	    -EIO if HW drops any EU stall data when the buffer is full.
>   */
>  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
>				       size_t count, loff_t *ppos)
> @@ -543,6 +576,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
>
>	for_each_dss_steering(xecore, gt, group, instance) {
>		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> +		/* Clear any drop bits set and not cleared in the previous session. */
> +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> +			clear_dropped_eviction_line_bit(gt, group, instance);
>		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
>		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
>		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> @@ -554,6 +590,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
>		xecore_buf->write = write_ptr;
>		xecore_buf->read = write_ptr;
>	}
> +	stream->data_drop.reported_to_user = false;
> +	bitmap_zero(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS);
> +
>	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
>				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
>				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> --
> 2.48.1
>

Re: [PATCH v9 5/8] drm/xe/eustall: Add support to handle dropped EU stall data

[Harish Chegondi]

On Wed, Feb 12, 2025 at 10:31:15PM -0800, Dixit, Ashutosh wrote:
> On Mon, 10 Feb 2025 05:46:46 -0800, Harish Chegondi wrote:
> >
> 
Hi Ashutosh,
> Hi Harish,
> 
> > If the user space doesn't read the EU stall data fast enough,
> > it is possible that the EU stall data buffer can get filled,
> > and if the hardware wants to write more data, it simply drops
> > data due to unavailable buffer space. In that case, hardware
> > sets a bit in a register. If the driver detects data drop,
> > the driver read() returns -EIO error to let the user space
> > know that HW has dropped data. The -EIO error is returned
> > even if there is EU stall data in the buffer. A subsequent
> > read by the user space returns the remaining EU stall data.
> >
> > v9:  Move all data drop handling code to this patch
> 
> Good, separating out makes this easier to review. I would actually make
> this the last patch, but anyway it's ok as is too.
> 
> >      Clear all drop data bits before returning -EIO.
> >
> > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > ---
> >  drivers/gpu/drm/xe/xe_eu_stall.c | 39 ++++++++++++++++++++++++++++++++
> >  1 file changed, 39 insertions(+)
> >
> > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > index 53f17aac7d3b..428267010805 100644
> > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > @@ -53,6 +53,10 @@ struct xe_eu_stall_data_stream {
> >	struct xe_gt *gt;
> >	struct xe_bo *bo;
> >	struct per_xecore_buf *xecore_buf;
> > +	struct {
> > +		bool reported_to_user;
> > +		xe_dss_mask_t mask;
> > +	} data_drop;
> >	struct delayed_work buf_poll_work;
> >	struct workqueue_struct *buf_poll_wq;
> >  };
> > @@ -331,12 +335,24 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> >			if (num_data_rows(total_data) >= stream->wait_num_reports)
> >				min_data_present = true;
> >		}
> > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > +			set_bit(xecore, stream->data_drop.mask);
> >		xecore_buf->write = write_ptr;
> >		mutex_unlock(&xecore_buf->ptr_lock);
> >	}
> >	return min_data_present;
> >  }
> >
> > +static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
> > +{
> > +	u32 write_ptr_reg;
> > +
> > +	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
> > +	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
> > +
> > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
> > +}
> > +
> >  static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> >				     char __user *buf, size_t count,
> >				     size_t *total_data_size, struct xe_gt *gt,
> > @@ -436,6 +452,22 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> >	unsigned int xecore;
> >	int ret = 0;
> >
> > +	if (bitmap_weight(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS)) {
> > +		if (!stream->data_drop.reported_to_user) {
> > +			for_each_dss_steering(xecore, gt, group, instance) {
> > +				if (test_bit(xecore, stream->data_drop.mask)) {
> > +					clear_dropped_eviction_line_bit(gt, group, instance);
> > +					clear_bit(xecore, stream->data_drop.mask);
> > +				}
> > +			}
> 
> This is not making any sense. How can we clear_dropped_eviction_line_bit
> before reading the data? The HW will set it right back up.

This bit is being cleared here because the driver has acknowledged to
the user space all the data that has been dropped so far. Any new data
drop after we clear the bit *should* result in another -EIO return.
HW will set the bit again *only* if it drops more data. User space is
expected to do another read() to clear the buffer ASAP after getting
an -EIO from the first read().

> 
> At least the code in the previous version made some sense. So we should at
> least go back to that and review that. Though it also had issue with how
> many times -EIO is returned etc.
Can you please explain what is the issue? Every time there is a new data
drop after the drop bit is cleared, it *should* result in another -EIO return
The driver ensures that two successive reads will not return -EIO.
> 
> The other issue is the locking. As I suggested in my comments on Patch 4/8,
> I don't think we need a per xecore_buf lock, just one ptr_lock for reading
> all the DSS's. And then we can use that here too.

I used a per xecore_buf lock so that the polling function can update for
example subslice 1's write pointer while read() reads the data from
subslice 2. It would lead to more parallelism. With a higher granularity
lock, the polling for new data blocks during read and vice versa.
> 
> But at least let's get something sane for review first.
Before I spawn another version of the patch series, I would like to
list the approaches to take here and cons for each approach.
Feel free to add any other approaches you suggest here. Feedback from
one of the EU stall consumers that they read data even after an -EIO
return means that any approach to discard data in the buffer 
is unacceptable.

1. Approach used in version 8: 
   First read() returns -EIO without clearing any drop bits
   Second read() reads the data and clears the bit for each subslice
   Cons: If the user space buffer is small and all subslice data is not
   read, those subslices whose drop bit is not cleared can cause -EIO in
   the next read(). This issue can be mitigated by user space buffer
   large enough to read data from all the subslices.

2. Approach used in version 9:
   First read() returns -EIO after clearing all drop bits
   Second read() reads all the EU stall data that can fit into the user
   buffer.
   Pros: Unlike in version 8 approach, even if the user buffer is small,
   all drop bits get cleared in the first read()
   Cons: Because the buffers are full, if the user space doesn't call
   another read() soon to clear the data, there is a higher chance of HW
   dropping the data again, setting the bit again.

3. New approach: Hybrid of version 8 and 9:
   First read() returns -EIO without clearing any drop bits
   Second read() reads all the EU stall data that can fit into the user
   buffer, but clears all the drop bits even for those subslices it
   can't read the data if the user buffer can't accommodate.
   Cons: For those subslices whose data buffers are full and drop bits
   are cleared, there is a chance that the HW can set the bits again if
   data is dropped again unless user space calls another read() fast
   enough. This can also be mitigated with a user space buffer large
   enough to read data from all the subslices.


Please feel free to add any new approaches here that those don't discard
data in the buffers, also add any more cons to the above approaches.
Let's agree on an approach for the next patch version.

Thank you
Harish.
> > +			stream->data_drop.reported_to_user = true;
> > +			xe_gt_dbg(gt, "EU stall data dropped in XeCores: %*pb\n",
> > +				  XE_MAX_DSS_FUSE_BITS, stream->data_drop.mask);
> > +			return -EIO;
> > +		}
> > +		stream->data_drop.reported_to_user = false;
> > +	}
> > +
> >	for_each_dss_steering(xecore, gt, group, instance) {
> >		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> >						gt, group, instance, xecore);
> > @@ -457,6 +489,7 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> >   * before calling read().
> >   *
> >   * Returns: The number of bytes copied or a negative error code on failure.
> > + *	    -EIO if HW drops any EU stall data when the buffer is full.
> >   */
> >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> >				       size_t count, loff_t *ppos)
> > @@ -543,6 +576,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> >
> >	for_each_dss_steering(xecore, gt, group, instance) {
> >		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> > +		/* Clear any drop bits set and not cleared in the previous session. */
> > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > +			clear_dropped_eviction_line_bit(gt, group, instance);
> >		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> >		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
> >		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > @@ -554,6 +590,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> >		xecore_buf->write = write_ptr;
> >		xecore_buf->read = write_ptr;
> >	}
> > +	stream->data_drop.reported_to_user = false;
> > +	bitmap_zero(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS);
> > +
> >	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
> >				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
> >				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> > --
> > 2.48.1
> >

Re: [PATCH v9 5/8] drm/xe/eustall: Add support to handle dropped EU stall data

[Dixit, Ashutosh]

On Thu, 13 Feb 2025 13:55:06 -0800, Harish Chegondi wrote:
>

Hi Harish,

> On Wed, Feb 12, 2025 at 10:31:15PM -0800, Dixit, Ashutosh wrote:
> > On Mon, 10 Feb 2025 05:46:46 -0800, Harish Chegondi wrote:
> > >
> >
> Hi Ashutosh,
> > Hi Harish,
> >
> > > If the user space doesn't read the EU stall data fast enough,
> > > it is possible that the EU stall data buffer can get filled,
> > > and if the hardware wants to write more data, it simply drops
> > > data due to unavailable buffer space. In that case, hardware
> > > sets a bit in a register. If the driver detects data drop,
> > > the driver read() returns -EIO error to let the user space
> > > know that HW has dropped data. The -EIO error is returned
> > > even if there is EU stall data in the buffer. A subsequent
> > > read by the user space returns the remaining EU stall data.
> > >
> > > v9:  Move all data drop handling code to this patch
> >
> > Good, separating out makes this easier to review. I would actually make
> > this the last patch, but anyway it's ok as is too.
> >
> > >      Clear all drop data bits before returning -EIO.
> > >
> > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > ---
> > >  drivers/gpu/drm/xe/xe_eu_stall.c | 39 ++++++++++++++++++++++++++++++++
> > >  1 file changed, 39 insertions(+)
> > >
> > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > index 53f17aac7d3b..428267010805 100644
> > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > @@ -53,6 +53,10 @@ struct xe_eu_stall_data_stream {
> > >	struct xe_gt *gt;
> > >	struct xe_bo *bo;
> > >	struct per_xecore_buf *xecore_buf;
> > > +	struct {
> > > +		bool reported_to_user;
> > > +		xe_dss_mask_t mask;
> > > +	} data_drop;
> > >	struct delayed_work buf_poll_work;
> > >	struct workqueue_struct *buf_poll_wq;
> > >  };
> > > @@ -331,12 +335,24 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > >			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > >				min_data_present = true;
> > >		}
> > > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > > +			set_bit(xecore, stream->data_drop.mask);
> > >		xecore_buf->write = write_ptr;
> > >		mutex_unlock(&xecore_buf->ptr_lock);
> > >	}
> > >	return min_data_present;
> > >  }
> > >
> > > +static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
> > > +{
> > > +	u32 write_ptr_reg;
> > > +
> > > +	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
> > > +	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
> > > +
> > > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
> > > +}
> > > +
> > >  static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > >				     char __user *buf, size_t count,
> > >				     size_t *total_data_size, struct xe_gt *gt,
> > > @@ -436,6 +452,22 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> > >	unsigned int xecore;
> > >	int ret = 0;
> > >
> > > +	if (bitmap_weight(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS)) {
> > > +		if (!stream->data_drop.reported_to_user) {
> > > +			for_each_dss_steering(xecore, gt, group, instance) {
> > > +				if (test_bit(xecore, stream->data_drop.mask)) {
> > > +					clear_dropped_eviction_line_bit(gt, group, instance);
> > > +					clear_bit(xecore, stream->data_drop.mask);
> > > +				}
> > > +			}
> >
> > This is not making any sense. How can we clear_dropped_eviction_line_bit
> > before reading the data? The HW will set it right back up.
>
> This bit is being cleared here because the driver has acknowledged to
> the user space all the data that has been dropped so far. Any new data
> drop after we clear the bit *should* result in another -EIO return.
> HW will set the bit again *only* if it drops more data. User space is
> expected to do another read() to clear the buffer ASAP after getting
> an -EIO from the first read().
>
> >
> > At least the code in the previous version made some sense. So we should at
> > least go back to that and review that. Though it also had issue with how
> > many times -EIO is returned etc.
> Can you please explain what is the issue? Every time there is a new data
> drop after the drop bit is cleared, it *should* result in another -EIO return
> The driver ensures that two successive reads will not return -EIO.
> >
> > The other issue is the locking. As I suggested in my comments on Patch 4/8,
> > I don't think we need a per xecore_buf lock, just one ptr_lock for reading
> > all the DSS's. And then we can use that here too.
>
> I used a per xecore_buf lock so that the polling function can update for
> example subslice 1's write pointer while read() reads the data from
> subslice 2. It would lead to more parallelism. With a higher granularity
> lock, the polling for new data blocks during read and vice versa.
> >
> > But at least let's get something sane for review first.
> Before I spawn another version of the patch series, I would like to
> list the approaches to take here and cons for each approach.
> Feel free to add any other approaches you suggest here. Feedback from
> one of the EU stall consumers that they read data even after an -EIO
> return means that any approach to discard data in the buffer
> is unacceptable.
>
> 1. Approach used in version 8:
>    First read() returns -EIO without clearing any drop bits
>    Second read() reads the data and clears the bit for each subslice
>    Cons: If the user space buffer is small and all subslice data is not
>    read, those subslices whose drop bit is not cleared can cause -EIO in
>    the next read(). This issue can be mitigated by user space buffer
>    large enough to read data from all the subslices.
>
> 2. Approach used in version 9:
>    First read() returns -EIO after clearing all drop bits
>    Second read() reads all the EU stall data that can fit into the user
>    buffer.
>    Pros: Unlike in version 8 approach, even if the user buffer is small,
>    all drop bits get cleared in the first read()
>    Cons: Because the buffers are full, if the user space doesn't call
>    another read() soon to clear the data, there is a higher chance of HW
>    dropping the data again, setting the bit again.
>
> 3. New approach: Hybrid of version 8 and 9:
>    First read() returns -EIO without clearing any drop bits
>    Second read() reads all the EU stall data that can fit into the user
>    buffer, but clears all the drop bits even for those subslices it
>    can't read the data if the user buffer can't accommodate.
>    Cons: For those subslices whose data buffers are full and drop bits
>    are cleared, there is a chance that the HW can set the bits again if
>    data is dropped again unless user space calls another read() fast
>    enough. This can also be mitigated with a user space buffer large
>    enough to read data from all the subslices.
>
> Please feel free to add any new approaches here that those don't discard
> data in the buffers, also add any more cons to the above approaches.
> Let's agree on an approach for the next patch version.

Let's have some ground rules and not do random stuff. The basic ground rule
for me is that there is no point doing clear_dropped_eviction_line_bit,
till we have read the data (and moved the read pointer) to make some space
in the per dss buffer. Otherwise, HW will just set that bit right up. HW is
writing data and userspace reads cannot match the speed with which HW is
writing data.

So the only approach I see viable is that in your v8. These other
approaches you are making up are unworkable imo. I am ok if you don't want
to drop data in the driver, I am not pushing that approach which I had
suggested. But please post something which follows the ground rule
mentioned above. The only thing I see which does that is v8.

Finally, yes, it comes down to that userspace will either have to use a
large enough user buffer so that -EIO returns disappear. Or deal with -EIO
returns, ignore them etc. Or read data fast enough using a small buffer,
which is a bug in the current patches which we are saying we will fix after
merging. If they use a small buffer and see multiple -EIO returns, that's
fine, they just need to deal with it. The uapi is not promising anything
about number of -EIO returns they will see. Maybe the -EIO returns will
never clear up (I don't think they will till we fix the small buffer bug in
the patches).

Thanks.
--
Ashutosh

>
> Thank you
> Harish.
> > > +			stream->data_drop.reported_to_user = true;
> > > +			xe_gt_dbg(gt, "EU stall data dropped in XeCores: %*pb\n",
> > > +				  XE_MAX_DSS_FUSE_BITS, stream->data_drop.mask);
> > > +			return -EIO;
> > > +		}
> > > +		stream->data_drop.reported_to_user = false;
> > > +	}
> > > +
> > >	for_each_dss_steering(xecore, gt, group, instance) {
> > >		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > >						gt, group, instance, xecore);
> > > @@ -457,6 +489,7 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> > >   * before calling read().
> > >   *
> > >   * Returns: The number of bytes copied or a negative error code on failure.
> > > + *	    -EIO if HW drops any EU stall data when the buffer is full.
> > >   */
> > >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > >				       size_t count, loff_t *ppos)
> > > @@ -543,6 +576,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > >
> > >	for_each_dss_steering(xecore, gt, group, instance) {
> > >		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> > > +		/* Clear any drop bits set and not cleared in the previous session. */
> > > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > > +			clear_dropped_eviction_line_bit(gt, group, instance);
> > >		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > >		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
> > >		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > > @@ -554,6 +590,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > >		xecore_buf->write = write_ptr;
> > >		xecore_buf->read = write_ptr;
> > >	}
> > > +	stream->data_drop.reported_to_user = false;
> > > +	bitmap_zero(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS);
> > > +
> > >	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
> > >				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
> > >				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> > > --
> > > 2.48.1
> > >

Re: [PATCH v9 5/8] drm/xe/eustall: Add support to handle dropped EU stall data

[Dixit, Ashutosh]

On Thu, 13 Feb 2025 15:45:50 -0800, Dixit, Ashutosh wrote:
>
> On Thu, 13 Feb 2025 13:55:06 -0800, Harish Chegondi wrote:
> >
>
> Hi Harish,
>
> > On Wed, Feb 12, 2025 at 10:31:15PM -0800, Dixit, Ashutosh wrote:
> > > On Mon, 10 Feb 2025 05:46:46 -0800, Harish Chegondi wrote:
> > > >
> > >
> > Hi Ashutosh,
> > > Hi Harish,
> > >
> > > > If the user space doesn't read the EU stall data fast enough,
> > > > it is possible that the EU stall data buffer can get filled,
> > > > and if the hardware wants to write more data, it simply drops
> > > > data due to unavailable buffer space. In that case, hardware
> > > > sets a bit in a register. If the driver detects data drop,
> > > > the driver read() returns -EIO error to let the user space
> > > > know that HW has dropped data. The -EIO error is returned
> > > > even if there is EU stall data in the buffer. A subsequent
> > > > read by the user space returns the remaining EU stall data.
> > > >
> > > > v9:  Move all data drop handling code to this patch
> > >
> > > Good, separating out makes this easier to review. I would actually make
> > > this the last patch, but anyway it's ok as is too.
> > >
> > > >      Clear all drop data bits before returning -EIO.
> > > >
> > > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > > ---
> > > >  drivers/gpu/drm/xe/xe_eu_stall.c | 39 ++++++++++++++++++++++++++++++++
> > > >  1 file changed, 39 insertions(+)
> > > >
> > > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > index 53f17aac7d3b..428267010805 100644
> > > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > @@ -53,6 +53,10 @@ struct xe_eu_stall_data_stream {
> > > >	struct xe_gt *gt;
> > > >	struct xe_bo *bo;
> > > >	struct per_xecore_buf *xecore_buf;
> > > > +	struct {
> > > > +		bool reported_to_user;
> > > > +		xe_dss_mask_t mask;
> > > > +	} data_drop;
> > > >	struct delayed_work buf_poll_work;
> > > >	struct workqueue_struct *buf_poll_wq;
> > > >  };
> > > > @@ -331,12 +335,24 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > > >			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > > >				min_data_present = true;
> > > >		}
> > > > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > > > +			set_bit(xecore, stream->data_drop.mask);
> > > >		xecore_buf->write = write_ptr;
> > > >		mutex_unlock(&xecore_buf->ptr_lock);
> > > >	}
> > > >	return min_data_present;
> > > >  }
> > > >
> > > > +static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
> > > > +{
> > > > +	u32 write_ptr_reg;
> > > > +
> > > > +	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
> > > > +	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
> > > > +
> > > > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
> > > > +}
> > > > +
> > > >  static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > > >				     char __user *buf, size_t count,
> > > >				     size_t *total_data_size, struct xe_gt *gt,
> > > > @@ -436,6 +452,22 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> > > >	unsigned int xecore;
> > > >	int ret = 0;
> > > >
> > > > +	if (bitmap_weight(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS)) {
> > > > +		if (!stream->data_drop.reported_to_user) {
> > > > +			for_each_dss_steering(xecore, gt, group, instance) {
> > > > +				if (test_bit(xecore, stream->data_drop.mask)) {
> > > > +					clear_dropped_eviction_line_bit(gt, group, instance);
> > > > +					clear_bit(xecore, stream->data_drop.mask);
> > > > +				}
> > > > +			}
> > >
> > > This is not making any sense. How can we clear_dropped_eviction_line_bit
> > > before reading the data? The HW will set it right back up.
> >
> > This bit is being cleared here because the driver has acknowledged to
> > the user space all the data that has been dropped so far. Any new data
> > drop after we clear the bit *should* result in another -EIO return.
> > HW will set the bit again *only* if it drops more data. User space is
> > expected to do another read() to clear the buffer ASAP after getting
> > an -EIO from the first read().
> >
> > >
> > > At least the code in the previous version made some sense. So we should at
> > > least go back to that and review that. Though it also had issue with how
> > > many times -EIO is returned etc.
> > Can you please explain what is the issue? Every time there is a new data
> > drop after the drop bit is cleared, it *should* result in another -EIO return
> > The driver ensures that two successive reads will not return -EIO.
> > >
> > > The other issue is the locking. As I suggested in my comments on Patch 4/8,
> > > I don't think we need a per xecore_buf lock, just one ptr_lock for reading
> > > all the DSS's. And then we can use that here too.
> >
> > I used a per xecore_buf lock so that the polling function can update for
> > example subslice 1's write pointer while read() reads the data from
> > subslice 2. It would lead to more parallelism. With a higher granularity
> > lock, the polling for new data blocks during read and vice versa.

Why do we need this extra parallelism? I am fine with reads and polling
being serialized. Because if we don't do this, there are instances like
checking the drop data mask where we either take all the dss locks or don't
take any (which is what you are advocating). This situation is solved by
having a single lock for all dss's (I am assuming we don't need that
extra parallelism).

> > >
> > > But at least let's get something sane for review first.
> > Before I spawn another version of the patch series, I would like to
> > list the approaches to take here and cons for each approach.
> > Feel free to add any other approaches you suggest here. Feedback from
> > one of the EU stall consumers that they read data even after an -EIO
> > return means that any approach to discard data in the buffer
> > is unacceptable.
> >
> > 1. Approach used in version 8:
> >    First read() returns -EIO without clearing any drop bits
> >    Second read() reads the data and clears the bit for each subslice
> >    Cons: If the user space buffer is small and all subslice data is not
> >    read, those subslices whose drop bit is not cleared can cause -EIO in
> >    the next read(). This issue can be mitigated by user space buffer
> >    large enough to read data from all the subslices.
> >
> > 2. Approach used in version 9:
> >    First read() returns -EIO after clearing all drop bits
> >    Second read() reads all the EU stall data that can fit into the user
> >    buffer.
> >    Pros: Unlike in version 8 approach, even if the user buffer is small,
> >    all drop bits get cleared in the first read()
> >    Cons: Because the buffers are full, if the user space doesn't call
> >    another read() soon to clear the data, there is a higher chance of HW
> >    dropping the data again, setting the bit again.
> >
> > 3. New approach: Hybrid of version 8 and 9:
> >    First read() returns -EIO without clearing any drop bits
> >    Second read() reads all the EU stall data that can fit into the user
> >    buffer, but clears all the drop bits even for those subslices it
> >    can't read the data if the user buffer can't accommodate.
> >    Cons: For those subslices whose data buffers are full and drop bits
> >    are cleared, there is a chance that the HW can set the bits again if
> >    data is dropped again unless user space calls another read() fast
> >    enough. This can also be mitigated with a user space buffer large
> >    enough to read data from all the subslices.
> >
> > Please feel free to add any new approaches here that those don't discard
> > data in the buffers, also add any more cons to the above approaches.
> > Let's agree on an approach for the next patch version.
>
> Let's have some ground rules and not do random stuff. The basic ground rule
> for me is that there is no point doing clear_dropped_eviction_line_bit,
> till we have read the data (and moved the read pointer) to make some space
> in the per dss buffer. Otherwise, HW will just set that bit right up. HW is
> writing data and userspace reads cannot match the speed with which HW is
> writing data.
>
> So the only approach I see viable is that in your v8. These other
> approaches you are making up are unworkable imo. I am ok if you don't want
> to drop data in the driver, I am not pushing that approach which I had
> suggested. But please post something which follows the ground rule
> mentioned above. The only thing I see which does that is v8.
>
> Finally, yes, it comes down to that userspace will either have to use a
> large enough user buffer so that -EIO returns disappear. Or deal with -EIO
> returns, ignore them etc. Or read data fast enough using a small buffer,
> which is a bug in the current patches which we are saying we will fix after
> merging. If they use a small buffer and see multiple -EIO returns, that's
> fine, they just need to deal with it. The uapi is not promising anything
> about number of -EIO returns they will see. Maybe the -EIO returns will
> never clear up (I don't think they will till we fix the small buffer bug in
> the patches).

My approach would be to start with the stuff in v8 and then see if we can
do something there to make sure userspace can read all data even with a
small buffer, without seeing multiple -EIO returns till it has completed
reading all dss's, with the assumption that the small buffer bug is not
there (or has been fixed). Something like that. So at the minimum we start
with the code in v8.

>
> Thanks.
> --
> Ashutosh
>
> >
> > Thank you
> > Harish.
> > > > +			stream->data_drop.reported_to_user = true;
> > > > +			xe_gt_dbg(gt, "EU stall data dropped in XeCores: %*pb\n",
> > > > +				  XE_MAX_DSS_FUSE_BITS, stream->data_drop.mask);
> > > > +			return -EIO;
> > > > +		}
> > > > +		stream->data_drop.reported_to_user = false;
> > > > +	}
> > > > +
> > > >	for_each_dss_steering(xecore, gt, group, instance) {
> > > >		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > > >						gt, group, instance, xecore);
> > > > @@ -457,6 +489,7 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> > > >   * before calling read().
> > > >   *
> > > >   * Returns: The number of bytes copied or a negative error code on failure.
> > > > + *	    -EIO if HW drops any EU stall data when the buffer is full.
> > > >   */
> > > >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > > >				       size_t count, loff_t *ppos)
> > > > @@ -543,6 +576,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > >
> > > >	for_each_dss_steering(xecore, gt, group, instance) {
> > > >		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> > > > +		/* Clear any drop bits set and not cleared in the previous session. */
> > > > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > > > +			clear_dropped_eviction_line_bit(gt, group, instance);
> > > >		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > > >		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
> > > >		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > > > @@ -554,6 +590,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > >		xecore_buf->write = write_ptr;
> > > >		xecore_buf->read = write_ptr;
> > > >	}
> > > > +	stream->data_drop.reported_to_user = false;
> > > > +	bitmap_zero(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS);
> > > > +
> > > >	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
> > > >				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
> > > >				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> > > > --
> > > > 2.48.1
> > > >

Re: [PATCH v9 5/8] drm/xe/eustall: Add support to handle dropped EU stall data

[Dixit, Ashutosh]

On Thu, 13 Feb 2025 16:11:52 -0800, Dixit, Ashutosh wrote:
>
> On Thu, 13 Feb 2025 15:45:50 -0800, Dixit, Ashutosh wrote:
> >
> > On Thu, 13 Feb 2025 13:55:06 -0800, Harish Chegondi wrote:
> > >
> >
> > Hi Harish,
> >
> > > On Wed, Feb 12, 2025 at 10:31:15PM -0800, Dixit, Ashutosh wrote:
> > > > On Mon, 10 Feb 2025 05:46:46 -0800, Harish Chegondi wrote:
> > > > >
> > > >
> > > Hi Ashutosh,
> > > > Hi Harish,
> > > >
> > > > > If the user space doesn't read the EU stall data fast enough,
> > > > > it is possible that the EU stall data buffer can get filled,
> > > > > and if the hardware wants to write more data, it simply drops
> > > > > data due to unavailable buffer space. In that case, hardware
> > > > > sets a bit in a register. If the driver detects data drop,
> > > > > the driver read() returns -EIO error to let the user space
> > > > > know that HW has dropped data. The -EIO error is returned
> > > > > even if there is EU stall data in the buffer. A subsequent
> > > > > read by the user space returns the remaining EU stall data.
> > > > >
> > > > > v9:  Move all data drop handling code to this patch
> > > >
> > > > Good, separating out makes this easier to review. I would actually make
> > > > this the last patch, but anyway it's ok as is too.
> > > >
> > > > >      Clear all drop data bits before returning -EIO.
> > > > >
> > > > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > > > ---
> > > > >  drivers/gpu/drm/xe/xe_eu_stall.c | 39 ++++++++++++++++++++++++++++++++
> > > > >  1 file changed, 39 insertions(+)
> > > > >
> > > > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > index 53f17aac7d3b..428267010805 100644
> > > > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > @@ -53,6 +53,10 @@ struct xe_eu_stall_data_stream {
> > > > >	struct xe_gt *gt;
> > > > >	struct xe_bo *bo;
> > > > >	struct per_xecore_buf *xecore_buf;
> > > > > +	struct {
> > > > > +		bool reported_to_user;
> > > > > +		xe_dss_mask_t mask;
> > > > > +	} data_drop;
> > > > >	struct delayed_work buf_poll_work;
> > > > >	struct workqueue_struct *buf_poll_wq;
> > > > >  };
> > > > > @@ -331,12 +335,24 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > > > >			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > > > >				min_data_present = true;
> > > > >		}
> > > > > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > > > > +			set_bit(xecore, stream->data_drop.mask);
> > > > >		xecore_buf->write = write_ptr;
> > > > >		mutex_unlock(&xecore_buf->ptr_lock);
> > > > >	}
> > > > >	return min_data_present;
> > > > >  }
> > > > >
> > > > > +static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
> > > > > +{
> > > > > +	u32 write_ptr_reg;
> > > > > +
> > > > > +	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
> > > > > +	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
> > > > > +
> > > > > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
> > > > > +}
> > > > > +
> > > > >  static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > > > >				     char __user *buf, size_t count,
> > > > >				     size_t *total_data_size, struct xe_gt *gt,
> > > > > @@ -436,6 +452,22 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> > > > >	unsigned int xecore;
> > > > >	int ret = 0;
> > > > >
> > > > > +	if (bitmap_weight(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS)) {
> > > > > +		if (!stream->data_drop.reported_to_user) {
> > > > > +			for_each_dss_steering(xecore, gt, group, instance) {
> > > > > +				if (test_bit(xecore, stream->data_drop.mask)) {
> > > > > +					clear_dropped_eviction_line_bit(gt, group, instance);
> > > > > +					clear_bit(xecore, stream->data_drop.mask);
> > > > > +				}
> > > > > +			}
> > > >
> > > > This is not making any sense. How can we clear_dropped_eviction_line_bit
> > > > before reading the data? The HW will set it right back up.
> > >
> > > This bit is being cleared here because the driver has acknowledged to
> > > the user space all the data that has been dropped so far. Any new data
> > > drop after we clear the bit *should* result in another -EIO return.
> > > HW will set the bit again *only* if it drops more data. User space is
> > > expected to do another read() to clear the buffer ASAP after getting
> > > an -EIO from the first read().
> > >
> > > >
> > > > At least the code in the previous version made some sense. So we should at
> > > > least go back to that and review that. Though it also had issue with how
> > > > many times -EIO is returned etc.
> > > Can you please explain what is the issue? Every time there is a new data
> > > drop after the drop bit is cleared, it *should* result in another -EIO return
> > > The driver ensures that two successive reads will not return -EIO.
> > > >
> > > > The other issue is the locking. As I suggested in my comments on Patch 4/8,
> > > > I don't think we need a per xecore_buf lock, just one ptr_lock for reading
> > > > all the DSS's. And then we can use that here too.
> > >
> > > I used a per xecore_buf lock so that the polling function can update for
> > > example subslice 1's write pointer while read() reads the data from
> > > subslice 2. It would lead to more parallelism. With a higher granularity
> > > lock, the polling for new data blocks during read and vice versa.
>
> Why do we need this extra parallelism? I am fine with reads and polling
> being serialized. Because if we don't do this, there are instances like
> checking the drop data mask where we either take all the dss locks or don't
> take any (which is what you are advocating). This situation is solved by
> having a single lock for all dss's (I am assuming we don't need that
> extra parallelism).

About this: basically the polling thread is reading the write_ptr register
(to update its cached copy). So if we have N dss's and it takes T us to
read the register, we will block the read thread (which is doing memcpy's
which take presumably longer) will be blocked for N * T us, if we use a
single lock across dss's.

So my assumption is that even if we are blocked for N * T us, we still have
sufficient time to complete the memcpy's. And then we are ok. That is the
bandwidth of eu stall data is low enough to tolerate this extra N * T us of
lost time.

Note, we have another parameter. We run the polling thread every 10 ms and
incur this N * T us "loss" every 10 ms. If we increase this to say 20 ms,
we incur the same "loss" every 20 ms. So basically the effect of
serialization can be minimized by increasing how frequently the polling
thread runs.

It is not difficult to profile this using timestamps in ftrace you've
already introduced. It should tell us how much time it takes to complete
the memcpy's and how much time is left over, if we use a single lock across
dss's. If needed that is.

Of course on larger systems, with more dss's and which are also generating
more data, we are getting blocked longer, so that's something we need to
assess, if we are short of read bandwidth.

E.g. if T = 20 us, N = 20 dss, we will be blocked for 400 us every 10,000
us. Is that a lot? I don't know. I just made up those T and N numbers. But
a single lock also introduces the efficiency of not having to lock/unlock
constantly, so we gain some time there too. My guess is having a single
lock should be ok. But if possible, it would be nice to back this up with
some data, from ftrace.

>
> > > >
> > > > But at least let's get something sane for review first.
> > > Before I spawn another version of the patch series, I would like to
> > > list the approaches to take here and cons for each approach.
> > > Feel free to add any other approaches you suggest here. Feedback from
> > > one of the EU stall consumers that they read data even after an -EIO
> > > return means that any approach to discard data in the buffer
> > > is unacceptable.
> > >
> > > 1. Approach used in version 8:
> > >    First read() returns -EIO without clearing any drop bits
> > >    Second read() reads the data and clears the bit for each subslice
> > >    Cons: If the user space buffer is small and all subslice data is not
> > >    read, those subslices whose drop bit is not cleared can cause -EIO in
> > >    the next read(). This issue can be mitigated by user space buffer
> > >    large enough to read data from all the subslices.
> > >
> > > 2. Approach used in version 9:
> > >    First read() returns -EIO after clearing all drop bits
> > >    Second read() reads all the EU stall data that can fit into the user
> > >    buffer.
> > >    Pros: Unlike in version 8 approach, even if the user buffer is small,
> > >    all drop bits get cleared in the first read()
> > >    Cons: Because the buffers are full, if the user space doesn't call
> > >    another read() soon to clear the data, there is a higher chance of HW
> > >    dropping the data again, setting the bit again.
> > >
> > > 3. New approach: Hybrid of version 8 and 9:
> > >    First read() returns -EIO without clearing any drop bits
> > >    Second read() reads all the EU stall data that can fit into the user
> > >    buffer, but clears all the drop bits even for those subslices it
> > >    can't read the data if the user buffer can't accommodate.
> > >    Cons: For those subslices whose data buffers are full and drop bits
> > >    are cleared, there is a chance that the HW can set the bits again if
> > >    data is dropped again unless user space calls another read() fast
> > >    enough. This can also be mitigated with a user space buffer large
> > >    enough to read data from all the subslices.
> > >
> > > Please feel free to add any new approaches here that those don't discard
> > > data in the buffers, also add any more cons to the above approaches.
> > > Let's agree on an approach for the next patch version.
> >
> > Let's have some ground rules and not do random stuff. The basic ground rule
> > for me is that there is no point doing clear_dropped_eviction_line_bit,
> > till we have read the data (and moved the read pointer) to make some space
> > in the per dss buffer. Otherwise, HW will just set that bit right up. HW is
> > writing data and userspace reads cannot match the speed with which HW is
> > writing data.
> >
> > So the only approach I see viable is that in your v8. These other
> > approaches you are making up are unworkable imo. I am ok if you don't want
> > to drop data in the driver, I am not pushing that approach which I had
> > suggested. But please post something which follows the ground rule
> > mentioned above. The only thing I see which does that is v8.
> >
> > Finally, yes, it comes down to that userspace will either have to use a
> > large enough user buffer so that -EIO returns disappear. Or deal with -EIO
> > returns, ignore them etc. Or read data fast enough using a small buffer,
> > which is a bug in the current patches which we are saying we will fix after
> > merging. If they use a small buffer and see multiple -EIO returns, that's
> > fine, they just need to deal with it. The uapi is not promising anything
> > about number of -EIO returns they will see. Maybe the -EIO returns will
> > never clear up (I don't think they will till we fix the small buffer bug in
> > the patches).
>
> My approach would be to start with the stuff in v8 and then see if we can
> do something there to make sure userspace can read all data even with a
> small buffer, without seeing multiple -EIO returns till it has completed
> reading all dss's, with the assumption that the small buffer bug is not
> there (or has been fixed). Something like that. So at the minimum we start
> with the code in v8.
>
> >
> > Thanks.
> > --
> > Ashutosh
> >
> > >
> > > Thank you
> > > Harish.
> > > > > +			stream->data_drop.reported_to_user = true;
> > > > > +			xe_gt_dbg(gt, "EU stall data dropped in XeCores: %*pb\n",
> > > > > +				  XE_MAX_DSS_FUSE_BITS, stream->data_drop.mask);
> > > > > +			return -EIO;
> > > > > +		}
> > > > > +		stream->data_drop.reported_to_user = false;
> > > > > +	}
> > > > > +
> > > > >	for_each_dss_steering(xecore, gt, group, instance) {
> > > > >		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > > > >						gt, group, instance, xecore);
> > > > > @@ -457,6 +489,7 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> > > > >   * before calling read().
> > > > >   *
> > > > >   * Returns: The number of bytes copied or a negative error code on failure.
> > > > > + *	    -EIO if HW drops any EU stall data when the buffer is full.
> > > > >   */
> > > > >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > > > >				       size_t count, loff_t *ppos)
> > > > > @@ -543,6 +576,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > > >
> > > > >	for_each_dss_steering(xecore, gt, group, instance) {
> > > > >		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> > > > > +		/* Clear any drop bits set and not cleared in the previous session. */
> > > > > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > > > > +			clear_dropped_eviction_line_bit(gt, group, instance);
> > > > >		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > > > >		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
> > > > >		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > > > > @@ -554,6 +590,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > > >		xecore_buf->write = write_ptr;
> > > > >		xecore_buf->read = write_ptr;
> > > > >	}
> > > > > +	stream->data_drop.reported_to_user = false;
> > > > > +	bitmap_zero(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS);
> > > > > +
> > > > >	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
> > > > >				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
> > > > >				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> > > > > --
> > > > > 2.48.1
> > > > >

Re: [PATCH v9 5/8] drm/xe/eustall: Add support to handle dropped EU stall data

[Dixit, Ashutosh]

On Thu, 13 Feb 2025 18:05:08 -0800, Dixit, Ashutosh wrote:
>
> On Thu, 13 Feb 2025 16:11:52 -0800, Dixit, Ashutosh wrote:
> >
> > On Thu, 13 Feb 2025 15:45:50 -0800, Dixit, Ashutosh wrote:
> > >
> > > On Thu, 13 Feb 2025 13:55:06 -0800, Harish Chegondi wrote:
> > > >
> > >
> > > Hi Harish,
> > >
> > > > On Wed, Feb 12, 2025 at 10:31:15PM -0800, Dixit, Ashutosh wrote:
> > > > > On Mon, 10 Feb 2025 05:46:46 -0800, Harish Chegondi wrote:
> > > > > >
> > > > >
> > > > Hi Ashutosh,
> > > > > Hi Harish,
> > > > >
> > > > > > If the user space doesn't read the EU stall data fast enough,
> > > > > > it is possible that the EU stall data buffer can get filled,
> > > > > > and if the hardware wants to write more data, it simply drops
> > > > > > data due to unavailable buffer space. In that case, hardware
> > > > > > sets a bit in a register. If the driver detects data drop,
> > > > > > the driver read() returns -EIO error to let the user space
> > > > > > know that HW has dropped data. The -EIO error is returned
> > > > > > even if there is EU stall data in the buffer. A subsequent
> > > > > > read by the user space returns the remaining EU stall data.
> > > > > >
> > > > > > v9:  Move all data drop handling code to this patch
> > > > >
> > > > > Good, separating out makes this easier to review. I would actually make
> > > > > this the last patch, but anyway it's ok as is too.
> > > > >
> > > > > >      Clear all drop data bits before returning -EIO.
> > > > > >
> > > > > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > > > > ---
> > > > > >  drivers/gpu/drm/xe/xe_eu_stall.c | 39 ++++++++++++++++++++++++++++++++
> > > > > >  1 file changed, 39 insertions(+)
> > > > > >
> > > > > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > > index 53f17aac7d3b..428267010805 100644
> > > > > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > > @@ -53,6 +53,10 @@ struct xe_eu_stall_data_stream {
> > > > > >	struct xe_gt *gt;
> > > > > >	struct xe_bo *bo;
> > > > > >	struct per_xecore_buf *xecore_buf;
> > > > > > +	struct {
> > > > > > +		bool reported_to_user;
> > > > > > +		xe_dss_mask_t mask;
> > > > > > +	} data_drop;
> > > > > >	struct delayed_work buf_poll_work;
> > > > > >	struct workqueue_struct *buf_poll_wq;
> > > > > >  };
> > > > > > @@ -331,12 +335,24 @@ static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > > > > >			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > > > > >				min_data_present = true;
> > > > > >		}
> > > > > > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > > > > > +			set_bit(xecore, stream->data_drop.mask);
> > > > > >		xecore_buf->write = write_ptr;
> > > > > >		mutex_unlock(&xecore_buf->ptr_lock);
> > > > > >	}
> > > > > >	return min_data_present;
> > > > > >  }
> > > > > >
> > > > > > +static void clear_dropped_eviction_line_bit(struct xe_gt *gt, u16 group, u16 instance)
> > > > > > +{
> > > > > > +	u32 write_ptr_reg;
> > > > > > +
> > > > > > +	/* On PVC, the overflow bit has to be cleared by writing 1 to it. */
> > > > > > +	write_ptr_reg = _MASKED_BIT_ENABLE(XEHPC_EUSTALL_REPORT_OVERFLOW_DROP);
> > > > > > +
> > > > > > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT, write_ptr_reg, group, instance);
> > > > > > +}
> > > > > > +
> > > > > >  static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > > > > >				     char __user *buf, size_t count,
> > > > > >				     size_t *total_data_size, struct xe_gt *gt,
> > > > > > @@ -436,6 +452,22 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> > > > > >	unsigned int xecore;
> > > > > >	int ret = 0;
> > > > > >
> > > > > > +	if (bitmap_weight(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS)) {
> > > > > > +		if (!stream->data_drop.reported_to_user) {
> > > > > > +			for_each_dss_steering(xecore, gt, group, instance) {
> > > > > > +				if (test_bit(xecore, stream->data_drop.mask)) {
> > > > > > +					clear_dropped_eviction_line_bit(gt, group, instance);
> > > > > > +					clear_bit(xecore, stream->data_drop.mask);
> > > > > > +				}
> > > > > > +			}
> > > > >
> > > > > This is not making any sense. How can we clear_dropped_eviction_line_bit
> > > > > before reading the data? The HW will set it right back up.
> > > >
> > > > This bit is being cleared here because the driver has acknowledged to
> > > > the user space all the data that has been dropped so far. Any new data
> > > > drop after we clear the bit *should* result in another -EIO return.
> > > > HW will set the bit again *only* if it drops more data. User space is
> > > > expected to do another read() to clear the buffer ASAP after getting
> > > > an -EIO from the first read().
> > > >
> > > > >
> > > > > At least the code in the previous version made some sense. So we should at
> > > > > least go back to that and review that. Though it also had issue with how
> > > > > many times -EIO is returned etc.
> > > > Can you please explain what is the issue? Every time there is a new data
> > > > drop after the drop bit is cleared, it *should* result in another -EIO return
> > > > The driver ensures that two successive reads will not return -EIO.
> > > > >
> > > > > The other issue is the locking. As I suggested in my comments on Patch 4/8,
> > > > > I don't think we need a per xecore_buf lock, just one ptr_lock for reading
> > > > > all the DSS's. And then we can use that here too.
> > > >
> > > > I used a per xecore_buf lock so that the polling function can update for
> > > > example subslice 1's write pointer while read() reads the data from
> > > > subslice 2. It would lead to more parallelism. With a higher granularity
> > > > lock, the polling for new data blocks during read and vice versa.
> >
> > Why do we need this extra parallelism? I am fine with reads and polling
> > being serialized. Because if we don't do this, there are instances like
> > checking the drop data mask where we either take all the dss locks or don't
> > take any (which is what you are advocating). This situation is solved by
> > having a single lock for all dss's (I am assuming we don't need that
> > extra parallelism).
>
> About this: basically the polling thread is reading the write_ptr register
> (to update its cached copy). So if we have N dss's and it takes T us to
> read the register, we will block the read thread (which is doing memcpy's
> which take presumably longer) will be blocked for N * T us, if we use a
> single lock across dss's.
>
> So my assumption is that even if we are blocked for N * T us, we still have
> sufficient time to complete the memcpy's. And then we are ok. That is the
> bandwidth of eu stall data is low enough to tolerate this extra N * T us of
> lost time.
>
> Note, we have another parameter. We run the polling thread every 10 ms and
> incur this N * T us "loss" every 10 ms. If we increase this to say 20 ms,
> we incur the same "loss" every 20 ms. So basically the effect of
> serialization can be minimized by increasing how frequently the polling
> thread runs.
>
> It is not difficult to profile this using timestamps in ftrace you've
> already introduced. It should tell us how much time it takes to complete
> the memcpy's and how much time is left over, if we use a single lock across
> dss's. If needed that is.
>
> Of course on larger systems, with more dss's and which are also generating
> more data, we are getting blocked longer, so that's something we need to
> assess, if we are short of read bandwidth.
>
> E.g. if T = 20 us, N = 20 dss, we will be blocked for 400 us every 10,000
> us. Is that a lot? I don't know. I just made up those T and N numbers. But
> a single lock also introduces the efficiency of not having to lock/unlock
> constantly, so we gain some time there too. My guess is having a single
> lock should be ok. But if possible, it would be nice to back this up with
> some data, from ftrace.

If you don't want to do this now, you can leave in the per dss locks, at
least for the next version of this series. Then we can look at the dropped
data handling and decide if accessing data_drop.mask without taking the
locks is ok or not.

But some time we should assess if these per dss locks are actually needed
or not. All we need to see is how much time is spent in doing the
reads. Which will tell us how much time is left over and whether we can
afford to lose that time if we serialize the polling and reading.

>
> >
> > > > >
> > > > > But at least let's get something sane for review first.
> > > > Before I spawn another version of the patch series, I would like to
> > > > list the approaches to take here and cons for each approach.
> > > > Feel free to add any other approaches you suggest here. Feedback from
> > > > one of the EU stall consumers that they read data even after an -EIO
> > > > return means that any approach to discard data in the buffer
> > > > is unacceptable.
> > > >
> > > > 1. Approach used in version 8:
> > > >    First read() returns -EIO without clearing any drop bits
> > > >    Second read() reads the data and clears the bit for each subslice
> > > >    Cons: If the user space buffer is small and all subslice data is not
> > > >    read, those subslices whose drop bit is not cleared can cause -EIO in
> > > >    the next read(). This issue can be mitigated by user space buffer
> > > >    large enough to read data from all the subslices.
> > > >
> > > > 2. Approach used in version 9:
> > > >    First read() returns -EIO after clearing all drop bits
> > > >    Second read() reads all the EU stall data that can fit into the user
> > > >    buffer.
> > > >    Pros: Unlike in version 8 approach, even if the user buffer is small,
> > > >    all drop bits get cleared in the first read()
> > > >    Cons: Because the buffers are full, if the user space doesn't call
> > > >    another read() soon to clear the data, there is a higher chance of HW
> > > >    dropping the data again, setting the bit again.
> > > >
> > > > 3. New approach: Hybrid of version 8 and 9:
> > > >    First read() returns -EIO without clearing any drop bits
> > > >    Second read() reads all the EU stall data that can fit into the user
> > > >    buffer, but clears all the drop bits even for those subslices it
> > > >    can't read the data if the user buffer can't accommodate.
> > > >    Cons: For those subslices whose data buffers are full and drop bits
> > > >    are cleared, there is a chance that the HW can set the bits again if
> > > >    data is dropped again unless user space calls another read() fast
> > > >    enough. This can also be mitigated with a user space buffer large
> > > >    enough to read data from all the subslices.
> > > >
> > > > Please feel free to add any new approaches here that those don't discard
> > > > data in the buffers, also add any more cons to the above approaches.
> > > > Let's agree on an approach for the next patch version.
> > >
> > > Let's have some ground rules and not do random stuff. The basic ground rule
> > > for me is that there is no point doing clear_dropped_eviction_line_bit,
> > > till we have read the data (and moved the read pointer) to make some space
> > > in the per dss buffer. Otherwise, HW will just set that bit right up. HW is
> > > writing data and userspace reads cannot match the speed with which HW is
> > > writing data.
> > >
> > > So the only approach I see viable is that in your v8. These other
> > > approaches you are making up are unworkable imo. I am ok if you don't want
> > > to drop data in the driver, I am not pushing that approach which I had
> > > suggested. But please post something which follows the ground rule
> > > mentioned above. The only thing I see which does that is v8.
> > >
> > > Finally, yes, it comes down to that userspace will either have to use a
> > > large enough user buffer so that -EIO returns disappear. Or deal with -EIO
> > > returns, ignore them etc. Or read data fast enough using a small buffer,
> > > which is a bug in the current patches which we are saying we will fix after
> > > merging. If they use a small buffer and see multiple -EIO returns, that's
> > > fine, they just need to deal with it. The uapi is not promising anything
> > > about number of -EIO returns they will see. Maybe the -EIO returns will
> > > never clear up (I don't think they will till we fix the small buffer bug in
> > > the patches).
> >
> > My approach would be to start with the stuff in v8 and then see if we can
> > do something there to make sure userspace can read all data even with a
> > small buffer, without seeing multiple -EIO returns till it has completed
> > reading all dss's, with the assumption that the small buffer bug is not
> > there (or has been fixed). Something like that. So at the minimum we start
> > with the code in v8.
> >
> > >
> > > Thanks.
> > > --
> > > Ashutosh
> > >
> > > >
> > > > Thank you
> > > > Harish.
> > > > > > +			stream->data_drop.reported_to_user = true;
> > > > > > +			xe_gt_dbg(gt, "EU stall data dropped in XeCores: %*pb\n",
> > > > > > +				  XE_MAX_DSS_FUSE_BITS, stream->data_drop.mask);
> > > > > > +			return -EIO;
> > > > > > +		}
> > > > > > +		stream->data_drop.reported_to_user = false;
> > > > > > +	}
> > > > > > +
> > > > > >	for_each_dss_steering(xecore, gt, group, instance) {
> > > > > >		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > > > > >						gt, group, instance, xecore);
> > > > > > @@ -457,6 +489,7 @@ static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *st
> > > > > >   * before calling read().
> > > > > >   *
> > > > > >   * Returns: The number of bytes copied or a negative error code on failure.
> > > > > > + *	    -EIO if HW drops any EU stall data when the buffer is full.
> > > > > >   */
> > > > > >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > > > > >				       size_t count, loff_t *ppos)
> > > > > > @@ -543,6 +576,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > > > >
> > > > > >	for_each_dss_steering(xecore, gt, group, instance) {
> > > > > >		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT, group, instance);
> > > > > > +		/* Clear any drop bits set and not cleared in the previous session. */
> > > > > > +		if (write_ptr_reg & XEHPC_EUSTALL_REPORT_OVERFLOW_DROP)
> > > > > > +			clear_dropped_eviction_line_bit(gt, group, instance);
> > > > > >		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > > > > >		read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, write_ptr);
> > > > > >		read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > > > > > @@ -554,6 +590,9 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > > > >		xecore_buf->write = write_ptr;
> > > > > >		xecore_buf->read = write_ptr;
> > > > > >	}
> > > > > > +	stream->data_drop.reported_to_user = false;
> > > > > > +	bitmap_zero(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS);
> > > > > > +
> > > > > >	reg_value = _MASKED_FIELD(EUSTALL_MOCS | EUSTALL_SAMPLE_RATE,
> > > > > >				  REG_FIELD_PREP(EUSTALL_MOCS, gt->mocs.uc_index << 1) |
> > > > > >				  REG_FIELD_PREP(EUSTALL_SAMPLE_RATE,
> > > > > > --
> > > > > > 2.48.1
> > > > > >

Re: [PATCH v9 4/8] drm/xe/eustall: Add support to read() and poll() EU stall data

[Harish Chegondi]

On Wed, Feb 12, 2025 at 11:02:07AM -0800, Dixit, Ashutosh wrote:
> On Mon, 10 Feb 2025 05:46:45 -0800, Harish Chegondi wrote:
> >
> 
Hi Ashutosh,
> Hi Harish,
> 
> > Implement the EU stall sampling APIs to read() and poll() EU stall data.
> > A work function periodically polls the EU stall data buffer write pointer
> > registers to look for any new data and caches the write pointer. The read
> > function compares the cached read and write pointers and copies any new
> > data to the user space.
> >
> > v9:  New patch split from the previous patch.
> >      Used *_delayed_work functions instead of hrtimer
> >      Addressed the review feedback in read and poll functions
> >
> > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > ---
> >  drivers/gpu/drm/xe/xe_eu_stall.c | 267 ++++++++++++++++++++++++++++++-
> >  drivers/gpu/drm/xe/xe_trace.h    |  33 ++++
> >  2 files changed, 298 insertions(+), 2 deletions(-)
> >
> > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > index 12afa9720971..53f17aac7d3b 100644
> > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > @@ -21,6 +21,7 @@
> >  #include "xe_macros.h"
> >  #include "xe_observation.h"
> >  #include "xe_pm.h"
> > +#include "xe_trace.h"
> >
> >  #include "regs/xe_eu_stall_regs.h"
> >  #include "regs/xe_gt_regs.h"
> > @@ -41,7 +42,9 @@ struct per_xecore_buf {
> >  };
> >
> >  struct xe_eu_stall_data_stream {
> > +	bool pollin;
> >	bool enabled;
> > +	wait_queue_head_t poll_wq;
> >	size_t data_record_size;
> >	size_t per_xecore_buf_size;
> >	unsigned int wait_num_reports;
> > @@ -50,6 +53,8 @@ struct xe_eu_stall_data_stream {
> >	struct xe_gt *gt;
> >	struct xe_bo *bo;
> >	struct per_xecore_buf *xecore_buf;
> > +	struct delayed_work buf_poll_work;
> > +	struct workqueue_struct *buf_poll_wq;
> >  };
> >
> >  struct xe_eu_stall_gt {
> > @@ -256,6 +261,190 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> >	return 0;
> >  }
> >
> > +/**
> > + * buf_data_size - Calculate the number of bytes in a circular buffer
> > + *		   given the read and write pointers and the size of
> > + *		   the buffer.
> > + *
> > + * @buf_size: Size of the circular buffer
> > + * @read_ptr: Read pointer with an additional overflow bit
> > + * @write_ptr: Write pointer with an additional overflow bit
> > + *
> > + * Since the read and write pointers have an additional overflow bit,
> > + * this function calculates the offsets from the pointers and use the
> > + * offsets to calculate the data size in the buffer.
> > + *
> > + * Returns: number of bytes of data in the buffer
> > + */
> > +static u32 buf_data_size(size_t buf_size, u32 read_ptr, u32 write_ptr)
> > +{
> > +	u32 read_offset, write_offset, size = 0;
> > +
> > +	if (read_ptr == write_ptr)
> > +		goto exit;
> > +
> > +	read_offset = read_ptr & (buf_size - 1);
> > +	write_offset = write_ptr & (buf_size - 1);
> > +
> > +	if (write_offset > read_offset)
> > +		size = write_offset - read_offset;
> > +	else
> > +		size = buf_size - read_offset + write_offset;
> > +exit:
> > +	return size;
> > +}
> 
> Looks good now :)
> 
> > +
> > +/**
> > + * eu_stall_data_buf_poll - Poll for EU stall data in the buffer.
> > + *
> > + * @stream: xe EU stall data stream instance
> > + *
> > + * Returns: true if the EU stall buffer contains minimum stall data as
> > + *	    specified by the event report count, else false.
> > + */
> > +static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > +{
> > +	u32 read_ptr, write_ptr_reg, write_ptr, total_data = 0;
> > +	u32 buf_size = stream->per_xecore_buf_size;
> > +	struct per_xecore_buf *xecore_buf;
> > +	struct xe_gt *gt = stream->gt;
> > +	bool min_data_present = false;
> > +	u16 group, instance;
> > +	unsigned int xecore;
> 
> u32 and move above to u32 line?
> 
> > +
> > +	for_each_dss_steering(xecore, gt, group, instance) {
> > +		xecore_buf = &stream->xecore_buf[xecore];
> > +		mutex_lock(&xecore_buf->ptr_lock);
> 
> One thing I am wondering about is: do we really need these per xecore_buf
> locks? How about moving ptr_lock into xe_eu_stall_data_stream and just
> cover for_each_dss_steering() calls with the ptr lock. Because the polling
> thread runs every 10 ms, this should give plenty of time for the polling
> thread and the reads to go through, even with lcontention. And it will
> eliminate all these locks and the locking/unlocking overhead.

I used a per dss lock so that polling and read on two different
subslices can be done in parallel. I will try moving the ptr_lock into 
xe_eu_stall_data_stream.
> 
> > +		read_ptr = xecore_buf->read;
> > +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT,
> > +						       group, instance);
> > +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > +		write_ptr <<= 6;
> > +		write_ptr &= ((buf_size << 1) - 1);
> > +		if (write_ptr != read_ptr && !min_data_present) {
> 
> Don't need to check for 'write_ptr != read_ptr' here, it's already
> happening in buf_data_size.

Yes it is not needed. But eu_stall_data_buf_poll() is invoked approx every 10ms.
I am not an expert on compiler optimizations. If the compiler definitely
optimizes and prevents call to buf_data_size(), I can remove this check.
But if the compiler doesn't optimize, wouldn't this check help avoid
function calls given that this function gets executed every 10ms?
> 
> > +			total_data += buf_data_size(buf_size, read_ptr, write_ptr);
> > +			/*
> > +			 * Check if there are at least minimum number of stall data
> > +			 * rows for poll() to indicate that the data is present.
> > +			 * Each stall data row is 64B (cacheline size).
> > +			 */
> 
> I'd say this comment is not needed and should be removed, the code below is
> clear enough.
Will remove.
> 
> > +			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > +				min_data_present = true;
> > +		}
> > +		xecore_buf->write = write_ptr;
> > +		mutex_unlock(&xecore_buf->ptr_lock);
> > +	}
> > +	return min_data_present;
> > +}
> > +
> > +static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > +				     char __user *buf, size_t count,
> > +				     size_t *total_data_size, struct xe_gt *gt,
> > +				     u16 group, u16 instance, unsigned int xecore)
> > +{
> > +	size_t read_data_size, copy_size, buf_size, data_record_size;
> > +	u32 read_ptr_reg, read_ptr, write_ptr;
> > +	u8 *xecore_start_vaddr, *read_vaddr;
> > +	struct per_xecore_buf *xecore_buf;
> > +	u32 read_offset, write_offset;
> > +	int ret = 0;
> > +
> > +	/* Hardware increments the read and write pointers such that they can
> > +	 * overflow into one additional bit. For example, a 256KB size buffer
> > +	 * offset pointer needs 18 bits. But HW uses 19 bits for the read and
> > +	 * write pointers. This technique avoids wasting a slot in the buffer.
> > +	 * Read and write offsets are calculated from the pointers in order to
> > +	 * check if the write pointer has wrapped around the array.
> > +	 */
> > +	xecore_buf = &stream->xecore_buf[xecore];
> > +	mutex_lock(&xecore_buf->ptr_lock);
> > +	xecore_start_vaddr = xecore_buf->vaddr;
> > +	read_ptr = xecore_buf->read;
> > +	write_ptr = xecore_buf->write;
> > +	buf_size = stream->per_xecore_buf_size;
> > +	data_record_size = stream->data_record_size;l> > +
> > +	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> > +	/* Read only the data that the user space buffer can accommodate */
> > +	if ((*total_data_size + read_data_size) > count) {
> > +		read_data_size = count - *total_data_size;
> > +		read_data_size = (read_data_size / data_record_size) * data_record_size;
> > +	}
> 
> As I said, my preferred way of writing this is as follows. Isn't this cleaner?

Most of the times, the if condition would evaluate false and the body of
the if statement would not be executed. Whereas in your code the two
lines of code get executed all the time. 
> 
> 	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> 	XE_WARN_ON(count >= *total_size);
Wouldn't count (size of the user buffer) be greater than the total_size
most of the time? I am still not convinced with having a WARN_ON here.
> 	read_data_size = min_t(size_t, count - *total_size, read_data_size);
> 	read_data_size = ALIGN_DOWN(read_data_size, data_record_size);
> 
> Since data_record_size has to be a power of 2 for this to work (which it
> is), I would even put a
data_record_size is fixed in the hardware. As of now for both PVC and
xe2, it is 64 which is a power of 2. I am guessing that it will remain a
power of 2 in the future too. Why should we put an assert for the record
size which is determined in the hardware?
> 
> 	xe_assert(xe, is_power_of_2(record_size));
> 
> in xe_eu_stall_data_record_size().
> 
> 
> > +	if (read_data_size == 0)
> > +		goto exit;
> > +
> > +	read_offset = read_ptr & (buf_size - 1);
> > +	write_offset = write_ptr & (buf_size - 1);
> > +	read_vaddr = xecore_start_vaddr + read_offset;
> > +
> > +	if (write_offset > read_offset) {
> > +		if (copy_to_user((buf + *total_data_size), read_vaddr, read_data_size)) {
> 
> internal brackets not needed     ^
> 
> > +			ret = -EFAULT;
> > +			goto exit;
> > +		}
> > +	} else {
> > +		if (read_data_size >= (buf_size - read_offset))
> 
> internal brackets not needed          ^
> 
> > +			copy_size = buf_size - read_offset;
> > +		else
> > +			copy_size = read_data_size;
> 
> if (write_offset < read_offset) how is this 'else' ever possible? So
> shouldn't copy_size just be set unconditionally to 'buf_size -
> read_offset'?
If the user buffer doesn't have enough space to accommodate
(buf_size - read_offset) bytes, the else will get executed.
> 
> > +		if (copy_to_user((buf + *total_data_size), read_vaddr, copy_size)) {
> 
> internal brackets not needed     ^
> 
> > +			ret = -EFAULT;
> > +			goto exit;
> > +		}
> > +		if (copy_to_user((buf + *total_data_size + copy_size),
> 
> internal brackets not needed     ^
> 
> > +				 xecore_start_vaddr, read_data_size - copy_size)) {
> > +			ret = -EFAULT;
> > +			goto exit;
> > +		}
> > +	}
> > +
> > +	*total_data_size += read_data_size;
> > +	read_ptr += read_data_size;
> 
> Because there is an overflow bit we can just add without worrying about
> wraparound?
I want to make sure only one overflow bit is used and doesn't overflow
into the second bit.
> 
> > +
> > +	/* Read pointer can overflow into one additional bit */
> > +	read_ptr &= (buf_size << 1) - 1;
> > +	read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, (read_ptr >> 6));
> > +	read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> > +	xecore_buf->read = read_ptr;
> > +	trace_xe_eu_stall_data_read(group, instance, read_ptr, write_ptr,
> > +				    read_offset, write_offset, *total_data_size);
> > +exit:
> > +	mutex_unlock(&xecore_buf->ptr_lock);
> > +	return ret;
> > +}
> > +
> > +/**
> > + * xe_eu_stall_stream_read_locked - copy EU stall counters data from the
> > + *				    per xecore buffers to the userspace buffer
> > + * @stream: A stream opened for EU stall count metrics
> > + * @file: An xe EU stall data stream file
> > + * @buf: destination buffer given by userspace
> > + * @count: the number of bytes userspace wants to read
> > + *
> > + * Returns: Number of bytes copied or a negative error code
> > + * If we've successfully copied any data then reporting that takes
> > + * precedence over any internal error status, so the data isn't lost.
> > + */
> > +static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *stream,
> > +					      struct file *file, char __user *buf,
> > +					      size_t count)
> > +{
> > +	struct xe_gt *gt = stream->gt;
> > +	size_t total_size = 0;
> > +	u16 group, instance;
> > +	unsigned int xecore;
> > +	int ret = 0;
> > +
> > +	for_each_dss_steering(xecore, gt, group, instance) {
> > +		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > +						gt, group, instance, xecore);
> > +		if (ret || count == total_size)
> > +			break;
> > +	}
> > +	return total_size ?: (ret ?: -EAGAIN);
> > +}
> > +
> >  /**
> >   * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> >   *
> > @@ -272,7 +461,35 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> >				       size_t count, loff_t *ppos)
> >  {
> > -	ssize_t ret = 0;
> > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > +	struct xe_gt *gt = stream->gt;
> > +	ssize_t ret;
> > +
> > +	if (count == 0)
> > +		return -EINVAL;
> 
> I believe we need to also handle the fact that count might not be a
> multiple of record_size. The easiest way to handle this seems to be right
> here:
> 	ssize_t aligned_count = ALIGN_DOWN(count, stream->data_record_size);
I think the code handles buffer sizes that are not multiples of record
size. Copying few lines of code below. Wouldn't read_data_size be only a
multiple of record size ? and leave any remaining space empty that is
not a multiple of record size ?
/* Read only the data that the user space buffer can accommodate */
if ((*total_data_size + read_data_size) > count) {
	read_data_size = count - *total_data_size;
	read_data_size = (read_data_size / data_record_size) * data_record_size;

> 
> And used aligned_count rather than count in xe_eu_stall_stream_read_locked
> calls. So that we don't have to worry about this in later function calls.
> 
> So above will become:
> 
> 	if (aligned_count == 0)
> 		return -EINVAL;
> 
> Unless there is a minimum user buffer size we want to support, in that case
> this becomes:
> 
> 	if (aligned_count < minimum_user_buffer_size)
> 		return -EINVAL;
> 
> But to me looks like a good value for minimum_user_buffer_size is not
> available.
I guess the minimum user buffer size should be the data record size (64
for PVC and Xe2)? If smaller than the record size, the drive will be
unable to copy any data.
> 
> Anyway, better to handle this degenerate case here itself.
> 
> > +
> > +	if (!stream->enabled) {
> > +		xe_gt_dbg(gt, "EU stall data stream not enabled to read\n");
> > +		return -EINVAL;
> > +	}
> > +
> > +	if (!(file->f_flags & O_NONBLOCK)) {
> > +		do {
> > +			ret = wait_event_interruptible(stream->poll_wq, stream->pollin);
> > +			if (ret)
> > +				return -EINTR;
> > +
> > +			mutex_lock(&gt->eu_stall->stream_lock);
> > +			ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > +			mutex_unlock(&gt->eu_stall->stream_lock);
> > +		} while (ret == -EAGAIN);
> > +	} else {
> > +		mutex_lock(&gt->eu_stall->stream_lock);
> > +		ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > +		mutex_unlock(&gt->eu_stall->stream_lock);
> > +	}
> > +
> > +	stream->pollin = false;
> 
> Carry over comment from previous rev: this breaks if user buffer is smaller
> than available data. But this is a corner case so let's fix this after the
> initial merge.
I will check your fix in OA to better understand the problem here. If
the user buffer is smaller than data record size, it just returns
without copying any data. 
> 
> Let's put it a list of to be done's in the cover letter to do after we
> merge in the next revision.
Okay.
> 
> >
> >	return ret;
> >  }
> > @@ -281,6 +498,7 @@ static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
> >  {
> >	if (stream->bo)
> >		xe_bo_unpin_map_no_vm(stream->bo);
> > +	destroy_workqueue(stream->buf_poll_wq);
> 
> Don't put this here in free_eu_stall_data_buf, put this in the caller of
> this function, like the destroy/close function.
> 
> >  }
> >
> >  static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> > @@ -351,6 +569,21 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> >	return 0;
> >  }
> >
> > +static void eu_stall_data_buf_poll_work_fn(struct work_struct *work)
> > +{
> > +	struct xe_eu_stall_data_stream *stream =
> > +		container_of(work, typeof(*stream), buf_poll_work.work);
> > +
> > +	if (eu_stall_data_buf_poll(stream)) {
> > +		stream->pollin = true;
> > +		wake_up(&stream->poll_wq);
> > +	}
> > +	if (stream->enabled)
> 
> See comment at xe_eu_stall_disable_locked. If we do
> cancel_delayed_work_sync there, I think this stream->enabled check might
I will explain later why I used flush_delayed_work() instead of 
cancel_delayed_work_sync()
> not be needed here. Also see comments at cancel_work_sync in
> kernel/workqueue.c.
> 
> Could you please check and see if it works out. xe_guc_ct.c (and
> xe_gt_tlb_invalidation.c) seem to be doing that.
> 
> > +		queue_delayed_work(stream->buf_poll_wq,
> > +				   &stream->buf_poll_work,
> > +				   msecs_to_jiffies(POLL_PERIOD_MS));
> > +}
> > +
> >  static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> >				   struct eu_stall_open_properties *props)
> >  {
> > @@ -361,6 +594,11 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> >	u32 vaddr_offset;
> >	int ret, xecore;
> >
> > +	init_waitqueue_head(&stream->poll_wq);
> > +	INIT_DELAYED_WORK(&stream->buf_poll_work, eu_stall_data_buf_poll_work_fn);
> > +	stream->buf_poll_wq = alloc_ordered_workqueue("xe_eu_stall", 0);
> > +	if (!stream->buf_poll_wq)
> > +		return -ENOMEM;
> 
> Now we also need to destroy_workqueue during error unwinding (see comments
> regarding this in Patch 3).
> 
> >	stream->sampling_rate_mult = props->sampling_rate_mult;
> >	stream->wait_num_reports = props->wait_num_reports;
> >	stream->per_xecore_buf_size = per_xecore_buf_size;
> > @@ -391,6 +629,19 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> >	return 0;
> >  }
> >
> > +static __poll_t xe_eu_stall_stream_poll_locked(struct xe_eu_stall_data_stream *stream,
> > +					       struct file *file, poll_table *wait)
> > +{
> > +	__poll_t events = 0;
> > +
> > +	poll_wait(file, &stream->poll_wq, wait);
> > +
> > +	if (stream->pollin)
> > +		events |= EPOLLIN;
> > +
> > +	return events;
> > +}
> > +
> >  /**
> >   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> >   *
> > @@ -401,7 +652,13 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> >   */
> >  static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> >  {
> > -	__poll_t ret = 0;
> > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > +	struct xe_gt *gt = stream->gt;
> > +	__poll_t ret;
> > +
> > +	mutex_lock(&gt->eu_stall->stream_lock);
> > +	ret = xe_eu_stall_stream_poll_locked(stream, file, wait);
> > +	mutex_unlock(&gt->eu_stall->stream_lock);
> >
> >	return ret;
> >  }
> > @@ -416,6 +673,9 @@ static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
> >	stream->enabled = true;
> >
> >	ret = xe_eu_stall_stream_enable(stream);
> > +	queue_delayed_work(stream->buf_poll_wq,
> 
> A blank line before this line would be nice.
> 
> > +			   &stream->buf_poll_work,
> > +			   msecs_to_jiffies(POLL_PERIOD_MS));
> >	return ret;
> >  }
> >
> > @@ -429,6 +689,9 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
> >	stream->enabled = false;
> >
> >	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> > +	/* Check for any new EU stall data one last time */
> > +	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);
> 
> I am not sure if this is needed, especially if we use
> cancel_delayed_work_sync.
There was an ask from the user space to check for new data once after
disabling EU stall sampling to make sure we capture all the data.
> 
> > +	flush_delayed_work(&stream->buf_poll_work);
> 
> I think here we should use cancel_delayed_work_sync() instead. See
> e.g. xe_guc_ct.c (and also maybe xe_gt_tlb_invalidation.c).
I though about it and found that the difference between
flushed_delayed_work() and cancel_delayed_work_sync() is that
cancel_delayed_work_sync() cancels any pending work items and wait for
any work under execution to complete. Whereas flushed_delayed_work()
schedules any work pending and wait for it to complete. Since I want to
execute the work one last time after disable, flushed_delayed_work()
is more appropriate here than cancel_delayed_work_sync().

Thank You
Harish.

> 
> >
> >	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> >	xe_pm_runtime_put(gt_to_xe(gt));
> > diff --git a/drivers/gpu/drm/xe/xe_trace.h b/drivers/gpu/drm/xe/xe_trace.h
> > index d5281de04d54..1cc6bfc34ccb 100644
> > --- a/drivers/gpu/drm/xe/xe_trace.h
> > +++ b/drivers/gpu/drm/xe/xe_trace.h
> > @@ -427,6 +427,39 @@ DEFINE_EVENT(xe_pm_runtime, xe_pm_runtime_get_ioctl,
> >	     TP_ARGS(xe, caller)
> >  );
> >
> > +TRACE_EVENT(xe_eu_stall_data_read,
> > +	    TP_PROTO(u8 slice, u8 subslice,
> > +		     u32 read_ptr, u32 write_ptr,
> > +		     u32 read_offset, u32 write_offset,
> > +		     size_t total_size),
> > +	    TP_ARGS(slice, subslice, read_ptr, write_ptr,
> > +		    read_offset, write_offset, total_size),
> > +
> > +	    TP_STRUCT__entry(__field(u8, slice)
> > +			     __field(u8, subslice)
> > +			     __field(u32, read_ptr)
> > +			     __field(u32, write_ptr)
> > +			     __field(u32, read_offset)
> > +			     __field(u32, write_offset)
> > +			     __field(size_t, total_size)
> > +			     ),
> > +
> > +	    TP_fast_assign(__entry->slice = slice;
> > +			   __entry->subslice = subslice;
> > +			   __entry->read_ptr = read_ptr;
> > +			   __entry->write_ptr = write_ptr;
> > +			   __entry->read_offset = read_offset;
> > +			   __entry->write_offset = write_offset;
> > +			   __entry->total_size = total_size;
> > +			   ),
> > +
> > +	    TP_printk("slice:%u subslice:%u readptr:0x%x writeptr:0x%x read off:%u write off:%u size:%zu ",
> > +		      __entry->slice, __entry->subslice,
> > +		      __entry->read_ptr, __entry->write_ptr,
> > +		      __entry->read_offset, __entry->write_offset,
> > +		      __entry->total_size)
> > +);
> > +
> >  #endif
> >
> >  /* This part must be outside protection */
> > --
> > 2.48.1
> >

Re: [PATCH v9 4/8] drm/xe/eustall: Add support to read() and poll() EU stall data

[Dixit, Ashutosh]

On Thu, 13 Feb 2025 23:51:54 -0800, Harish Chegondi wrote:
>

Hi Harish,

> On Wed, Feb 12, 2025 at 11:02:07AM -0800, Dixit, Ashutosh wrote:
> > On Mon, 10 Feb 2025 05:46:45 -0800, Harish Chegondi wrote:
> > >
> >
> > > Implement the EU stall sampling APIs to read() and poll() EU stall data.
> > > A work function periodically polls the EU stall data buffer write pointer
> > > registers to look for any new data and caches the write pointer. The read
> > > function compares the cached read and write pointers and copies any new
> > > data to the user space.
> > >
> > > v9:  New patch split from the previous patch.
> > >      Used *_delayed_work functions instead of hrtimer
> > >      Addressed the review feedback in read and poll functions
> > >
> > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > ---
> > >  drivers/gpu/drm/xe/xe_eu_stall.c | 267 ++++++++++++++++++++++++++++++-
> > >  drivers/gpu/drm/xe/xe_trace.h    |  33 ++++
> > >  2 files changed, 298 insertions(+), 2 deletions(-)
> > >
> > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > index 12afa9720971..53f17aac7d3b 100644
> > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > @@ -21,6 +21,7 @@
> > >  #include "xe_macros.h"
> > >  #include "xe_observation.h"
> > >  #include "xe_pm.h"
> > > +#include "xe_trace.h"
> > >
> > >  #include "regs/xe_eu_stall_regs.h"
> > >  #include "regs/xe_gt_regs.h"
> > > @@ -41,7 +42,9 @@ struct per_xecore_buf {
> > >  };
> > >
> > >  struct xe_eu_stall_data_stream {
> > > +	bool pollin;
> > >	bool enabled;
> > > +	wait_queue_head_t poll_wq;
> > >	size_t data_record_size;
> > >	size_t per_xecore_buf_size;
> > >	unsigned int wait_num_reports;
> > > @@ -50,6 +53,8 @@ struct xe_eu_stall_data_stream {
> > >	struct xe_gt *gt;
> > >	struct xe_bo *bo;
> > >	struct per_xecore_buf *xecore_buf;
> > > +	struct delayed_work buf_poll_work;
> > > +	struct workqueue_struct *buf_poll_wq;
> > >  };
> > >
> > >  struct xe_eu_stall_gt {
> > > @@ -256,6 +261,190 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > >	return 0;
> > >  }
> > >
> > > +/**
> > > + * buf_data_size - Calculate the number of bytes in a circular buffer
> > > + *		   given the read and write pointers and the size of
> > > + *		   the buffer.
> > > + *
> > > + * @buf_size: Size of the circular buffer
> > > + * @read_ptr: Read pointer with an additional overflow bit
> > > + * @write_ptr: Write pointer with an additional overflow bit
> > > + *
> > > + * Since the read and write pointers have an additional overflow bit,
> > > + * this function calculates the offsets from the pointers and use the
> > > + * offsets to calculate the data size in the buffer.
> > > + *
> > > + * Returns: number of bytes of data in the buffer
> > > + */
> > > +static u32 buf_data_size(size_t buf_size, u32 read_ptr, u32 write_ptr)
> > > +{
> > > +	u32 read_offset, write_offset, size = 0;
> > > +
> > > +	if (read_ptr == write_ptr)
> > > +		goto exit;
> > > +
> > > +	read_offset = read_ptr & (buf_size - 1);
> > > +	write_offset = write_ptr & (buf_size - 1);
> > > +
> > > +	if (write_offset > read_offset)
> > > +		size = write_offset - read_offset;
> > > +	else
> > > +		size = buf_size - read_offset + write_offset;
> > > +exit:
> > > +	return size;
> > > +}
> >
> > Looks good now :)
> >
> > > +
> > > +/**
> > > + * eu_stall_data_buf_poll - Poll for EU stall data in the buffer.
> > > + *
> > > + * @stream: xe EU stall data stream instance
> > > + *
> > > + * Returns: true if the EU stall buffer contains minimum stall data as
> > > + *	    specified by the event report count, else false.
> > > + */
> > > +static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > > +{
> > > +	u32 read_ptr, write_ptr_reg, write_ptr, total_data = 0;
> > > +	u32 buf_size = stream->per_xecore_buf_size;
> > > +	struct per_xecore_buf *xecore_buf;
> > > +	struct xe_gt *gt = stream->gt;
> > > +	bool min_data_present = false;
> > > +	u16 group, instance;
> > > +	unsigned int xecore;
> >
> > u32 and move above to u32 line?
> >
> > > +
> > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > +		xecore_buf = &stream->xecore_buf[xecore];
> > > +		mutex_lock(&xecore_buf->ptr_lock);
> >
> > One thing I am wondering about is: do we really need these per xecore_buf
> > locks? How about moving ptr_lock into xe_eu_stall_data_stream and just
> > cover for_each_dss_steering() calls with the ptr lock. Because the polling
> > thread runs every 10 ms, this should give plenty of time for the polling
> > thread and the reads to go through, even with lcontention. And it will
> > eliminate all these locks and the locking/unlocking overhead.
>
> I used a per dss lock so that polling and read on two different
> subslices can be done in parallel. I will try moving the ptr_lock into
> xe_eu_stall_data_stream.

If you do this, please rename it to dss_lock or something like that, to
indicate it is guarding dss level info, not just the ptr's. Maybe rename
the lock to dss_lock even if you end up not doing this.

> >
> > > +		read_ptr = xecore_buf->read;
> > > +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT,
> > > +						       group, instance);
> > > +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > > +		write_ptr <<= 6;
> > > +		write_ptr &= ((buf_size << 1) - 1);
> > > +		if (write_ptr != read_ptr && !min_data_present) {
> >
> > Don't need to check for 'write_ptr != read_ptr' here, it's already
> > happening in buf_data_size.
>
> Yes it is not needed. But eu_stall_data_buf_poll() is invoked approx every 10ms.
> I am not an expert on compiler optimizations. If the compiler definitely
> optimizes and prevents call to buf_data_size(), I can remove this check.
> But if the compiler doesn't optimize, wouldn't this check help avoid
> function calls given that this function gets executed every 10ms?

The function is called every 10 ms * num_dss and then it is called every
dss for every read(). Even then I am not sure why you are obsessed with the
function call overhead. See here:

https://github.com/torvalds/linux/blob/master/Documentation/process/4.Coding.rst#inline-functions

Specially "The cost of a function call, after all, is not that high" (it is
typically memory accesses which reduce performance, not code execution). I
would let the compiler handle this sort of optimization and decide whether
or not the function can be inlined.

Another option is to use always_inline if you are really concerned:
https://gcc.gnu.org/onlinedocs/gcc/Inline.html

	static __always_inline u32 buf_data_size(...

though I am not sure if just inline is already sufficient:

	static inline u32 buf_data_size(...

So let's do one of these two things and remove this check, I'll approve
either. Sorry if I asked to remove inline earlier :/

> >
> > > +			total_data += buf_data_size(buf_size, read_ptr, write_ptr);
> > > +			/*
> > > +			 * Check if there are at least minimum number of stall data
> > > +			 * rows for poll() to indicate that the data is present.
> > > +			 * Each stall data row is 64B (cacheline size).
> > > +			 */
> >
> > I'd say this comment is not needed and should be removed, the code below is
> > clear enough.
> Will remove.
> >
> > > +			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > > +				min_data_present = true;
> > > +		}
> > > +		xecore_buf->write = write_ptr;
> > > +		mutex_unlock(&xecore_buf->ptr_lock);
> > > +	}
> > > +	return min_data_present;
> > > +}
> > > +
> > > +static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > > +				     char __user *buf, size_t count,
> > > +				     size_t *total_data_size, struct xe_gt *gt,
> > > +				     u16 group, u16 instance, unsigned int xecore)
> > > +{
> > > +	size_t read_data_size, copy_size, buf_size, data_record_size;
> > > +	u32 read_ptr_reg, read_ptr, write_ptr;
> > > +	u8 *xecore_start_vaddr, *read_vaddr;
> > > +	struct per_xecore_buf *xecore_buf;
> > > +	u32 read_offset, write_offset;
> > > +	int ret = 0;
> > > +
> > > +	/* Hardware increments the read and write pointers such that they can
> > > +	 * overflow into one additional bit. For example, a 256KB size buffer
> > > +	 * offset pointer needs 18 bits. But HW uses 19 bits for the read and
> > > +	 * write pointers. This technique avoids wasting a slot in the buffer.
> > > +	 * Read and write offsets are calculated from the pointers in order to
> > > +	 * check if the write pointer has wrapped around the array.
> > > +	 */
> > > +	xecore_buf = &stream->xecore_buf[xecore];
> > > +	mutex_lock(&xecore_buf->ptr_lock);
> > > +	xecore_start_vaddr = xecore_buf->vaddr;
> > > +	read_ptr = xecore_buf->read;
> > > +	write_ptr = xecore_buf->write;
> > > +	buf_size = stream->per_xecore_buf_size;
> > > +	data_record_size = stream->data_record_size;l> > +
> > > +	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> > > +	/* Read only the data that the user space buffer can accommodate */
> > > +	if ((*total_data_size + read_data_size) > count) {
> > > +		read_data_size = count - *total_data_size;
> > > +		read_data_size = (read_data_size / data_record_size) * data_record_size;
> > > +	}
> >
> > As I said, my preferred way of writing this is as follows. Isn't this cleaner?
>
> Most of the times, the if condition would evaluate false and the body of
> the if statement would not be executed. Whereas in your code the two
> lines of code get executed all the time.

The only thing extra which maybe gets executed unconditionally in my code
is the ALIGN_DOWN line. the min_t() part gets executed for you too in the
if () check. Correct?

But once again you seem to be obsessed with these micro optimizations: it
is not that simple:

1. We don't know how the compiler will optimize
2. The CPU itself does out-of-order and speculative execution, branch
   prediction etc. So for you the CPU might actually be executing the code
   in the if () statement (both when result of the if is true and when it
   is false and then discarding the branch which is not taken).
3. Execution speed is driven more by memory accesses and lock contention
   rather than code execution itself. So mostly code stalls at locks and
   for memory accesses to complete.

So with all this going on, my rule is to only make easy to understand and
maintain. And let the compiler and CPU take care of running the code
efficiently. Of course we can't do ridiculous things, which we are not
doing here.

Also, since you are obsessed with optimization, ALIGN_DOWN() uses bit
operations (AND etc.), rather than integer division, so is more
efficient. Also, use of pre-established, standard macros, like min_t and
ALIGN_DOWN, is preferable, rather than rolling your own new code.

> >
> >	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> >	XE_WARN_ON(count >= *total_size);
> Wouldn't count (size of the user buffer) be greater than the total_size
> most of the time? I am still not convinced with having a WARN_ON here.

Sorry, I meant an xe_assert() here:

	xe_assert(xe, count >= *total_size);

To make sure that (count - *total_size >= 0) in the min_t statement
below. So if we use XE_WARN_ON(), this would become:

	XE_WARN_ON(count < *total_size);

So either is ok. I think it is good to have it.

> >	read_data_size = min_t(size_t, count - *total_size, read_data_size);
> >	read_data_size = ALIGN_DOWN(read_data_size, data_record_size);
> >
> > Since data_record_size has to be a power of 2 for this to work (which it
> > is), I would even put a
> data_record_size is fixed in the hardware. As of now for both PVC and
> xe2, it is 64 which is a power of 2. I am guessing that it will remain a
> power of 2 in the future too. Why should we put an assert for the record
> size which is determined in the hardware?

Because we are explicitly making use of the property that data_record_size
is a power of 2 in our code. The ALIGN_DOWN results will be wrong if
somehow data_record_size were not a power of 2.

And it also makes clear that the code is using this property and will break
if it were to be false.

That is the purpose of the assert(). If we weren't making use of that
property in *our* code, we wouldn't need the assert.

> >
> >	xe_assert(xe, is_power_of_2(record_size));
> >
> > in xe_eu_stall_data_record_size().
> >
> >
> > > +	if (read_data_size == 0)
> > > +		goto exit;
> > > +
> > > +	read_offset = read_ptr & (buf_size - 1);
> > > +	write_offset = write_ptr & (buf_size - 1);
> > > +	read_vaddr = xecore_start_vaddr + read_offset;
> > > +
> > > +	if (write_offset > read_offset) {
> > > +		if (copy_to_user((buf + *total_data_size), read_vaddr, read_data_size)) {
> >
> > internal brackets not needed     ^
> >
> > > +			ret = -EFAULT;
> > > +			goto exit;
> > > +		}
> > > +	} else {
> > > +		if (read_data_size >= (buf_size - read_offset))
> >
> > internal brackets not needed          ^
> >
> > > +			copy_size = buf_size - read_offset;
> > > +		else
> > > +			copy_size = read_data_size;
> >
> > if (write_offset < read_offset) how is this 'else' ever possible? So
> > shouldn't copy_size just be set unconditionally to 'buf_size -
> > read_offset'?
> If the user buffer doesn't have enough space to accommodate
> (buf_size - read_offset) bytes, the else will get executed.

Sorry, yes, you are right here.

> >
> > > +		if (copy_to_user((buf + *total_data_size), read_vaddr, copy_size)) {
> >
> > internal brackets not needed     ^
> >
> > > +			ret = -EFAULT;
> > > +			goto exit;
> > > +		}
> > > +		if (copy_to_user((buf + *total_data_size + copy_size),
> >
> > internal brackets not needed     ^
> >
> > > +				 xecore_start_vaddr, read_data_size - copy_size)) {
> > > +			ret = -EFAULT;
> > > +			goto exit;
> > > +		}
> > > +	}
> > > +
> > > +	*total_data_size += read_data_size;
> > > +	read_ptr += read_data_size;
> >
> > Because there is an overflow bit we can just add without worrying about
> > wraparound?
> I want to make sure only one overflow bit is used and doesn't overflow
> into the second bit.

OK, I don't follow, but this was just something I was trying to confirm, so
ignore this comment. The code is fine because of the overflow bits.

> >
> > > +
> > > +	/* Read pointer can overflow into one additional bit */
> > > +	read_ptr &= (buf_size << 1) - 1;
> > > +	read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, (read_ptr >> 6));
> > > +	read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> > > +	xecore_buf->read = read_ptr;
> > > +	trace_xe_eu_stall_data_read(group, instance, read_ptr, write_ptr,
> > > +				    read_offset, write_offset, *total_data_size);
> > > +exit:
> > > +	mutex_unlock(&xecore_buf->ptr_lock);
> > > +	return ret;
> > > +}
> > > +
> > > +/**
> > > + * xe_eu_stall_stream_read_locked - copy EU stall counters data from the
> > > + *				    per xecore buffers to the userspace buffer
> > > + * @stream: A stream opened for EU stall count metrics
> > > + * @file: An xe EU stall data stream file
> > > + * @buf: destination buffer given by userspace
> > > + * @count: the number of bytes userspace wants to read
> > > + *
> > > + * Returns: Number of bytes copied or a negative error code
> > > + * If we've successfully copied any data then reporting that takes
> > > + * precedence over any internal error status, so the data isn't lost.
> > > + */
> > > +static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *stream,
> > > +					      struct file *file, char __user *buf,
> > > +					      size_t count)
> > > +{
> > > +	struct xe_gt *gt = stream->gt;
> > > +	size_t total_size = 0;
> > > +	u16 group, instance;
> > > +	unsigned int xecore;
> > > +	int ret = 0;
> > > +
> > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > +		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > > +						gt, group, instance, xecore);
> > > +		if (ret || count == total_size)
> > > +			break;
> > > +	}
> > > +	return total_size ?: (ret ?: -EAGAIN);
> > > +}
> > > +
> > >  /**
> > >   * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> > >   *
> > > @@ -272,7 +461,35 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > >				       size_t count, loff_t *ppos)
> > >  {
> > > -	ssize_t ret = 0;
> > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > +	struct xe_gt *gt = stream->gt;
> > > +	ssize_t ret;
> > > +
> > > +	if (count == 0)
> > > +		return -EINVAL;
> >
> > I believe we need to also handle the fact that count might not be a
> > multiple of record_size. The easiest way to handle this seems to be right
> > here:
> >	ssize_t aligned_count = ALIGN_DOWN(count, stream->data_record_size);
> I think the code handles buffer sizes that are not multiples of record
> size. Copying few lines of code below. Wouldn't read_data_size be only a
> multiple of record size ? and leave any remaining space empty that is
> not a multiple of record size ?
> /* Read only the data that the user space buffer can accommodate */
> if ((*total_data_size + read_data_size) > count) {
>	read_data_size = count - *total_data_size;
>	read_data_size = (read_data_size / data_record_size) * data_record_size;
>

No, I don't think it is handled. The issue is we have this check here:

xe_eu_stall_stream_read_locked()
{
	...
		if (ret || count == total_size)
			break;
}

And if count is not a multiple of record_size, the 'count == total_size'
will never be true, I think. Since total_size returned by
xe_eu_stall_data_buf_read() is always a multiple of record_size.

> >
> > And used aligned_count rather than count in xe_eu_stall_stream_read_locked
> > calls. So that we don't have to worry about this in later function calls.
> >
> > So above will become:
> >
> >	if (aligned_count == 0)
> >		return -EINVAL;
> >
> > Unless there is a minimum user buffer size we want to support, in that case
> > this becomes:
> >
> >	if (aligned_count < minimum_user_buffer_size)
> >		return -EINVAL;
> >
> > But to me looks like a good value for minimum_user_buffer_size is not
> > available.
> I guess the minimum user buffer size should be the data record size (64
> for PVC and Xe2)? If smaller than the record size, the drive will be
> unable to copy any data.

That is this check:

	if (aligned_count == 0)
		return -EINVAL;

Apart from that, is there a minimum_user_buffer_size which is greater than
record_size? That is why I was saying it is not available.

> >
> > Anyway, better to handle this degenerate case here itself.
> >
> > > +
> > > +	if (!stream->enabled) {
> > > +		xe_gt_dbg(gt, "EU stall data stream not enabled to read\n");
> > > +		return -EINVAL;
> > > +	}
> > > +
> > > +	if (!(file->f_flags & O_NONBLOCK)) {
> > > +		do {
> > > +			ret = wait_event_interruptible(stream->poll_wq, stream->pollin);
> > > +			if (ret)
> > > +				return -EINTR;
> > > +
> > > +			mutex_lock(&gt->eu_stall->stream_lock);
> > > +			ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > +			mutex_unlock(&gt->eu_stall->stream_lock);
> > > +		} while (ret == -EAGAIN);
> > > +	} else {
> > > +		mutex_lock(&gt->eu_stall->stream_lock);
> > > +		ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > +		mutex_unlock(&gt->eu_stall->stream_lock);
> > > +	}
> > > +
> > > +	stream->pollin = false;
> >
> > Carry over comment from previous rev: this breaks if user buffer is smaller
> > than available data. But this is a corner case so let's fix this after the
> > initial merge.
> I will check your fix in OA to better understand the problem here. If
> the user buffer is smaller than data record size, it just returns
> without copying any data.

No, it is the issue when user buffer is larger than record_size, but still
smaller than the size of total data available. In that case, basically we
should let stream->pollin set to true, so that the user thread does not get
blocked, enabling it to rapidly consume data, even with a small buffer.

Otherwise the thread is getting blocked every 10 ms, even when data is
available. And because new data keeps arriving, the user thread constantly
falls behind and soon HW will start dropping data (because the kernel is
blocking the user thread, it's a kernel not a user thread issue)

To handle this OA does:

	if (ret != -ENOSPC && ret != -EIO)
		stream->pollin = false;

Anyway, we can do this after the initial merge.

> >
> > Let's put it a list of to be done's in the cover letter to do after we
> > merge in the next revision.
> Okay.
> >
> > >
> > >	return ret;
> > >  }
> > > @@ -281,6 +498,7 @@ static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
> > >  {
> > >	if (stream->bo)
> > >		xe_bo_unpin_map_no_vm(stream->bo);
> > > +	destroy_workqueue(stream->buf_poll_wq);
> >
> > Don't put this here in free_eu_stall_data_buf, put this in the caller of
> > this function, like the destroy/close function.
> >
> > >  }
> > >
> > >  static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> > > @@ -351,6 +569,21 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > >	return 0;
> > >  }
> > >
> > > +static void eu_stall_data_buf_poll_work_fn(struct work_struct *work)
> > > +{
> > > +	struct xe_eu_stall_data_stream *stream =
> > > +		container_of(work, typeof(*stream), buf_poll_work.work);
> > > +
> > > +	if (eu_stall_data_buf_poll(stream)) {
> > > +		stream->pollin = true;
> > > +		wake_up(&stream->poll_wq);
> > > +	}
> > > +	if (stream->enabled)
> >
> > See comment at xe_eu_stall_disable_locked. If we do
> > cancel_delayed_work_sync there, I think this stream->enabled check might
> I will explain later why I used flush_delayed_work() instead of
> cancel_delayed_work_sync()

See below.

> > not be needed here. Also see comments at cancel_work_sync in
> > kernel/workqueue.c.
> >
> > Could you please check and see if it works out. xe_guc_ct.c (and
> > xe_gt_tlb_invalidation.c) seem to be doing that.
> >
> > > +		queue_delayed_work(stream->buf_poll_wq,
> > > +				   &stream->buf_poll_work,
> > > +				   msecs_to_jiffies(POLL_PERIOD_MS));
> > > +}
> > > +
> > >  static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > >				   struct eu_stall_open_properties *props)
> > >  {
> > > @@ -361,6 +594,11 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > >	u32 vaddr_offset;
> > >	int ret, xecore;
> > >
> > > +	init_waitqueue_head(&stream->poll_wq);
> > > +	INIT_DELAYED_WORK(&stream->buf_poll_work, eu_stall_data_buf_poll_work_fn);
> > > +	stream->buf_poll_wq = alloc_ordered_workqueue("xe_eu_stall", 0);
> > > +	if (!stream->buf_poll_wq)
> > > +		return -ENOMEM;
> >
> > Now we also need to destroy_workqueue during error unwinding (see comments
> > regarding this in Patch 3).
> >
> > >	stream->sampling_rate_mult = props->sampling_rate_mult;
> > >	stream->wait_num_reports = props->wait_num_reports;
> > >	stream->per_xecore_buf_size = per_xecore_buf_size;
> > > @@ -391,6 +629,19 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > >	return 0;
> > >  }
> > >
> > > +static __poll_t xe_eu_stall_stream_poll_locked(struct xe_eu_stall_data_stream *stream,
> > > +					       struct file *file, poll_table *wait)
> > > +{
> > > +	__poll_t events = 0;
> > > +
> > > +	poll_wait(file, &stream->poll_wq, wait);
> > > +
> > > +	if (stream->pollin)
> > > +		events |= EPOLLIN;
> > > +
> > > +	return events;
> > > +}
> > > +
> > >  /**
> > >   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> > >   *
> > > @@ -401,7 +652,13 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > >   */
> > >  static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> > >  {
> > > -	__poll_t ret = 0;
> > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > +	struct xe_gt *gt = stream->gt;
> > > +	__poll_t ret;
> > > +
> > > +	mutex_lock(&gt->eu_stall->stream_lock);
> > > +	ret = xe_eu_stall_stream_poll_locked(stream, file, wait);
> > > +	mutex_unlock(&gt->eu_stall->stream_lock);
> > >
> > >	return ret;
> > >  }
> > > @@ -416,6 +673,9 @@ static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
> > >	stream->enabled = true;
> > >
> > >	ret = xe_eu_stall_stream_enable(stream);
> > > +	queue_delayed_work(stream->buf_poll_wq,
> >
> > A blank line before this line would be nice.
> >
> > > +			   &stream->buf_poll_work,
> > > +			   msecs_to_jiffies(POLL_PERIOD_MS));
> > >	return ret;
> > >  }
> > >
> > > @@ -429,6 +689,9 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
> > >	stream->enabled = false;
> > >
> > >	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> > > +	/* Check for any new EU stall data one last time */
> > > +	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);
> >
> > I am not sure if this is needed, especially if we use
> > cancel_delayed_work_sync.
> There was an ask from the user space to check for new data once after
> disabling EU stall sampling to make sure we capture all the data.

But they won't be able to read it because we set stream->enabled to false?
So what's the point?

> >
> > > +	flush_delayed_work(&stream->buf_poll_work);
> >
> > I think here we should use cancel_delayed_work_sync() instead. See
> > e.g. xe_guc_ct.c (and also maybe xe_gt_tlb_invalidation.c).
> I though about it and found that the difference between
> flushed_delayed_work() and cancel_delayed_work_sync() is that
> cancel_delayed_work_sync() cancels any pending work items and wait for
> any work under execution to complete. Whereas flushed_delayed_work()
> schedules any work pending and wait for it to complete. Since I want to
> execute the work one last time after disable, flushed_delayed_work()
> is more appropriate here than cancel_delayed_work_sync().

Above I am questioning what is the purpose of the last queue_delayed_work.
Also we could add the cancel_delayed_work_sync after the
flush_delayed_work, if that is needed.

As pointed out above, I think it is preferable to eliminate the 'if
(stream->enabled)' check in eu_stall_data_buf_poll_work_fn() and handle it
via cancel_delayed_work_sync(). Which I think should work, but probably
needs to be checked.

>
> >
> > >
> > >	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> > >	xe_pm_runtime_put(gt_to_xe(gt));
> > > diff --git a/drivers/gpu/drm/xe/xe_trace.h b/drivers/gpu/drm/xe/xe_trace.h
> > > index d5281de04d54..1cc6bfc34ccb 100644
> > > --- a/drivers/gpu/drm/xe/xe_trace.h
> > > +++ b/drivers/gpu/drm/xe/xe_trace.h
> > > @@ -427,6 +427,39 @@ DEFINE_EVENT(xe_pm_runtime, xe_pm_runtime_get_ioctl,
> > >	     TP_ARGS(xe, caller)
> > >  );
> > >
> > > +TRACE_EVENT(xe_eu_stall_data_read,
> > > +	    TP_PROTO(u8 slice, u8 subslice,
> > > +		     u32 read_ptr, u32 write_ptr,
> > > +		     u32 read_offset, u32 write_offset,
> > > +		     size_t total_size),
> > > +	    TP_ARGS(slice, subslice, read_ptr, write_ptr,
> > > +		    read_offset, write_offset, total_size),
> > > +
> > > +	    TP_STRUCT__entry(__field(u8, slice)
> > > +			     __field(u8, subslice)
> > > +			     __field(u32, read_ptr)
> > > +			     __field(u32, write_ptr)
> > > +			     __field(u32, read_offset)
> > > +			     __field(u32, write_offset)
> > > +			     __field(size_t, total_size)
> > > +			     ),
> > > +
> > > +	    TP_fast_assign(__entry->slice = slice;
> > > +			   __entry->subslice = subslice;
> > > +			   __entry->read_ptr = read_ptr;
> > > +			   __entry->write_ptr = write_ptr;
> > > +			   __entry->read_offset = read_offset;
> > > +			   __entry->write_offset = write_offset;
> > > +			   __entry->total_size = total_size;
> > > +			   ),
> > > +
> > > +	    TP_printk("slice:%u subslice:%u readptr:0x%x writeptr:0x%x read off:%u write off:%u size:%zu ",
> > > +		      __entry->slice, __entry->subslice,
> > > +		      __entry->read_ptr, __entry->write_ptr,
> > > +		      __entry->read_offset, __entry->write_offset,
> > > +		      __entry->total_size)
> > > +);
> > > +
> > >  #endif
> > >
> > >  /* This part must be outside protection */
> > > --
> > > 2.48.1
> > >

Thanks.
--
Ashutosh

Re: [PATCH v9 4/8] drm/xe/eustall: Add support to read() and poll() EU stall data

[Harish Chegondi]

On Fri, Feb 14, 2025 at 12:34:26PM -0800, Dixit, Ashutosh wrote:
> On Thu, 13 Feb 2025 23:51:54 -0800, Harish Chegondi wrote:
> >
> 
> Hi Harish,
> 
> > On Wed, Feb 12, 2025 at 11:02:07AM -0800, Dixit, Ashutosh wrote:
> > > On Mon, 10 Feb 2025 05:46:45 -0800, Harish Chegondi wrote:
> > > >
> > >
> > > > Implement the EU stall sampling APIs to read() and poll() EU stall data.
> > > > A work function periodically polls the EU stall data buffer write pointer
> > > > registers to look for any new data and caches the write pointer. The read
> > > > function compares the cached read and write pointers and copies any new
> > > > data to the user space.
> > > >
> > > > v9:  New patch split from the previous patch.
> > > >      Used *_delayed_work functions instead of hrtimer
> > > >      Addressed the review feedback in read and poll functions
> > > >
> > > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > > ---
> > > >  drivers/gpu/drm/xe/xe_eu_stall.c | 267 ++++++++++++++++++++++++++++++-
> > > >  drivers/gpu/drm/xe/xe_trace.h    |  33 ++++
> > > >  2 files changed, 298 insertions(+), 2 deletions(-)
> > > >
> > > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > index 12afa9720971..53f17aac7d3b 100644
> > > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > @@ -21,6 +21,7 @@
> > > >  #include "xe_macros.h"
> > > >  #include "xe_observation.h"
> > > >  #include "xe_pm.h"
> > > > +#include "xe_trace.h"
> > > >
> > > >  #include "regs/xe_eu_stall_regs.h"
> > > >  #include "regs/xe_gt_regs.h"
> > > > @@ -41,7 +42,9 @@ struct per_xecore_buf {
> > > >  };
> > > >
> > > >  struct xe_eu_stall_data_stream {
> > > > +	bool pollin;
> > > >	bool enabled;
> > > > +	wait_queue_head_t poll_wq;
> > > >	size_t data_record_size;
> > > >	size_t per_xecore_buf_size;
> > > >	unsigned int wait_num_reports;
> > > > @@ -50,6 +53,8 @@ struct xe_eu_stall_data_stream {
> > > >	struct xe_gt *gt;
> > > >	struct xe_bo *bo;
> > > >	struct per_xecore_buf *xecore_buf;
> > > > +	struct delayed_work buf_poll_work;
> > > > +	struct workqueue_struct *buf_poll_wq;
> > > >  };
> > > >
> > > >  struct xe_eu_stall_gt {
> > > > @@ -256,6 +261,190 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > > >	return 0;
> > > >  }
> > > >
> > > > +/**
> > > > + * buf_data_size - Calculate the number of bytes in a circular buffer
> > > > + *		   given the read and write pointers and the size of
> > > > + *		   the buffer.
> > > > + *
> > > > + * @buf_size: Size of the circular buffer
> > > > + * @read_ptr: Read pointer with an additional overflow bit
> > > > + * @write_ptr: Write pointer with an additional overflow bit
> > > > + *
> > > > + * Since the read and write pointers have an additional overflow bit,
> > > > + * this function calculates the offsets from the pointers and use the
> > > > + * offsets to calculate the data size in the buffer.
> > > > + *
> > > > + * Returns: number of bytes of data in the buffer
> > > > + */
> > > > +static u32 buf_data_size(size_t buf_size, u32 read_ptr, u32 write_ptr)
> > > > +{
> > > > +	u32 read_offset, write_offset, size = 0;
> > > > +
> > > > +	if (read_ptr == write_ptr)
> > > > +		goto exit;
> > > > +
> > > > +	read_offset = read_ptr & (buf_size - 1);
> > > > +	write_offset = write_ptr & (buf_size - 1);
> > > > +
> > > > +	if (write_offset > read_offset)
> > > > +		size = write_offset - read_offset;
> > > > +	else
> > > > +		size = buf_size - read_offset + write_offset;
> > > > +exit:
> > > > +	return size;
> > > > +}
> > >
> > > Looks good now :)
> > >
> > > > +
> > > > +/**
> > > > + * eu_stall_data_buf_poll - Poll for EU stall data in the buffer.
> > > > + *
> > > > + * @stream: xe EU stall data stream instance
> > > > + *
> > > > + * Returns: true if the EU stall buffer contains minimum stall data as
> > > > + *	    specified by the event report count, else false.
> > > > + */
> > > > +static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > > > +{
> > > > +	u32 read_ptr, write_ptr_reg, write_ptr, total_data = 0;
> > > > +	u32 buf_size = stream->per_xecore_buf_size;
> > > > +	struct per_xecore_buf *xecore_buf;
> > > > +	struct xe_gt *gt = stream->gt;
> > > > +	bool min_data_present = false;
> > > > +	u16 group, instance;
> > > > +	unsigned int xecore;
> > >
> > > u32 and move above to u32 line?
> > >
> > > > +
> > > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > > +		xecore_buf = &stream->xecore_buf[xecore];
> > > > +		mutex_lock(&xecore_buf->ptr_lock);
> > >
> > > One thing I am wondering about is: do we really need these per xecore_buf
> > > locks? How about moving ptr_lock into xe_eu_stall_data_stream and just
> > > cover for_each_dss_steering() calls with the ptr lock. Because the polling
> > > thread runs every 10 ms, this should give plenty of time for the polling
> > > thread and the reads to go through, even with lcontention. And it will
> > > eliminate all these locks and the locking/unlocking overhead.
> >
> > I used a per dss lock so that polling and read on two different
> > subslices can be done in parallel. I will try moving the ptr_lock into
> > xe_eu_stall_data_stream.
> 
> If you do this, please rename it to dss_lock or something like that, to
> indicate it is guarding dss level info, not just the ptr's. Maybe rename
> the lock to dss_lock even if you end up not doing this.
> 
> > >
> > > > +		read_ptr = xecore_buf->read;
> > > > +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT,
> > > > +						       group, instance);
> > > > +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > > > +		write_ptr <<= 6;
> > > > +		write_ptr &= ((buf_size << 1) - 1);
> > > > +		if (write_ptr != read_ptr && !min_data_present) {
> > >
> > > Don't need to check for 'write_ptr != read_ptr' here, it's already
> > > happening in buf_data_size.
> >
> > Yes it is not needed. But eu_stall_data_buf_poll() is invoked approx every 10ms.
> > I am not an expert on compiler optimizations. If the compiler definitely
> > optimizes and prevents call to buf_data_size(), I can remove this check.
> > But if the compiler doesn't optimize, wouldn't this check help avoid
> > function calls given that this function gets executed every 10ms?
> 
> The function is called every 10 ms * num_dss and then it is called every
> dss for every read(). Even then I am not sure why you are obsessed with the
> function call overhead. See here:
> 
> https://github.com/torvalds/linux/blob/master/Documentation/process/4.Coding.rst#inline-functions
> 
> Specially "The cost of a function call, after all, is not that high" (it is
> typically memory accesses which reduce performance, not code execution). I
> would let the compiler handle this sort of optimization and decide whether
> or not the function can be inlined.
> 
> Another option is to use always_inline if you are really concerned:
> https://gcc.gnu.org/onlinedocs/gcc/Inline.html
> 
> 	static __always_inline u32 buf_data_size(...
> 
> though I am not sure if just inline is already sufficient:
> 
> 	static inline u32 buf_data_size(...
> 
> So let's do one of these two things and remove this check, I'll approve
> either. Sorry if I asked to remove inline earlier :/
Okay, I will remove the if write_ptr != read_ptr. But I am not sure if
want to add inline. My understanding is we only add inline for very
small functions. 
> 
> > >
> > > > +			total_data += buf_data_size(buf_size, read_ptr, write_ptr);
> > > > +			/*
> > > > +			 * Check if there are at least minimum number of stall data
> > > > +			 * rows for poll() to indicate that the data is present.
> > > > +			 * Each stall data row is 64B (cacheline size).
> > > > +			 */
> > >
> > > I'd say this comment is not needed and should be removed, the code below is
> > > clear enough.
> > Will remove.
> > >
> > > > +			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > > > +				min_data_present = true;
> > > > +		}
> > > > +		xecore_buf->write = write_ptr;
> > > > +		mutex_unlock(&xecore_buf->ptr_lock);
> > > > +	}
> > > > +	return min_data_present;
> > > > +}
> > > > +
> > > > +static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > > > +				     char __user *buf, size_t count,
> > > > +				     size_t *total_data_size, struct xe_gt *gt,
> > > > +				     u16 group, u16 instance, unsigned int xecore)
> > > > +{
> > > > +	size_t read_data_size, copy_size, buf_size, data_record_size;
> > > > +	u32 read_ptr_reg, read_ptr, write_ptr;
> > > > +	u8 *xecore_start_vaddr, *read_vaddr;
> > > > +	struct per_xecore_buf *xecore_buf;
> > > > +	u32 read_offset, write_offset;
> > > > +	int ret = 0;
> > > > +
> > > > +	/* Hardware increments the read and write pointers such that they can
> > > > +	 * overflow into one additional bit. For example, a 256KB size buffer
> > > > +	 * offset pointer needs 18 bits. But HW uses 19 bits for the read and
> > > > +	 * write pointers. This technique avoids wasting a slot in the buffer.
> > > > +	 * Read and write offsets are calculated from the pointers in order to
> > > > +	 * check if the write pointer has wrapped around the array.
> > > > +	 */
> > > > +	xecore_buf = &stream->xecore_buf[xecore];
> > > > +	mutex_lock(&xecore_buf->ptr_lock);
> > > > +	xecore_start_vaddr = xecore_buf->vaddr;
> > > > +	read_ptr = xecore_buf->read;
> > > > +	write_ptr = xecore_buf->write;
> > > > +	buf_size = stream->per_xecore_buf_size;
> > > > +	data_record_size = stream->data_record_size;l> > +
> > > > +	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> > > > +	/* Read only the data that the user space buffer can accommodate */
> > > > +	if ((*total_data_size + read_data_size) > count) {
> > > > +		read_data_size = count - *total_data_size;
> > > > +		read_data_size = (read_data_size / data_record_size) * data_record_size;
> > > > +	}
> > >
> > > As I said, my preferred way of writing this is as follows. Isn't this cleaner?
> >
> > Most of the times, the if condition would evaluate false and the body of
> > the if statement would not be executed. Whereas in your code the two
> > lines of code get executed all the time.
> 
> The only thing extra which maybe gets executed unconditionally in my code
> is the ALIGN_DOWN line. the min_t() part gets executed for you too in the
> if () check. Correct?
> 
> But once again you seem to be obsessed with these micro optimizations: it
> is not that simple:
> 
> 1. We don't know how the compiler will optimize
> 2. The CPU itself does out-of-order and speculative execution, branch
>    prediction etc. So for you the CPU might actually be executing the code
>    in the if () statement (both when result of the if is true and when it
>    is false and then discarding the branch which is not taken).
> 3. Execution speed is driven more by memory accesses and lock contention
>    rather than code execution itself. So mostly code stalls at locks and
>    for memory accesses to complete.
> 
> So with all this going on, my rule is to only make easy to understand and
> maintain. And let the compiler and CPU take care of running the code
> efficiently. Of course we can't do ridiculous things, which we are not
> doing here.
> 
> Also, since you are obsessed with optimization, ALIGN_DOWN() uses bit
> operations (AND etc.), rather than integer division, so is more
> efficient. Also, use of pre-established, standard macros, like min_t and
> ALIGN_DOWN, is preferable, rather than rolling your own new code.
> 
> > >
> > >	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> > >	XE_WARN_ON(count >= *total_size);
> > Wouldn't count (size of the user buffer) be greater than the total_size
> > most of the time? I am still not convinced with having a WARN_ON here.
> 
> Sorry, I meant an xe_assert() here:
> 
> 	xe_assert(xe, count >= *total_size);
> 
> To make sure that (count - *total_size >= 0) in the min_t statement
> below. So if we use XE_WARN_ON(), this would become:
> 
> 	XE_WARN_ON(count < *total_size);
The code has sufficient checks to make sure this doesn't happen.
> 
> So either is ok. I think it is good to have it.
> 
> > >	read_data_size = min_t(size_t, count - *total_size, read_data_size);
> > >	read_data_size = ALIGN_DOWN(read_data_size, data_record_size);
We don't need this ALIGN_DOWN() here if we have the ALIGN_DOWN() you
suggested down below.
> > >
> > > Since data_record_size has to be a power of 2 for this to work (which it
> > > is), I would even put a
> > data_record_size is fixed in the hardware. As of now for both PVC and
> > xe2, it is 64 which is a power of 2. I am guessing that it will remain a
> > power of 2 in the future too. Why should we put an assert for the record
> > size which is determined in the hardware?
> 
> Because we are explicitly making use of the property that data_record_size
> is a power of 2 in our code. The ALIGN_DOWN results will be wrong if
> somehow data_record_size were not a power of 2.
> 
> And it also makes clear that the code is using this property and will break
> if it were to be false.
> 
> That is the purpose of the assert(). If we weren't making use of that
> property in *our* code, we wouldn't need the assert.
> 
> > >
> > >	xe_assert(xe, is_power_of_2(record_size));
> > >
> > > in xe_eu_stall_data_record_size().
> > >
> > >
> > > > +	if (read_data_size == 0)
> > > > +		goto exit;
> > > > +
> > > > +	read_offset = read_ptr & (buf_size - 1);
> > > > +	write_offset = write_ptr & (buf_size - 1);
> > > > +	read_vaddr = xecore_start_vaddr + read_offset;
> > > > +
> > > > +	if (write_offset > read_offset) {
> > > > +		if (copy_to_user((buf + *total_data_size), read_vaddr, read_data_size)) {
> > >
> > > internal brackets not needed     ^
> > >
> > > > +			ret = -EFAULT;
> > > > +			goto exit;
> > > > +		}
> > > > +	} else {
> > > > +		if (read_data_size >= (buf_size - read_offset))
> > >
> > > internal brackets not needed          ^
> > >
> > > > +			copy_size = buf_size - read_offset;
> > > > +		else
> > > > +			copy_size = read_data_size;
> > >
> > > if (write_offset < read_offset) how is this 'else' ever possible? So
> > > shouldn't copy_size just be set unconditionally to 'buf_size -
> > > read_offset'?
> > If the user buffer doesn't have enough space to accommodate
> > (buf_size - read_offset) bytes, the else will get executed.
> 
> Sorry, yes, you are right here.
> 
> > >
> > > > +		if (copy_to_user((buf + *total_data_size), read_vaddr, copy_size)) {
> > >
> > > internal brackets not needed     ^
> > >
> > > > +			ret = -EFAULT;
> > > > +			goto exit;
> > > > +		}
> > > > +		if (copy_to_user((buf + *total_data_size + copy_size),
> > >
> > > internal brackets not needed     ^
> > >
> > > > +				 xecore_start_vaddr, read_data_size - copy_size)) {
> > > > +			ret = -EFAULT;
> > > > +			goto exit;
> > > > +		}
> > > > +	}
> > > > +
> > > > +	*total_data_size += read_data_size;
> > > > +	read_ptr += read_data_size;
> > >
> > > Because there is an overflow bit we can just add without worrying about
> > > wraparound?
> > I want to make sure only one overflow bit is used and doesn't overflow
> > into the second bit.
> 
> OK, I don't follow, but this was just something I was trying to confirm, so
> ignore this comment. The code is fine because of the overflow bits.
> 
> > >
> > > > +
> > > > +	/* Read pointer can overflow into one additional bit */
> > > > +	read_ptr &= (buf_size << 1) - 1;
> > > > +	read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, (read_ptr >> 6));
> > > > +	read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > > > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> > > > +	xecore_buf->read = read_ptr;
> > > > +	trace_xe_eu_stall_data_read(group, instance, read_ptr, write_ptr,
> > > > +				    read_offset, write_offset, *total_data_size);
> > > > +exit:
> > > > +	mutex_unlock(&xecore_buf->ptr_lock);
> > > > +	return ret;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eu_stall_stream_read_locked - copy EU stall counters data from the
> > > > + *				    per xecore buffers to the userspace buffer
> > > > + * @stream: A stream opened for EU stall count metrics
> > > > + * @file: An xe EU stall data stream file
> > > > + * @buf: destination buffer given by userspace
> > > > + * @count: the number of bytes userspace wants to read
> > > > + *
> > > > + * Returns: Number of bytes copied or a negative error code
> > > > + * If we've successfully copied any data then reporting that takes
> > > > + * precedence over any internal error status, so the data isn't lost.
> > > > + */
> > > > +static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *stream,
> > > > +					      struct file *file, char __user *buf,
> > > > +					      size_t count)
> > > > +{
> > > > +	struct xe_gt *gt = stream->gt;
> > > > +	size_t total_size = 0;
> > > > +	u16 group, instance;
> > > > +	unsigned int xecore;
> > > > +	int ret = 0;
> > > > +
> > > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > > +		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > > > +						gt, group, instance, xecore);
> > > > +		if (ret || count == total_size)
> > > > +			break;
> > > > +	}
> > > > +	return total_size ?: (ret ?: -EAGAIN);
> > > > +}
> > > > +
> > > >  /**
> > > >   * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> > > >   *
> > > > @@ -272,7 +461,35 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > > >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > > >				       size_t count, loff_t *ppos)
> > > >  {
> > > > -	ssize_t ret = 0;
> > > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > > +	struct xe_gt *gt = stream->gt;
> > > > +	ssize_t ret;
> > > > +
> > > > +	if (count == 0)
> > > > +		return -EINVAL;
> > >
> > > I believe we need to also handle the fact that count might not be a
> > > multiple of record_size. The easiest way to handle this seems to be right
> > > here:
> > >	ssize_t aligned_count = ALIGN_DOWN(count, stream->data_record_size);
If we consider the aligned_count here, we don't need the ALIGN_DOWN()
you suggested above.
> > I think the code handles buffer sizes that are not multiples of record
> > size. Copying few lines of code below. Wouldn't read_data_size be only a
> > multiple of record size ? and leave any remaining space empty that is
> > not a multiple of record size ?
> > /* Read only the data that the user space buffer can accommodate */
> > if ((*total_data_size + read_data_size) > count) {
> >	read_data_size = count - *total_data_size;
> >	read_data_size = (read_data_size / data_record_size) * data_record_size;
> >
> 
> No, I don't think it is handled. The issue is we have this check here:
> 
> xe_eu_stall_stream_read_locked()
> {
> 	...
> 		if (ret || count == total_size)
> 			break;
> }
> 
> And if count is not a multiple of record_size, the 'count == total_size'
> will never be true, I think. Since total_size returned by
> xe_eu_stall_data_buf_read() is always a multiple of record_size.
> 
> > >
> > > And used aligned_count rather than count in xe_eu_stall_stream_read_locked
> > > calls. So that we don't have to worry about this in later function calls.
> > >
> > > So above will become:
> > >
> > >	if (aligned_count == 0)
> > >		return -EINVAL;
> > >
> > > Unless there is a minimum user buffer size we want to support, in that case
> > > this becomes:
> > >
> > >	if (aligned_count < minimum_user_buffer_size)
> > >		return -EINVAL;
> > >
> > > But to me looks like a good value for minimum_user_buffer_size is not
> > > available.
> > I guess the minimum user buffer size should be the data record size (64
> > for PVC and Xe2)? If smaller than the record size, the drive will be
> > unable to copy any data.
> 
> That is this check:
> 
> 	if (aligned_count == 0)
> 		return -EINVAL;
> 
> Apart from that, is there a minimum_user_buffer_size which is greater than
> record_size? That is why I was saying it is not available.
> 
> > >
> > > Anyway, better to handle this degenerate case here itself.
> > >
> > > > +
> > > > +	if (!stream->enabled) {
> > > > +		xe_gt_dbg(gt, "EU stall data stream not enabled to read\n");
> > > > +		return -EINVAL;
> > > > +	}
I will remove this check. User space should be able to read any last
remaining data even after EU stall is disabled.
> > > > +
> > > > +	if (!(file->f_flags & O_NONBLOCK)) {
> > > > +		do {
> > > > +			ret = wait_event_interruptible(stream->poll_wq, stream->pollin);
> > > > +			if (ret)
> > > > +				return -EINTR;
> > > > +
> > > > +			mutex_lock(&gt->eu_stall->stream_lock);
> > > > +			ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > > +			mutex_unlock(&gt->eu_stall->stream_lock);
> > > > +		} while (ret == -EAGAIN);
> > > > +	} else {
> > > > +		mutex_lock(&gt->eu_stall->stream_lock);
> > > > +		ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > > +		mutex_unlock(&gt->eu_stall->stream_lock);
> > > > +	}
> > > > +
> > > > +	stream->pollin = false;
> > >
> > > Carry over comment from previous rev: this breaks if user buffer is smaller
> > > than available data. But this is a corner case so let's fix this after the
> > > initial merge.
> > I will check your fix in OA to better understand the problem here. If
> > the user buffer is smaller than data record size, it just returns
> > without copying any data.
> 
> No, it is the issue when user buffer is larger than record_size, but still
> smaller than the size of total data available. In that case, basically we
> should let stream->pollin set to true, so that the user thread does not get
> blocked, enabling it to rapidly consume data, even with a small buffer.
> 
> Otherwise the thread is getting blocked every 10 ms, even when data is
> available. And because new data keeps arriving, the user thread constantly
> falls behind and soon HW will start dropping data (because the kernel is
> blocking the user thread, it's a kernel not a user thread issue)
> 
> To handle this OA does:
> 
> 	if (ret != -ENOSPC && ret != -EIO)
EU stall read() never returns -ENOSPC. Even if the user buffer is
smaller then the size of total data in the buffer, only the data that
can fit into the user buffer will be copied through read().
As long as there are atleast wait_num_reports data rows in the buffer,
stream->pollin is set to true. It sounds to me that this issue is
specific to OA code only. Is there something that I missed?
> 		stream->pollin = false;
> 
> Anyway, we can do this after the initial merge.
> 
> > >
> > > Let's put it a list of to be done's in the cover letter to do after we
> > > merge in the next revision.
> > Okay.
> > >
> > > >
> > > >	return ret;
> > > >  }
> > > > @@ -281,6 +498,7 @@ static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
> > > >  {
> > > >	if (stream->bo)
> > > >		xe_bo_unpin_map_no_vm(stream->bo);
> > > > +	destroy_workqueue(stream->buf_poll_wq);
> > >
> > > Don't put this here in free_eu_stall_data_buf, put this in the caller of
> > > this function, like the destroy/close function.
> > >
> > > >  }
> > > >
> > > >  static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> > > > @@ -351,6 +569,21 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > >	return 0;
> > > >  }
> > > >
> > > > +static void eu_stall_data_buf_poll_work_fn(struct work_struct *work)
> > > > +{
> > > > +	struct xe_eu_stall_data_stream *stream =
> > > > +		container_of(work, typeof(*stream), buf_poll_work.work);
> > > > +
> > > > +	if (eu_stall_data_buf_poll(stream)) {
> > > > +		stream->pollin = true;
> > > > +		wake_up(&stream->poll_wq);
> > > > +	}
> > > > +	if (stream->enabled)
> > >
> > > See comment at xe_eu_stall_disable_locked. If we do
> > > cancel_delayed_work_sync there, I think this stream->enabled check might
> > I will explain later why I used flush_delayed_work() instead of
> > cancel_delayed_work_sync()
> 
> See below.
> 
> > > not be needed here. Also see comments at cancel_work_sync in
> > > kernel/workqueue.c.
> > >
> > > Could you please check and see if it works out. xe_guc_ct.c (and
> > > xe_gt_tlb_invalidation.c) seem to be doing that.
> > >
> > > > +		queue_delayed_work(stream->buf_poll_wq,
> > > > +				   &stream->buf_poll_work,
> > > > +				   msecs_to_jiffies(POLL_PERIOD_MS));
> > > > +}
> > > > +
> > > >  static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > >				   struct eu_stall_open_properties *props)
> > > >  {
> > > > @@ -361,6 +594,11 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > >	u32 vaddr_offset;
> > > >	int ret, xecore;
> > > >
> > > > +	init_waitqueue_head(&stream->poll_wq);
> > > > +	INIT_DELAYED_WORK(&stream->buf_poll_work, eu_stall_data_buf_poll_work_fn);
> > > > +	stream->buf_poll_wq = alloc_ordered_workqueue("xe_eu_stall", 0);
> > > > +	if (!stream->buf_poll_wq)
> > > > +		return -ENOMEM;
> > >
> > > Now we also need to destroy_workqueue during error unwinding (see comments
> > > regarding this in Patch 3).
> > >
> > > >	stream->sampling_rate_mult = props->sampling_rate_mult;
> > > >	stream->wait_num_reports = props->wait_num_reports;
> > > >	stream->per_xecore_buf_size = per_xecore_buf_size;
> > > > @@ -391,6 +629,19 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > >	return 0;
> > > >  }
> > > >
> > > > +static __poll_t xe_eu_stall_stream_poll_locked(struct xe_eu_stall_data_stream *stream,
> > > > +					       struct file *file, poll_table *wait)
> > > > +{
> > > > +	__poll_t events = 0;
> > > > +
> > > > +	poll_wait(file, &stream->poll_wq, wait);
> > > > +
> > > > +	if (stream->pollin)
> > > > +		events |= EPOLLIN;
> > > > +
> > > > +	return events;
> > > > +}
> > > > +
> > > >  /**
> > > >   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> > > >   *
> > > > @@ -401,7 +652,13 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > >   */
> > > >  static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> > > >  {
> > > > -	__poll_t ret = 0;
> > > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > > +	struct xe_gt *gt = stream->gt;
> > > > +	__poll_t ret;
> > > > +
> > > > +	mutex_lock(&gt->eu_stall->stream_lock);
> > > > +	ret = xe_eu_stall_stream_poll_locked(stream, file, wait);
> > > > +	mutex_unlock(&gt->eu_stall->stream_lock);
> > > >
> > > >	return ret;
> > > >  }
> > > > @@ -416,6 +673,9 @@ static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
> > > >	stream->enabled = true;
> > > >
> > > >	ret = xe_eu_stall_stream_enable(stream);
> > > > +	queue_delayed_work(stream->buf_poll_wq,
> > >
> > > A blank line before this line would be nice.
> > >
> > > > +			   &stream->buf_poll_work,
> > > > +			   msecs_to_jiffies(POLL_PERIOD_MS));
> > > >	return ret;
> > > >  }
> > > >
> > > > @@ -429,6 +689,9 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
> > > >	stream->enabled = false;
> > > >
> > > >	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> > > > +	/* Check for any new EU stall data one last time */
> > > > +	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);
> > >
> > > I am not sure if this is needed, especially if we use
> > > cancel_delayed_work_sync.
> > There was an ask from the user space to check for new data once after
> > disabling EU stall sampling to make sure we capture all the data.
> 
> But they won't be able to read it because we set stream->enabled to false?
> So what's the point?
Good point. I will remove check for stream->enabled in the read function
xe_eu_stall_stream_read().
> 
> > >
> > > > +	flush_delayed_work(&stream->buf_poll_work);
> > >
> > > I think here we should use cancel_delayed_work_sync() instead. See
> > > e.g. xe_guc_ct.c (and also maybe xe_gt_tlb_invalidation.c).
> > I though about it and found that the difference between
> > flushed_delayed_work() and cancel_delayed_work_sync() is that
> > cancel_delayed_work_sync() cancels any pending work items and wait for
> > any work under execution to complete. Whereas flushed_delayed_work()
> > schedules any work pending and wait for it to complete. Since I want to
> > execute the work one last time after disable, flushed_delayed_work()
> > is more appropriate here than cancel_delayed_work_sync().
> 
> Above I am questioning what is the purpose of the last queue_delayed_work.
> Also we could add the cancel_delayed_work_sync after the
> flush_delayed_work, if that is needed.
Okay, will add cancel_delayed_work_sync() after flush_delayed_work().
> 
> As pointed out above, I think it is preferable to eliminate the 'if
> (stream->enabled)' check in eu_stall_data_buf_poll_work_fn() and handle it
> via cancel_delayed_work_sync(). Which I think should work, but probably
> needs to be checked.
Will check on this. I need to find a different way to check for any new
data and update write pointers one last time after disabling EU stall.
> 
> >
> > >
> > > >
> > > >	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> > > >	xe_pm_runtime_put(gt_to_xe(gt));
> > > > diff --git a/drivers/gpu/drm/xe/xe_trace.h b/drivers/gpu/drm/xe/xe_trace.h
> > > > index d5281de04d54..1cc6bfc34ccb 100644
> > > > --- a/drivers/gpu/drm/xe/xe_trace.h
> > > > +++ b/drivers/gpu/drm/xe/xe_trace.h
> > > > @@ -427,6 +427,39 @@ DEFINE_EVENT(xe_pm_runtime, xe_pm_runtime_get_ioctl,
> > > >	     TP_ARGS(xe, caller)
> > > >  );
> > > >
> > > > +TRACE_EVENT(xe_eu_stall_data_read,
> > > > +	    TP_PROTO(u8 slice, u8 subslice,
> > > > +		     u32 read_ptr, u32 write_ptr,
> > > > +		     u32 read_offset, u32 write_offset,
> > > > +		     size_t total_size),
> > > > +	    TP_ARGS(slice, subslice, read_ptr, write_ptr,
> > > > +		    read_offset, write_offset, total_size),
> > > > +
> > > > +	    TP_STRUCT__entry(__field(u8, slice)
> > > > +			     __field(u8, subslice)
> > > > +			     __field(u32, read_ptr)
> > > > +			     __field(u32, write_ptr)
> > > > +			     __field(u32, read_offset)
> > > > +			     __field(u32, write_offset)
> > > > +			     __field(size_t, total_size)
> > > > +			     ),
> > > > +
> > > > +	    TP_fast_assign(__entry->slice = slice;
> > > > +			   __entry->subslice = subslice;
> > > > +			   __entry->read_ptr = read_ptr;
> > > > +			   __entry->write_ptr = write_ptr;
> > > > +			   __entry->read_offset = read_offset;
> > > > +			   __entry->write_offset = write_offset;
> > > > +			   __entry->total_size = total_size;
> > > > +			   ),
> > > > +
> > > > +	    TP_printk("slice:%u subslice:%u readptr:0x%x writeptr:0x%x read off:%u write off:%u size:%zu ",
> > > > +		      __entry->slice, __entry->subslice,
> > > > +		      __entry->read_ptr, __entry->write_ptr,
> > > > +		      __entry->read_offset, __entry->write_offset,
> > > > +		      __entry->total_size)
> > > > +);
> > > > +
> > > >  #endif
> > > >
> > > >  /* This part must be outside protection */
> > > > --
> > > > 2.48.1
> > > >
> 
> Thanks.
> --
> Ashutosh

Re: [PATCH v9 4/8] drm/xe/eustall: Add support to read() and poll() EU stall data

[Dixit, Ashutosh]

On Fri, 14 Feb 2025 16:44:26 -0800, Harish Chegondi wrote:
>
> On Fri, Feb 14, 2025 at 12:34:26PM -0800, Dixit, Ashutosh wrote:
> > On Thu, 13 Feb 2025 23:51:54 -0800, Harish Chegondi wrote:
> > >
> >
> > Hi Harish,
> >
> > > On Wed, Feb 12, 2025 at 11:02:07AM -0800, Dixit, Ashutosh wrote:
> > > > On Mon, 10 Feb 2025 05:46:45 -0800, Harish Chegondi wrote:
> > > > >
> > > >
> > > > > Implement the EU stall sampling APIs to read() and poll() EU stall data.
> > > > > A work function periodically polls the EU stall data buffer write pointer
> > > > > registers to look for any new data and caches the write pointer. The read
> > > > > function compares the cached read and write pointers and copies any new
> > > > > data to the user space.
> > > > >
> > > > > v9:  New patch split from the previous patch.
> > > > >      Used *_delayed_work functions instead of hrtimer
> > > > >      Addressed the review feedback in read and poll functions
> > > > >
> > > > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > > > ---
> > > > >  drivers/gpu/drm/xe/xe_eu_stall.c | 267 ++++++++++++++++++++++++++++++-
> > > > >  drivers/gpu/drm/xe/xe_trace.h    |  33 ++++
> > > > >  2 files changed, 298 insertions(+), 2 deletions(-)
> > > > >
> > > > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > index 12afa9720971..53f17aac7d3b 100644
> > > > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > @@ -21,6 +21,7 @@
> > > > >  #include "xe_macros.h"
> > > > >  #include "xe_observation.h"
> > > > >  #include "xe_pm.h"
> > > > > +#include "xe_trace.h"
> > > > >
> > > > >  #include "regs/xe_eu_stall_regs.h"
> > > > >  #include "regs/xe_gt_regs.h"
> > > > > @@ -41,7 +42,9 @@ struct per_xecore_buf {
> > > > >  };
> > > > >
> > > > >  struct xe_eu_stall_data_stream {
> > > > > +	bool pollin;
> > > > >	bool enabled;
> > > > > +	wait_queue_head_t poll_wq;
> > > > >	size_t data_record_size;
> > > > >	size_t per_xecore_buf_size;
> > > > >	unsigned int wait_num_reports;
> > > > > @@ -50,6 +53,8 @@ struct xe_eu_stall_data_stream {
> > > > >	struct xe_gt *gt;
> > > > >	struct xe_bo *bo;
> > > > >	struct per_xecore_buf *xecore_buf;
> > > > > +	struct delayed_work buf_poll_work;
> > > > > +	struct workqueue_struct *buf_poll_wq;
> > > > >  };
> > > > >
> > > > >  struct xe_eu_stall_gt {
> > > > > @@ -256,6 +261,190 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > > > >	return 0;
> > > > >  }
> > > > >
> > > > > +/**
> > > > > + * buf_data_size - Calculate the number of bytes in a circular buffer
> > > > > + *		   given the read and write pointers and the size of
> > > > > + *		   the buffer.
> > > > > + *
> > > > > + * @buf_size: Size of the circular buffer
> > > > > + * @read_ptr: Read pointer with an additional overflow bit
> > > > > + * @write_ptr: Write pointer with an additional overflow bit
> > > > > + *
> > > > > + * Since the read and write pointers have an additional overflow bit,
> > > > > + * this function calculates the offsets from the pointers and use the
> > > > > + * offsets to calculate the data size in the buffer.
> > > > > + *
> > > > > + * Returns: number of bytes of data in the buffer
> > > > > + */
> > > > > +static u32 buf_data_size(size_t buf_size, u32 read_ptr, u32 write_ptr)
> > > > > +{
> > > > > +	u32 read_offset, write_offset, size = 0;
> > > > > +
> > > > > +	if (read_ptr == write_ptr)
> > > > > +		goto exit;
> > > > > +
> > > > > +	read_offset = read_ptr & (buf_size - 1);
> > > > > +	write_offset = write_ptr & (buf_size - 1);
> > > > > +
> > > > > +	if (write_offset > read_offset)
> > > > > +		size = write_offset - read_offset;
> > > > > +	else
> > > > > +		size = buf_size - read_offset + write_offset;
> > > > > +exit:
> > > > > +	return size;
> > > > > +}
> > > >
> > > > Looks good now :)
> > > >
> > > > > +
> > > > > +/**
> > > > > + * eu_stall_data_buf_poll - Poll for EU stall data in the buffer.
> > > > > + *
> > > > > + * @stream: xe EU stall data stream instance
> > > > > + *
> > > > > + * Returns: true if the EU stall buffer contains minimum stall data as
> > > > > + *	    specified by the event report count, else false.
> > > > > + */
> > > > > +static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > > > > +{
> > > > > +	u32 read_ptr, write_ptr_reg, write_ptr, total_data = 0;
> > > > > +	u32 buf_size = stream->per_xecore_buf_size;
> > > > > +	struct per_xecore_buf *xecore_buf;
> > > > > +	struct xe_gt *gt = stream->gt;
> > > > > +	bool min_data_present = false;
> > > > > +	u16 group, instance;
> > > > > +	unsigned int xecore;
> > > >
> > > > u32 and move above to u32 line?
> > > >
> > > > > +
> > > > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > > > +		xecore_buf = &stream->xecore_buf[xecore];
> > > > > +		mutex_lock(&xecore_buf->ptr_lock);
> > > >
> > > > One thing I am wondering about is: do we really need these per xecore_buf
> > > > locks? How about moving ptr_lock into xe_eu_stall_data_stream and just
> > > > cover for_each_dss_steering() calls with the ptr lock. Because the polling
> > > > thread runs every 10 ms, this should give plenty of time for the polling
> > > > thread and the reads to go through, even with lcontention. And it will
> > > > eliminate all these locks and the locking/unlocking overhead.
> > >
> > > I used a per dss lock so that polling and read on two different
> > > subslices can be done in parallel. I will try moving the ptr_lock into
> > > xe_eu_stall_data_stream.
> >
> > If you do this, please rename it to dss_lock or something like that, to
> > indicate it is guarding dss level info, not just the ptr's. Maybe rename
> > the lock to dss_lock even if you end up not doing this.
> >
> > > >
> > > > > +		read_ptr = xecore_buf->read;
> > > > > +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT,
> > > > > +						       group, instance);
> > > > > +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > > > > +		write_ptr <<= 6;
> > > > > +		write_ptr &= ((buf_size << 1) - 1);
> > > > > +		if (write_ptr != read_ptr && !min_data_present) {
> > > >
> > > > Don't need to check for 'write_ptr != read_ptr' here, it's already
> > > > happening in buf_data_size.
> > >
> > > Yes it is not needed. But eu_stall_data_buf_poll() is invoked approx every 10ms.
> > > I am not an expert on compiler optimizations. If the compiler definitely
> > > optimizes and prevents call to buf_data_size(), I can remove this check.
> > > But if the compiler doesn't optimize, wouldn't this check help avoid
> > > function calls given that this function gets executed every 10ms?
> >
> > The function is called every 10 ms * num_dss and then it is called every
> > dss for every read(). Even then I am not sure why you are obsessed with the
> > function call overhead. See here:
> >
> > https://github.com/torvalds/linux/blob/master/Documentation/process/4.Coding.rst#inline-functions
> >
> > Specially "The cost of a function call, after all, is not that high" (it is
> > typically memory accesses which reduce performance, not code execution). I
> > would let the compiler handle this sort of optimization and decide whether
> > or not the function can be inlined.
> >
> > Another option is to use always_inline if you are really concerned:
> > https://gcc.gnu.org/onlinedocs/gcc/Inline.html
> >
> >	static __always_inline u32 buf_data_size(...
> >
> > though I am not sure if just inline is already sufficient:
> >
> >	static inline u32 buf_data_size(...
> >
> > So let's do one of these two things and remove this check, I'll approve
> > either. Sorry if I asked to remove inline earlier :/
> Okay, I will remove the if write_ptr != read_ptr. But I am not sure if
> want to add inline. My understanding is we only add inline for very
> small functions.

You can add __always_inline, there are only 2 instances of this, it is a
small function.

> >
> > > >
> > > > > +			total_data += buf_data_size(buf_size, read_ptr, write_ptr);
> > > > > +			/*
> > > > > +			 * Check if there are at least minimum number of stall data
> > > > > +			 * rows for poll() to indicate that the data is present.
> > > > > +			 * Each stall data row is 64B (cacheline size).
> > > > > +			 */
> > > >
> > > > I'd say this comment is not needed and should be removed, the code below is
> > > > clear enough.
> > > Will remove.
> > > >
> > > > > +			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > > > > +				min_data_present = true;
> > > > > +		}
> > > > > +		xecore_buf->write = write_ptr;
> > > > > +		mutex_unlock(&xecore_buf->ptr_lock);
> > > > > +	}
> > > > > +	return min_data_present;
> > > > > +}
> > > > > +
> > > > > +static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > > > > +				     char __user *buf, size_t count,
> > > > > +				     size_t *total_data_size, struct xe_gt *gt,
> > > > > +				     u16 group, u16 instance, unsigned int xecore)
> > > > > +{
> > > > > +	size_t read_data_size, copy_size, buf_size, data_record_size;
> > > > > +	u32 read_ptr_reg, read_ptr, write_ptr;
> > > > > +	u8 *xecore_start_vaddr, *read_vaddr;
> > > > > +	struct per_xecore_buf *xecore_buf;
> > > > > +	u32 read_offset, write_offset;
> > > > > +	int ret = 0;
> > > > > +
> > > > > +	/* Hardware increments the read and write pointers such that they can
> > > > > +	 * overflow into one additional bit. For example, a 256KB size buffer
> > > > > +	 * offset pointer needs 18 bits. But HW uses 19 bits for the read and
> > > > > +	 * write pointers. This technique avoids wasting a slot in the buffer.
> > > > > +	 * Read and write offsets are calculated from the pointers in order to
> > > > > +	 * check if the write pointer has wrapped around the array.
> > > > > +	 */
> > > > > +	xecore_buf = &stream->xecore_buf[xecore];
> > > > > +	mutex_lock(&xecore_buf->ptr_lock);
> > > > > +	xecore_start_vaddr = xecore_buf->vaddr;
> > > > > +	read_ptr = xecore_buf->read;
> > > > > +	write_ptr = xecore_buf->write;
> > > > > +	buf_size = stream->per_xecore_buf_size;
> > > > > +	data_record_size = stream->data_record_size;l> > +
> > > > > +	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> > > > > +	/* Read only the data that the user space buffer can accommodate */
> > > > > +	if ((*total_data_size + read_data_size) > count) {
> > > > > +		read_data_size = count - *total_data_size;
> > > > > +		read_data_size = (read_data_size / data_record_size) * data_record_size;
> > > > > +	}
> > > >
> > > > As I said, my preferred way of writing this is as follows. Isn't this cleaner?
> > >
> > > Most of the times, the if condition would evaluate false and the body of
> > > the if statement would not be executed. Whereas in your code the two
> > > lines of code get executed all the time.
> >
> > The only thing extra which maybe gets executed unconditionally in my code
> > is the ALIGN_DOWN line. the min_t() part gets executed for you too in the
> > if () check. Correct?
> >
> > But once again you seem to be obsessed with these micro optimizations: it
> > is not that simple:
> >
> > 1. We don't know how the compiler will optimize
> > 2. The CPU itself does out-of-order and speculative execution, branch
> >    prediction etc. So for you the CPU might actually be executing the code
> >    in the if () statement (both when result of the if is true and when it
> >    is false and then discarding the branch which is not taken).
> > 3. Execution speed is driven more by memory accesses and lock contention
> >    rather than code execution itself. So mostly code stalls at locks and
> >    for memory accesses to complete.
> >
> > So with all this going on, my rule is to only make easy to understand and
> > maintain. And let the compiler and CPU take care of running the code
> > efficiently. Of course we can't do ridiculous things, which we are not
> > doing here.
> >
> > Also, since you are obsessed with optimization, ALIGN_DOWN() uses bit
> > operations (AND etc.), rather than integer division, so is more
> > efficient. Also, use of pre-established, standard macros, like min_t and
> > ALIGN_DOWN, is preferable, rather than rolling your own new code.
> >
> > > >
> > > >	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> > > >	XE_WARN_ON(count >= *total_size);
> > > Wouldn't count (size of the user buffer) be greater than the total_size
> > > most of the time? I am still not convinced with having a WARN_ON here.
> >
> > Sorry, I meant an xe_assert() here:
> >
> >	xe_assert(xe, count >= *total_size);
> >
> > To make sure that (count - *total_size >= 0) in the min_t statement
> > below. So if we use XE_WARN_ON(), this would become:
> >
> >	XE_WARN_ON(count < *total_size);
> The code has sufficient checks to make sure this doesn't happen.

OK.

> >
> > So either is ok. I think it is good to have it.
> >
> > > >	read_data_size = min_t(size_t, count - *total_size, read_data_size);
> > > >	read_data_size = ALIGN_DOWN(read_data_size, data_record_size);
> We don't need this ALIGN_DOWN() here if we have the ALIGN_DOWN() you
> suggested down below.

Yes, you are right, good catch.

> > > >
> > > > Since data_record_size has to be a power of 2 for this to work (which it
> > > > is), I would even put a
> > > data_record_size is fixed in the hardware. As of now for both PVC and
> > > xe2, it is 64 which is a power of 2. I am guessing that it will remain a
> > > power of 2 in the future too. Why should we put an assert for the record
> > > size which is determined in the hardware?
> >
> > Because we are explicitly making use of the property that data_record_size
> > is a power of 2 in our code. The ALIGN_DOWN results will be wrong if
> > somehow data_record_size were not a power of 2.
> >
> > And it also makes clear that the code is using this property and will break
> > if it were to be false.
> >
> > That is the purpose of the assert(). If we weren't making use of that
> > property in *our* code, we wouldn't need the assert.
> >
> > > >
> > > >	xe_assert(xe, is_power_of_2(record_size));
> > > >
> > > > in xe_eu_stall_data_record_size().
> > > >
> > > >
> > > > > +	if (read_data_size == 0)
> > > > > +		goto exit;
> > > > > +
> > > > > +	read_offset = read_ptr & (buf_size - 1);
> > > > > +	write_offset = write_ptr & (buf_size - 1);
> > > > > +	read_vaddr = xecore_start_vaddr + read_offset;
> > > > > +
> > > > > +	if (write_offset > read_offset) {
> > > > > +		if (copy_to_user((buf + *total_data_size), read_vaddr, read_data_size)) {
> > > >
> > > > internal brackets not needed     ^
> > > >
> > > > > +			ret = -EFAULT;
> > > > > +			goto exit;
> > > > > +		}
> > > > > +	} else {
> > > > > +		if (read_data_size >= (buf_size - read_offset))
> > > >
> > > > internal brackets not needed          ^
> > > >
> > > > > +			copy_size = buf_size - read_offset;
> > > > > +		else
> > > > > +			copy_size = read_data_size;
> > > >
> > > > if (write_offset < read_offset) how is this 'else' ever possible? So
> > > > shouldn't copy_size just be set unconditionally to 'buf_size -
> > > > read_offset'?
> > > If the user buffer doesn't have enough space to accommodate
> > > (buf_size - read_offset) bytes, the else will get executed.
> >
> > Sorry, yes, you are right here.
> >
> > > >
> > > > > +		if (copy_to_user((buf + *total_data_size), read_vaddr, copy_size)) {
> > > >
> > > > internal brackets not needed     ^
> > > >
> > > > > +			ret = -EFAULT;
> > > > > +			goto exit;
> > > > > +		}
> > > > > +		if (copy_to_user((buf + *total_data_size + copy_size),
> > > >
> > > > internal brackets not needed     ^
> > > >
> > > > > +				 xecore_start_vaddr, read_data_size - copy_size)) {
> > > > > +			ret = -EFAULT;
> > > > > +			goto exit;
> > > > > +		}
> > > > > +	}
> > > > > +
> > > > > +	*total_data_size += read_data_size;
> > > > > +	read_ptr += read_data_size;
> > > >
> > > > Because there is an overflow bit we can just add without worrying about
> > > > wraparound?
> > > I want to make sure only one overflow bit is used and doesn't overflow
> > > into the second bit.
> >
> > OK, I don't follow, but this was just something I was trying to confirm, so
> > ignore this comment. The code is fine because of the overflow bits.
> >
> > > >
> > > > > +
> > > > > +	/* Read pointer can overflow into one additional bit */
> > > > > +	read_ptr &= (buf_size << 1) - 1;
> > > > > +	read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, (read_ptr >> 6));
> > > > > +	read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > > > > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> > > > > +	xecore_buf->read = read_ptr;
> > > > > +	trace_xe_eu_stall_data_read(group, instance, read_ptr, write_ptr,
> > > > > +				    read_offset, write_offset, *total_data_size);
> > > > > +exit:
> > > > > +	mutex_unlock(&xecore_buf->ptr_lock);
> > > > > +	return ret;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eu_stall_stream_read_locked - copy EU stall counters data from the
> > > > > + *				    per xecore buffers to the userspace buffer
> > > > > + * @stream: A stream opened for EU stall count metrics
> > > > > + * @file: An xe EU stall data stream file
> > > > > + * @buf: destination buffer given by userspace
> > > > > + * @count: the number of bytes userspace wants to read
> > > > > + *
> > > > > + * Returns: Number of bytes copied or a negative error code
> > > > > + * If we've successfully copied any data then reporting that takes
> > > > > + * precedence over any internal error status, so the data isn't lost.
> > > > > + */
> > > > > +static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *stream,
> > > > > +					      struct file *file, char __user *buf,
> > > > > +					      size_t count)
> > > > > +{
> > > > > +	struct xe_gt *gt = stream->gt;
> > > > > +	size_t total_size = 0;
> > > > > +	u16 group, instance;
> > > > > +	unsigned int xecore;
> > > > > +	int ret = 0;
> > > > > +
> > > > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > > > +		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > > > > +						gt, group, instance, xecore);
> > > > > +		if (ret || count == total_size)
> > > > > +			break;
> > > > > +	}
> > > > > +	return total_size ?: (ret ?: -EAGAIN);
> > > > > +}
> > > > > +
> > > > >  /**
> > > > >   * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> > > > >   *
> > > > > @@ -272,7 +461,35 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > > > >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > > > >				       size_t count, loff_t *ppos)
> > > > >  {
> > > > > -	ssize_t ret = 0;
> > > > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > > > +	struct xe_gt *gt = stream->gt;
> > > > > +	ssize_t ret;
> > > > > +
> > > > > +	if (count == 0)
> > > > > +		return -EINVAL;
> > > >
> > > > I believe we need to also handle the fact that count might not be a
> > > > multiple of record_size. The easiest way to handle this seems to be right
> > > > here:
> > > >	ssize_t aligned_count = ALIGN_DOWN(count, stream->data_record_size);
> If we consider the aligned_count here, we don't need the ALIGN_DOWN()
> you suggested above.

Agreed, correct!

> > > I think the code handles buffer sizes that are not multiples of record
> > > size. Copying few lines of code below. Wouldn't read_data_size be only a
> > > multiple of record size ? and leave any remaining space empty that is
> > > not a multiple of record size ?
> > > /* Read only the data that the user space buffer can accommodate */
> > > if ((*total_data_size + read_data_size) > count) {
> > >	read_data_size = count - *total_data_size;
> > >	read_data_size = (read_data_size / data_record_size) * data_record_size;
> > >
> >
> > No, I don't think it is handled. The issue is we have this check here:
> >
> > xe_eu_stall_stream_read_locked()
> > {
> >	...
> >		if (ret || count == total_size)
> >			break;
> > }
> >
> > And if count is not a multiple of record_size, the 'count == total_size'
> > will never be true, I think. Since total_size returned by
> > xe_eu_stall_data_buf_read() is always a multiple of record_size.
> >
> > > >
> > > > And used aligned_count rather than count in xe_eu_stall_stream_read_locked
> > > > calls. So that we don't have to worry about this in later function calls.
> > > >
> > > > So above will become:
> > > >
> > > >	if (aligned_count == 0)
> > > >		return -EINVAL;
> > > >
> > > > Unless there is a minimum user buffer size we want to support, in that case
> > > > this becomes:
> > > >
> > > >	if (aligned_count < minimum_user_buffer_size)
> > > >		return -EINVAL;
> > > >
> > > > But to me looks like a good value for minimum_user_buffer_size is not
> > > > available.
> > > I guess the minimum user buffer size should be the data record size (64
> > > for PVC and Xe2)? If smaller than the record size, the drive will be
> > > unable to copy any data.
> >
> > That is this check:
> >
> >	if (aligned_count == 0)
> >		return -EINVAL;
> >
> > Apart from that, is there a minimum_user_buffer_size which is greater than
> > record_size? That is why I was saying it is not available.
> >
> > > >
> > > > Anyway, better to handle this degenerate case here itself.
> > > >
> > > > > +
> > > > > +	if (!stream->enabled) {
> > > > > +		xe_gt_dbg(gt, "EU stall data stream not enabled to read\n");
> > > > > +		return -EINVAL;
> > > > > +	}
> I will remove this check. User space should be able to read any last
> remaining data even after EU stall is disabled.

I would advise against it. You will need to carefully consider the
consequences of allowing reads in disabled state. When there is no data in
disabled state (after the initial data has been read):

* Non-blocking reads will return -EAGAIN, so that is ok
* Blocking reads will indefinitely block, unless userland unblocks these
  via a signal.

Why can't userland read all data and then disable the stream? What kind of
a requirement is that?

They run a workload to capture some stats. They should:
	1. stop the workload
	2. get all data for the workload: read() till non-blocking reads
	   return -EAGAIN or blocking reads block (unblock using signal). I
	   am assuming if nothing is running on the EU's there is no data?
	3. finally disable the stream.

So if they do that, we don't allow reading any data in disabled state.

And anyway, this is what we can implement initially. If they don't agree we
can later add a patch to change the behavior. But they need to convince us
why they can't do what I just said above. Our default behavior should be to
not allow reads in disabled state, I think.

> > > > > +
> > > > > +	if (!(file->f_flags & O_NONBLOCK)) {
> > > > > +		do {
> > > > > +			ret = wait_event_interruptible(stream->poll_wq, stream->pollin);
> > > > > +			if (ret)
> > > > > +				return -EINTR;
> > > > > +
> > > > > +			mutex_lock(&gt->eu_stall->stream_lock);
> > > > > +			ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > > > +			mutex_unlock(&gt->eu_stall->stream_lock);
> > > > > +		} while (ret == -EAGAIN);
> > > > > +	} else {
> > > > > +		mutex_lock(&gt->eu_stall->stream_lock);
> > > > > +		ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > > > +		mutex_unlock(&gt->eu_stall->stream_lock);
> > > > > +	}
> > > > > +
> > > > > +	stream->pollin = false;
> > > >
> > > > Carry over comment from previous rev: this breaks if user buffer is smaller
> > > > than available data. But this is a corner case so let's fix this after the
> > > > initial merge.
> > > I will check your fix in OA to better understand the problem here. If
> > > the user buffer is smaller than data record size, it just returns
> > > without copying any data.
> >
> > No, it is the issue when user buffer is larger than record_size, but still
> > smaller than the size of total data available. In that case, basically we
> > should let stream->pollin set to true, so that the user thread does not get
> > blocked, enabling it to rapidly consume data, even with a small buffer.
> >
> > Otherwise the thread is getting blocked every 10 ms, even when data is
> > available. And because new data keeps arriving, the user thread constantly
> > falls behind and soon HW will start dropping data (because the kernel is
> > blocking the user thread, it's a kernel not a user thread issue)
> >
> > To handle this OA does:
> >
> >	if (ret != -ENOSPC && ret != -EIO)
> EU stall read() never returns -ENOSPC. Even if the user buffer is
> smaller then the size of total data in the buffer, only the data that
> can fit into the user buffer will be copied through read().

OA read() also doesn't return -ENOSPC to userland. That is the expected
read() behavior (return number of bytes if you are returning any data). The
full code is this:

        if (ret != -ENOSPC && ret != -EIO)
                stream->pollin = false;

        return offset ?: (ret ?: -EAGAIN);

> As long as there are atleast wait_num_reports data rows in the buffer,
> stream->pollin is set to true. It sounds to me that this issue is
> specific to OA code only. Is there something that I missed?

No this issue is there in EU stall code. You should not block reads till
the next time the polling thread runs, if we could not copy all data in the
previous read (because there already is data, don't block the user thread).

> >		stream->pollin = false;
> >
> > Anyway, we can do this after the initial merge.
> >
> > > >
> > > > Let's put it a list of to be done's in the cover letter to do after we
> > > > merge in the next revision.
> > > Okay.
> > > >
> > > > >
> > > > >	return ret;
> > > > >  }
> > > > > @@ -281,6 +498,7 @@ static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
> > > > >  {
> > > > >	if (stream->bo)
> > > > >		xe_bo_unpin_map_no_vm(stream->bo);
> > > > > +	destroy_workqueue(stream->buf_poll_wq);
> > > >
> > > > Don't put this here in free_eu_stall_data_buf, put this in the caller of
> > > > this function, like the destroy/close function.
> > > >
> > > > >  }
> > > > >
> > > > >  static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> > > > > @@ -351,6 +569,21 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > > >	return 0;
> > > > >  }
> > > > >
> > > > > +static void eu_stall_data_buf_poll_work_fn(struct work_struct *work)
> > > > > +{
> > > > > +	struct xe_eu_stall_data_stream *stream =
> > > > > +		container_of(work, typeof(*stream), buf_poll_work.work);
> > > > > +
> > > > > +	if (eu_stall_data_buf_poll(stream)) {
> > > > > +		stream->pollin = true;
> > > > > +		wake_up(&stream->poll_wq);
> > > > > +	}
> > > > > +	if (stream->enabled)
> > > >
> > > > See comment at xe_eu_stall_disable_locked. If we do
> > > > cancel_delayed_work_sync there, I think this stream->enabled check might
> > > I will explain later why I used flush_delayed_work() instead of
> > > cancel_delayed_work_sync()
> >
> > See below.
> >
> > > > not be needed here. Also see comments at cancel_work_sync in
> > > > kernel/workqueue.c.
> > > >
> > > > Could you please check and see if it works out. xe_guc_ct.c (and
> > > > xe_gt_tlb_invalidation.c) seem to be doing that.
> > > >
> > > > > +		queue_delayed_work(stream->buf_poll_wq,
> > > > > +				   &stream->buf_poll_work,
> > > > > +				   msecs_to_jiffies(POLL_PERIOD_MS));
> > > > > +}
> > > > > +
> > > > >  static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > > >				   struct eu_stall_open_properties *props)
> > > > >  {
> > > > > @@ -361,6 +594,11 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > > >	u32 vaddr_offset;
> > > > >	int ret, xecore;
> > > > >
> > > > > +	init_waitqueue_head(&stream->poll_wq);
> > > > > +	INIT_DELAYED_WORK(&stream->buf_poll_work, eu_stall_data_buf_poll_work_fn);
> > > > > +	stream->buf_poll_wq = alloc_ordered_workqueue("xe_eu_stall", 0);
> > > > > +	if (!stream->buf_poll_wq)
> > > > > +		return -ENOMEM;
> > > >
> > > > Now we also need to destroy_workqueue during error unwinding (see comments
> > > > regarding this in Patch 3).
> > > >
> > > > >	stream->sampling_rate_mult = props->sampling_rate_mult;
> > > > >	stream->wait_num_reports = props->wait_num_reports;
> > > > >	stream->per_xecore_buf_size = per_xecore_buf_size;
> > > > > @@ -391,6 +629,19 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > > >	return 0;
> > > > >  }
> > > > >
> > > > > +static __poll_t xe_eu_stall_stream_poll_locked(struct xe_eu_stall_data_stream *stream,
> > > > > +					       struct file *file, poll_table *wait)
> > > > > +{
> > > > > +	__poll_t events = 0;
> > > > > +
> > > > > +	poll_wait(file, &stream->poll_wq, wait);
> > > > > +
> > > > > +	if (stream->pollin)
> > > > > +		events |= EPOLLIN;
> > > > > +
> > > > > +	return events;
> > > > > +}
> > > > > +
> > > > >  /**
> > > > >   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> > > > >   *
> > > > > @@ -401,7 +652,13 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > > >   */
> > > > >  static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> > > > >  {
> > > > > -	__poll_t ret = 0;
> > > > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > > > +	struct xe_gt *gt = stream->gt;
> > > > > +	__poll_t ret;
> > > > > +
> > > > > +	mutex_lock(&gt->eu_stall->stream_lock);
> > > > > +	ret = xe_eu_stall_stream_poll_locked(stream, file, wait);
> > > > > +	mutex_unlock(&gt->eu_stall->stream_lock);
> > > > >
> > > > >	return ret;
> > > > >  }
> > > > > @@ -416,6 +673,9 @@ static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
> > > > >	stream->enabled = true;
> > > > >
> > > > >	ret = xe_eu_stall_stream_enable(stream);
> > > > > +	queue_delayed_work(stream->buf_poll_wq,
> > > >
> > > > A blank line before this line would be nice.
> > > >
> > > > > +			   &stream->buf_poll_work,
> > > > > +			   msecs_to_jiffies(POLL_PERIOD_MS));
> > > > >	return ret;
> > > > >  }
> > > > >
> > > > > @@ -429,6 +689,9 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
> > > > >	stream->enabled = false;
> > > > >
> > > > >	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> > > > > +	/* Check for any new EU stall data one last time */
> > > > > +	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);
> > > >
> > > > I am not sure if this is needed, especially if we use
> > > > cancel_delayed_work_sync.
> > > There was an ask from the user space to check for new data once after
> > > disabling EU stall sampling to make sure we capture all the data.
> >
> > But they won't be able to read it because we set stream->enabled to false?
> > So what's the point?
> Good point. I will remove check for stream->enabled in the read function
> xe_eu_stall_stream_read().

See above.

> >
> > > >
> > > > > +	flush_delayed_work(&stream->buf_poll_work);
> > > >
> > > > I think here we should use cancel_delayed_work_sync() instead. See
> > > > e.g. xe_guc_ct.c (and also maybe xe_gt_tlb_invalidation.c).
> > > I though about it and found that the difference between
> > > flushed_delayed_work() and cancel_delayed_work_sync() is that
> > > cancel_delayed_work_sync() cancels any pending work items and wait for
> > > any work under execution to complete. Whereas flushed_delayed_work()
> > > schedules any work pending and wait for it to complete. Since I want to
> > > execute the work one last time after disable, flushed_delayed_work()
> > > is more appropriate here than cancel_delayed_work_sync().
> >
> > Above I am questioning what is the purpose of the last queue_delayed_work.
> > Also we could add the cancel_delayed_work_sync after the
> > flush_delayed_work, if that is needed.
> Okay, will add cancel_delayed_work_sync() after flush_delayed_work().
> >
> > As pointed out above, I think it is preferable to eliminate the 'if
> > (stream->enabled)' check in eu_stall_data_buf_poll_work_fn() and handle it
> > via cancel_delayed_work_sync(). Which I think should work, but probably
> > needs to be checked.
> Will check on this. I need to find a different way to check for any new
> data and update write pointers one last time after disabling EU stall.
> >
> > >
> > > >
> > > > >
> > > > >	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> > > > >	xe_pm_runtime_put(gt_to_xe(gt));
> > > > > diff --git a/drivers/gpu/drm/xe/xe_trace.h b/drivers/gpu/drm/xe/xe_trace.h
> > > > > index d5281de04d54..1cc6bfc34ccb 100644
> > > > > --- a/drivers/gpu/drm/xe/xe_trace.h
> > > > > +++ b/drivers/gpu/drm/xe/xe_trace.h
> > > > > @@ -427,6 +427,39 @@ DEFINE_EVENT(xe_pm_runtime, xe_pm_runtime_get_ioctl,
> > > > >	     TP_ARGS(xe, caller)
> > > > >  );
> > > > >
> > > > > +TRACE_EVENT(xe_eu_stall_data_read,
> > > > > +	    TP_PROTO(u8 slice, u8 subslice,
> > > > > +		     u32 read_ptr, u32 write_ptr,
> > > > > +		     u32 read_offset, u32 write_offset,
> > > > > +		     size_t total_size),
> > > > > +	    TP_ARGS(slice, subslice, read_ptr, write_ptr,
> > > > > +		    read_offset, write_offset, total_size),
> > > > > +
> > > > > +	    TP_STRUCT__entry(__field(u8, slice)
> > > > > +			     __field(u8, subslice)
> > > > > +			     __field(u32, read_ptr)
> > > > > +			     __field(u32, write_ptr)
> > > > > +			     __field(u32, read_offset)
> > > > > +			     __field(u32, write_offset)
> > > > > +			     __field(size_t, total_size)
> > > > > +			     ),
> > > > > +
> > > > > +	    TP_fast_assign(__entry->slice = slice;
> > > > > +			   __entry->subslice = subslice;
> > > > > +			   __entry->read_ptr = read_ptr;
> > > > > +			   __entry->write_ptr = write_ptr;
> > > > > +			   __entry->read_offset = read_offset;
> > > > > +			   __entry->write_offset = write_offset;
> > > > > +			   __entry->total_size = total_size;
> > > > > +			   ),
> > > > > +
> > > > > +	    TP_printk("slice:%u subslice:%u readptr:0x%x writeptr:0x%x read off:%u write off:%u size:%zu ",
> > > > > +		      __entry->slice, __entry->subslice,
> > > > > +		      __entry->read_ptr, __entry->write_ptr,
> > > > > +		      __entry->read_offset, __entry->write_offset,
> > > > > +		      __entry->total_size)
> > > > > +);
> > > > > +
> > > > >  #endif
> > > > >
> > > > >  /* This part must be outside protection */
> > > > > --
> > > > > 2.48.1
> > > > >
> >
> > Thanks.
> > --
> > Ashutosh

Re: [PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Harish Chegondi]

On Wed, Feb 12, 2025 at 06:39:47PM -0800, Dixit, Ashutosh wrote:
> On Wed, 12 Feb 2025 15:54:41 -0800, Harish Chegondi wrote:
> >
> > On Mon, Feb 10, 2025 at 03:07:51PM -0800, Dixit, Ashutosh wrote:
> > > On Mon, 10 Feb 2025 05:46:43 -0800, Harish Chegondi wrote:
> > > >
> > >
> > Hi Ashutosh,
> > > Hi Harish,
> > >
> > > > A new hardware feature first introduced in PVC gives capability to
> > > > periodically sample EU stall state and record counts for different stall
> > > > reasons, on a per IP basis, aggregate across all EUs in a subslice and
> > > > record the samples in a buffer in each subslice. Eventually, the aggregated
> > > > data is written out to a buffer in the memory. This feature is also
> > > > supported in XE2 and later architecture GPUs.
> > > >
> > > > Use an existing IOCTL - DRM_IOCTL_XE_OBSERVATION as the interface into the
> > > > driver from the user space to do initial setup and obtain a file descriptor
> > > > for the EU stall data stream.  Input parameter to the IOCTL is a struct
> > > > drm_xe_observation_param in which observation_type should be set to
> > > > DRM_XE_OBSERVATION_TYPE_EU_STALL, observation_op should be
> > > > DRM_XE_OBSERVATION_OP_STREAM_OPEN and param should point to a chain of
> > > > drm_xe_ext_set_property structures in which each structure has a pair of
> > > > property and value. The EU stall sampling input properties are defined in
> > > > drm_xe_eu_stall_property_id enum.
> > > >
> > > > With the file descriptor obtained from DRM_IOCTL_XE_OBSERVATION, user space
> > > > can enable and disable EU stall sampling with the IOCTLs:
> > > > DRM_XE_OBSERVATION_IOCTL_ENABLE and DRM_XE_OBSERVATION_IOCTL_DISABLE.
> > > > User space can also call poll() to check for availability of data in the
> > > > buffer. The data can be read with read(). Finally, the file descriptor
> > > > can be closed with close().
> > > >
> > > > v9: Changed some u32 to unsigned int.
> > > >     Moved some code around as per review feedback from v8.
> > > > v8: Used div_u64 instead of / to fix 32-bit build issue.
> > > >     Changed copyright year in xe_eu_stall.c/h to 2025.
> > > > v7: Renamed input property DRM_XE_EU_STALL_PROP_EVENT_REPORT_COUNT
> > > >     to DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS to be consistent with
> > > >     OA. Renamed the corresponding internal variables.
> > > >     Fixed some commit messages based on review feedback.
> > > > v6: Change the input sampling rate to GPU cycles instead of
> > > >     GPU cycles multiplier.
> > > >
> > > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > > ---
> > > >  drivers/gpu/drm/xe/Makefile         |   1 +
> > > >  drivers/gpu/drm/xe/xe_eu_stall.c    | 280 ++++++++++++++++++++++++++++
> > > >  drivers/gpu/drm/xe/xe_eu_stall.h    |  16 ++
> > > >  drivers/gpu/drm/xe/xe_observation.c |  14 ++
> > > >  include/uapi/drm/xe_drm.h           |  38 ++++
> > > >  5 files changed, 349 insertions(+)
> > > >  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.c
> > > >  create mode 100644 drivers/gpu/drm/xe/xe_eu_stall.h
> > > >
> > > > diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
> > > > index be73362ef334..05bcb9941c38 100644
> > > > --- a/drivers/gpu/drm/xe/Makefile
> > > > +++ b/drivers/gpu/drm/xe/Makefile
> > > > @@ -33,6 +33,7 @@ xe-y += xe_bb.o \
> > > >	xe_device_sysfs.o \
> > > >	xe_dma_buf.o \
> > > >	xe_drm_client.o \
> > > > +	xe_eu_stall.o \
> > > >	xe_exec.o \
> > > >	xe_exec_queue.o \
> > > >	xe_execlist.o \
> > > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > new file mode 100644
> > > > index 000000000000..0ceb3091f81e
> > > > --- /dev/null
> > > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > @@ -0,0 +1,280 @@
> > > > +// SPDX-License-Identifier: MIT
> > > > +/*
> > > > + * Copyright © 2025 Intel Corporation
> > > > + */
> > > > +
> > > > +#include <linux/anon_inodes.h>
> > > > +#include <linux/fs.h>
> > > > +#include <linux/poll.h>
> > > > +#include <linux/types.h>
> > > > +
> > > > +#include <uapi/drm/xe_drm.h>
> > > > +
> > > > +#include "xe_device.h"
> > > > +#include "xe_eu_stall.h"
> > > > +#include "xe_gt_printk.h"
> > > > +#include "xe_gt_topology.h"
> > > > +#include "xe_macros.h"
> > > > +#include "xe_observation.h"
> > > > +
> > > > +static size_t per_xecore_buf_size = SZ_512K;
> > > > +
> > > > +/**
> > > > + * struct eu_stall_open_properties - EU stall sampling properties received
> > > > + *				     from user space at open.
> > > > + * @sampling_rate_mult: EU stall sampling rate multiplier.
> > > > + *			HW will sample every (sampling_rate_mult x 251) cycles.
> > > > + * @wait_num_reports: Minimum number of EU stall data reports to unblock poll().
> > > > + * @gt: GT on which EU stall data will be captured.
> > > > + */
> > > > +struct eu_stall_open_properties {
> > > > +	unsigned int sampling_rate_mult;
> > > > +	unsigned int wait_num_reports;
> > >
> > > I already said no need to be so specific. Just use int or u32 as types for
> > > these.
> > Okay, will try to change these back to u8/u32 in the next version.
> 
> Use int or u32, not u8.
Any reason why I can't use u8? The maximum value of sampling_rate_mult
is 7.
> 
> > >
> > > > +	struct xe_gt *gt;
> > > > +};
> > > > +
> > > > +/**
> > > > + * num_data_rows - Return the number of EU stall data rows of 64B each
> > > > + *		   for a given data size.
> > > > + *
> > > > + * @data_size: EU stall data size
> > > > + */
> > > > +static u32 num_data_rows(u32 data_size)
> > > > +{
> > > > +	return (data_size >> 6);
> > > > +}
> > > > +
> > > > +static int set_prop_eu_stall_sampling_rate(struct xe_device *xe, u64 value,
> > > > +					   struct eu_stall_open_properties *props)
> > > > +{
> > > > +	value = div_u64(value, 251);
> > > > +	if (value == 0 || value > 7) {
> > > > +		drm_dbg(&xe->drm, "Invalid EU stall sampling rate %llu\n", value);
> > > > +		return -EINVAL;
> > > > +	}
> > > > +	props->sampling_rate_mult = value;
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +static int set_prop_eu_stall_wait_num_reports(struct xe_device *xe, u64 value,
> > > > +					      struct eu_stall_open_properties *props)
> > > > +{
> > > > +	unsigned int max_wait_num_reports;
> > > > +
> > > > +	max_wait_num_reports = num_data_rows(per_xecore_buf_size * XE_MAX_DSS_FUSE_BITS);
> > >
> > > This seems wrong. Instead of XE_MAX_DSS_FUSE_BITS, shouldn't we use the
> > > value returned by xe_gt_topology_mask_last_dss()?
> > Yes you are correct. But not xe_gt_topology_mask_last_dss() as it would
> > only return the last DSS and the DSSes can be discontiguous. We should
> > use the absolute number of DSSes * buffer size. I can move this
> > validation to xe_eu_stall_stream_init() where we can do a
> > bitmap_weight(all_xecore) to find the actual number of DSSes and return
> > EINVAL if invalid input. I did a simple validation here as I wasn't sure
> > if it is worth doing the extra validation.
> > >
> > > Note that a large value can result in the poll/read never getting
> > > unblocked!
> > >
> > > To solve this issue I think num_xecore should be maintained in struct
> > > xe_eu_stall_gt. Though let's see what happens to 'struct xe_device *' arg
> > > to these functions if we do this.
> > Probably not required if this validation is done in
> > xe_eu_stall_stream_init() added in the next patch as I described above.
> 
> OK, we can do that. But in that case just check for 0 below, remove all the
> drm_dbg's and also remove max_wait_num_reports, since that will be
> validated in xe_eu_stall_stream_init(). So that we are not doing any
> invalid validation here and correcting it later. Maybe even check for 0 in
> xe_eu_stall_stream_init. You can add xe_gt_dbg's there if needed, or even
> create a small new function.
> 
> Actually I was wrong in saying "num_xecore should be maintained in struct
> xe_eu_stall_gt" because xe_eu_stall_stream_open() is a device level
> function so only xe_device is available there not xe_gt. So if we were to
> store num_xecore, we'd need to create a new device level xe_eu_stall struct
> and put num_xecore there. This is also device level information. E.g. OA
> has both device and gt level structs.
> 
> So depends on you. But we can do xe_eu_stall_stream_init for now.
> 
> > >
> > > > +	if (value == 0 || value > max_wait_num_reports) {
> > > > +		drm_dbg(&xe->drm, "Invalid EU stall event report count %llu\n", value);
> > > > +		drm_dbg(&xe->drm, "Minimum event report count is 1, maximum is %u\n",
> > > > +			max_wait_num_reports);
> > > > +		return -EINVAL;
> > > > +	}
> > > > +	props->wait_num_reports = value;
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +static int set_prop_eu_stall_gt_id(struct xe_device *xe, u64 value,
> > > > +				   struct eu_stall_open_properties *props)
> > > > +{
> > > > +	if (value >= xe->info.gt_count) {
> > > > +		drm_dbg(&xe->drm, "Invalid GT ID %llu for EU stall sampling\n", value);
> > > > +		return -EINVAL;
> > > > +	}
> > > > +	props->gt = xe_device_get_gt(xe, value);
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +typedef int (*set_eu_stall_property_fn)(struct xe_device *xe, u64 value,
> > > > +					struct eu_stall_open_properties *props);
> > > > +
> > > > +static const set_eu_stall_property_fn xe_set_eu_stall_property_funcs[] = {
> > > > +	[DRM_XE_EU_STALL_PROP_SAMPLE_RATE] = set_prop_eu_stall_sampling_rate,
> > > > +	[DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS] = set_prop_eu_stall_wait_num_reports,
> > > > +	[DRM_XE_EU_STALL_PROP_GT_ID] = set_prop_eu_stall_gt_id,
> > > > +};
> > > > +
> > > > +static int xe_eu_stall_user_ext_set_property(struct xe_device *xe, u64 extension,
> > > > +					     struct eu_stall_open_properties *props)
> > > > +{
> > > > +	u64 __user *address = u64_to_user_ptr(extension);
> > > > +	struct drm_xe_ext_set_property ext;
> > > > +	int err;
> > > > +	u32 idx;
> > > > +
> > > > +	err = __copy_from_user(&ext, address, sizeof(ext));
> > > > +	if (XE_IOCTL_DBG(xe, err))
> > > > +		return -EFAULT;
> > > > +
> > > > +	if (XE_IOCTL_DBG(xe, ext.property >= ARRAY_SIZE(xe_set_eu_stall_property_funcs)) ||
> > > > +	    XE_IOCTL_DBG(xe, ext.pad))
> > > > +		return -EINVAL;
> > > > +
> > > > +	idx = array_index_nospec(ext.property, ARRAY_SIZE(xe_set_eu_stall_property_funcs));
> > > > +	return xe_set_eu_stall_property_funcs[idx](xe, ext.value, props);
> > > > +}
> > > > +
> > > > +typedef int (*xe_eu_stall_user_extension_fn)(struct xe_device *xe, u64 extension,
> > > > +					     struct eu_stall_open_properties *props);
> > > > +static const xe_eu_stall_user_extension_fn xe_eu_stall_user_extension_funcs[] = {
> > > > +	[DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY] = xe_eu_stall_user_ext_set_property,
> > > > +};
> > > > +
> > > > +static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > > > +				       struct eu_stall_open_properties *props)
> > >
> > > What is the reason for not using the ext_number argument here, which is
> > > used in both exec_queue_user_extensions and in xe_oa_user_extensions?
> >
> > When I reused this code from the OA code it didn't have the ext_number.
> > I will check that out and make the change.
> > >
> > > The reason for ext_number is that the extensions can be chained in a loop,
> > > which can cause an infinite loop in the kernel when parsing these
> > > extensions. ext_number is used to break out of these potential infinite
> > > loops.
> > >
> > > > +{
> > > > +	u64 __user *address = u64_to_user_ptr(extension);
> > > > +	struct drm_xe_user_extension ext;
> > > > +	int err;
> > > > +	u32 idx;
> > > > +
> > > > +	err = __copy_from_user(&ext, address, sizeof(ext));
> > > > +	if (XE_IOCTL_DBG(xe, err))
> > > > +		return -EFAULT;
> > > > +
> > > > +	if (XE_IOCTL_DBG(xe, ext.pad) ||
> > > > +	    XE_IOCTL_DBG(xe, ext.name >= ARRAY_SIZE(xe_eu_stall_user_extension_funcs)))
> > > > +		return -EINVAL;
> > > > +
> > > > +	idx = array_index_nospec(ext.name, ARRAY_SIZE(xe_eu_stall_user_extension_funcs));
> > > > +	err = xe_eu_stall_user_extension_funcs[idx](xe, extension, props);
> > > > +	if (XE_IOCTL_DBG(xe, err))
> > > > +		return err;
> > > > +
> > > > +	if (ext.next_extension)
> > > > +		return xe_eu_stall_user_extensions(xe, ext.next_extension, props);
> > > > +
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> > > > + *
> > > > + * @file: An xe EU stall data stream file
> > > > + * @buf: destination buffer given by userspace
> > > > + * @count: the number of bytes userspace wants to read
> > > > + * @ppos: (inout) file seek position (unused)
> > > > + *
> > > > + * Userspace must enable the EU stall stream with DRM_XE_OBSERVATION_IOCTL_ENABLE
> > > > + * before calling read().
> > >
> > > We can just retain these two lines of comment. See below.
> > >
> > > > + *
> > > > + * Returns: The number of bytes copied or a negative error code on failure.
> > > > + */
> > > > +static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > > > +				       size_t count, loff_t *ppos)
> > > > +{
> > > > +	ssize_t ret = 0;
> > > > +
> > > > +	return ret;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> > > > + *
> > > > + * @file: An xe EU stall data stream file
> > > > + * @wait: Poll table
> > > > + *
> > > > + * Returns: Bit mask of returned events.
> > > > + */
> > > > +static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> > > > +{
> > > > +	__poll_t ret = 0;
> > > > +
> > > > +	return ret;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eu_stall_stream_ioctl - support ioctl() of a xe EU stall data stream fd.
> > > > + *
> > > > + * @file: An xe EU stall data stream file
> > > > + * @cmd: the ioctl request
> > > > + * @arg: the ioctl data
> > > > + *
> > > > + * Returns: zero on success or a negative error code.
> > > > + *	    -EINVAL for an unknown ioctl request.
> > > > + */
> > > > +static long xe_eu_stall_stream_ioctl(struct file *file,
> > > > +				     unsigned int cmd,
> > > > +				     unsigned long arg)
> > > > +{
> > > > +	switch (cmd) {
> > > > +	case DRM_XE_OBSERVATION_IOCTL_ENABLE:
> > > > +		return 0;
> > > > +	case DRM_XE_OBSERVATION_IOCTL_DISABLE:
> > > > +		return 0;
> > > > +	}
> > > > +
> > > > +	return -EINVAL;
> > >
> > > Just return 0 or -EINVAL in this patch since you are going to add locking
> > > in a later patch.
> > You mean remove the switch statement completely and just return 0 or
> > EINVAL? The intention of this switch statement is to specify the two
> > IOCTLs that will be supported in the uAPI.
> 
> Each patch just has to compile and pass checkpatch. You can add the switch
> statement in the later patch which adds locking, in
> xe_eu_stall_stream_ioctl_locked (to avoid unnecessary code movement, see
> deleted lines in that patch).
> 
> > >
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eu_stall_stream_close - handles userspace close() of a EU stall data
> > > > + *			      stream file.
> > > > + * @inode: anonymous inode associated with file
> > > > + * @file: An xe EU stall data stream file
> > > > + *
> > > > + * Cleans up any resources associated with an open EU stall data stream file.
> > > > + */
> > >
> > > As I said before, these comments are completely redundant. These are
> > > standard file_operations. There are one million instances of these in the
> > > kernel, all of them have exactly the same arguments.
> > >
> > > If you have anything specific to EU stall here, we can leave it. Otherwise
> > > I'd still say get rid of them.
> > >
> > > Or get rid them now and send a patch later to add them, we can review that
> > > patch later, if you really think they add value. They were included in
> > > i915_perf.c, but I don't think they should be in Xe.
> > >
> > > If you think these comments should be there, let's get a second opinion,
> > > from one of the maintainers.
> > >
> > Okay, will get feedback from a maintainer and will update.
> > > > +static int xe_eu_stall_stream_close(struct inode *inode, struct file *file)
> > > > +{
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +static const struct file_operations fops_eu_stall = {
> > > > +	.owner		= THIS_MODULE,
> > > > +	.llseek		= noop_llseek,
> > > > +	.release	= xe_eu_stall_stream_close,
> > > > +	.poll		= xe_eu_stall_stream_poll,
> > > > +	.read		= xe_eu_stall_stream_read,
> > > > +	.unlocked_ioctl = xe_eu_stall_stream_ioctl,
> > > > +	.compat_ioctl   = xe_eu_stall_stream_ioctl,
> > > > +};
> > > > +
> > > > +static inline bool has_eu_stall_sampling_support(struct xe_device *xe)
> > > > +{
> > > > +	return false;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eu_stall_stream_open - Open a xe EU stall data stream fd
> > > > + *
> > > > + * @dev: DRM device pointer
> > > > + * @data: pointer to first struct @drm_xe_ext_set_property in
> > > > + *	  the chain of input properties from the user space.
> > > > + * @file: DRM file pointer
> > > > + *
> > > > + * This function opens a EU stall data stream with input properties from
> > > > + * the user space.
> > > > + *
> > > > + * Returns: EU stall data stream fd on success or a negative error code.
> > > > + */
> > > > +int xe_eu_stall_stream_open(struct drm_device *dev,
> > > > +			    u64 data,
> > > > +			    struct drm_file *file)
> > > > +{
> > > > +	struct xe_device *xe = to_xe_device(dev);
> > > > +	struct eu_stall_open_properties props = {};
> > > > +	int ret, stream_fd;
> > > > +
> > > > +	if (xe_observation_paranoid && !perfmon_capable()) {
> > > > +		xe_gt_dbg(props.gt, "Insufficient privileges for EU stall monitoring\n");
> > > > +		return -EACCES;
> > > > +	}
> > > > +	if (!has_eu_stall_sampling_support(xe)) {
> > > > +		xe_gt_dbg(props.gt, "EU stall monitoring is not supported on this platform\n");
> > > > +		return -EPERM;
> > >
> > > I think we are using -ENODEV for this, at least in OA.
> > Okay.
> > >
> > > > +	}
> > >
> > > Move this has_eu_stall_sampling_support at the top, this should be even
> > > before the perfmon_capable check.
> > Will move.
> > >
> > > > +
> > > > +	ret = xe_eu_stall_user_extensions(xe, data, &props);
> > > > +	if (ret)
> > > > +		return ret;
> > > > +
> > > > +	if (!props.gt) {
> > > > +		drm_dbg(&xe->drm, "GT ID not provided for EU stall sampling\n");
> > > > +		return -EINVAL;
> > > > +	}
> > >
> > > This check is not needed. props.gt cannot be NULL the way
> > > set_prop_eu_stall_gt_id is implemented.
> > If the user doesn't pass a GT ID, it will be NULL.
> 
> Yeah I commented on this later. Depends on whether we use a default gt_id
> of 0 or not.
> 
> > >
> > > If you need it, use xe_assert(props->gt) in set_prop_eu_stall_gt_id.
> > >
> > > > +
> > > > +	stream_fd = anon_inode_getfd("[xe_eu_stall]", &fops_eu_stall, NULL, 0);
> > > > +	if (stream_fd < 0)
> > > > +		xe_gt_dbg(props.gt, "EU stall inode get fd failed : %d\n", stream_fd);
> > > > +
> > > > +	return stream_fd;
> > > > +}
> > > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.h b/drivers/gpu/drm/xe/xe_eu_stall.h
> > > > new file mode 100644
> > > > index 000000000000..d514e78341d5
> > > > --- /dev/null
> > > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.h
> > > > @@ -0,0 +1,16 @@
> > > > +/* SPDX-License-Identifier: MIT */
> > > > +/*
> > > > + * Copyright © 2025 Intel Corporation
> > > > + */
> > > > +
> > > > +#ifndef __XE_EU_STALL_H__
> > > > +#define __XE_EU_STALL_H__
> > > > +
> > > > +#include <drm/drm_device.h>
> > > > +#include <drm/drm_file.h>
> > > > +#include <linux/types.h>
> > >
> > > Because these lines are replaced in a future patch with '#include
> > > "xe_gt_types.h"', just do that in this patch itself.
> > Okay.
> > >
> > > Also, as I said, I am not going to focus too much on the patches, only the
> > > final code, but in general, if you are deleting lines in these initial
> > > patches, think hard about why you need delete those lines and what you
> > > could do differently.
> > >
> > > > +
> > > > +int xe_eu_stall_stream_open(struct drm_device *dev,
> > > > +			    u64 data,
> > > > +			    struct drm_file *file);
> > > > +#endif
> > > > diff --git a/drivers/gpu/drm/xe/xe_observation.c b/drivers/gpu/drm/xe/xe_observation.c
> > > > index 8ec1b84cbb9e..cca661de60ac 100644
> > > > --- a/drivers/gpu/drm/xe/xe_observation.c
> > > > +++ b/drivers/gpu/drm/xe/xe_observation.c
> > > > @@ -9,6 +9,7 @@
> > > >  #include <uapi/drm/xe_drm.h>
> > > >
> > > >  #include "xe_oa.h"
> > > > +#include "xe_eu_stall.h"
> > > >  #include "xe_observation.h"
> > > >
> > > >  u32 xe_observation_paranoid = true;
> > > > @@ -29,6 +30,17 @@ static int xe_oa_ioctl(struct drm_device *dev, struct drm_xe_observation_param *
> > > >	}
> > > >  }
> > > >
> > > > +static int xe_eu_stall_ioctl(struct drm_device *dev, struct drm_xe_observation_param *arg,
> > > > +			     struct drm_file *file)
> > > > +{
> > > > +	switch (arg->observation_op) {
> > > > +	case DRM_XE_OBSERVATION_OP_STREAM_OPEN:
> > > > +		return xe_eu_stall_stream_open(dev, arg->param, file);
> > > > +	default:
> > > > +		return -EINVAL;
> > > > +	}
> > > > +}
> > > > +
> > > >  /**
> > > >   * xe_observation_ioctl - The top level observation layer ioctl
> > > >   * @dev: @drm_device
> > > > @@ -51,6 +63,8 @@ int xe_observation_ioctl(struct drm_device *dev, void *data, struct drm_file *fi
> > > >	switch (arg->observation_type) {
> > > >	case DRM_XE_OBSERVATION_TYPE_OA:
> > > >		return xe_oa_ioctl(dev, arg, file);
> > > > +	case DRM_XE_OBSERVATION_TYPE_EU_STALL:
> > > > +		return xe_eu_stall_ioctl(dev, arg, file);
> > > >	default:
> > > >		return -EINVAL;
> > > >	}
> > > > diff --git a/include/uapi/drm/xe_drm.h b/include/uapi/drm/xe_drm.h
> > > > index 892f54d3aa09..1d79621f267b 100644
> > > > --- a/include/uapi/drm/xe_drm.h
> > > > +++ b/include/uapi/drm/xe_drm.h
> > > > @@ -1496,6 +1496,8 @@ struct drm_xe_wait_user_fence {
> > > >  enum drm_xe_observation_type {
> > > >	/** @DRM_XE_OBSERVATION_TYPE_OA: OA observation stream type */
> > > >	DRM_XE_OBSERVATION_TYPE_OA,
> > > > +	/** @DRM_XE_OBSERVATION_TYPE_EU_STALL: EU stall sampling observation stream type */
> > > > +	DRM_XE_OBSERVATION_TYPE_EU_STALL,
> > > >  };
> > > >
> > > >  /**
> > > > @@ -1848,6 +1850,42 @@ enum drm_xe_pxp_session_type {
> > > >  /* ID of the protected content session managed by Xe when PXP is active */
> > > >  #define DRM_XE_PXP_HWDRM_DEFAULT_SESSION 0xf
> > > >
> > > > +/**
> > > > + * enum drm_xe_eu_stall_property_id - EU stall sampling input property ids.
> > > > + *
> > > > + * These properties are passed to the driver at open as a chain of
> > > > + * @drm_xe_ext_set_property structures with @property set to these
> > > > + * properties' enums and @value set to the corresponding values of these
> > > > + * properties. @drm_xe_user_extension base.name should be set to
> > > > + * @DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY.
> > > > + *
> > > > + * With the file descriptor obtained from open, user space must enable
> > > > + * the EU stall stream fd with @DRM_XE_OBSERVATION_IOCTL_ENABLE before
> > > > + * calling read(). EIO errno from read() indicates HW dropped data
> > > > + * due to full buffer.
> > > > + */
> > > > +enum drm_xe_eu_stall_property_id {
> > > > +#define DRM_XE_EU_STALL_EXTENSION_SET_PROPERTY		0
> > > > +	/**
> > > > +	 * @DRM_XE_EU_STALL_PROP_GT_ID: @gt_id of the GT on which
> > > > +	 * EU stall data will be captured.
> > > > +	 */
> > > > +	DRM_XE_EU_STALL_PROP_GT_ID = 1,
> > > > +
> > > > +	/**
> > > > +	 * @DRM_XE_EU_STALL_PROP_SAMPLE_RATE: Sampling rate
> > > > +	 * in GPU cycles.
> > > > +	 */
> > > > +	DRM_XE_EU_STALL_PROP_SAMPLE_RATE,
> > > > +
> > > > +	/**
> > > > +	 * @DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS: Minimum number of
> > > > +	 * EU stall data reports to be present in the kernel buffer
> > > > +	 * before unblocking poll or read that is blocked.
> > >
> > > before unblocking a blocked poll or read
> > Okay
> > >
> > > > +	 */
> > > > +	DRM_XE_EU_STALL_PROP_WAIT_NUM_REPORTS,
> > > > +};
> > > > +
> > > >  #if defined(__cplusplus)
> > > >  }
> > > >  #endif
> > > > --
> > > > 2.48.1
> > > >
> >
> > Thank you
> > Harish.

Re: [PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Dixit, Ashutosh]

On Sat, 15 Feb 2025 17:49:16 -0800, Harish Chegondi wrote:
>
> > > > > +struct eu_stall_open_properties {
> > > > > +	unsigned int sampling_rate_mult;
> > > > > +	unsigned int wait_num_reports;
> > > >
> > > > I already said no need to be so specific. Just use int or u32 as types for
> > > > these.
> > > Okay, will try to change these back to u8/u32 in the next version.
> >
> > Use int or u32, not u8.
> Any reason why I can't use u8? The maximum value of sampling_rate_mult
> is 7.

Use whatever you want. The real question to ask is why can't we use a
generic type like int? Whether you use u8 or int, the CPU will still fetch
a 64 byte cacheline. And this structure is only used at initialization, so
performance is not a concern.

Re: [PATCH v9 4/8] drm/xe/eustall: Add support to read() and poll() EU stall data

[Harish Chegondi]

On Fri, Feb 14, 2025 at 06:22:08PM -0800, Dixit, Ashutosh wrote:
> On Fri, 14 Feb 2025 16:44:26 -0800, Harish Chegondi wrote:
> >
> > On Fri, Feb 14, 2025 at 12:34:26PM -0800, Dixit, Ashutosh wrote:
> > > On Thu, 13 Feb 2025 23:51:54 -0800, Harish Chegondi wrote:
> > > >
> > >
> > > Hi Harish,
> > >
> > > > On Wed, Feb 12, 2025 at 11:02:07AM -0800, Dixit, Ashutosh wrote:
> > > > > On Mon, 10 Feb 2025 05:46:45 -0800, Harish Chegondi wrote:
> > > > > >
> > > > >
> > > > > > Implement the EU stall sampling APIs to read() and poll() EU stall data.
> > > > > > A work function periodically polls the EU stall data buffer write pointer
> > > > > > registers to look for any new data and caches the write pointer. The read
> > > > > > function compares the cached read and write pointers and copies any new
> > > > > > data to the user space.
> > > > > >
> > > > > > v9:  New patch split from the previous patch.
> > > > > >      Used *_delayed_work functions instead of hrtimer
> > > > > >      Addressed the review feedback in read and poll functions
> > > > > >
> > > > > > Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
> > > > > > ---
> > > > > >  drivers/gpu/drm/xe/xe_eu_stall.c | 267 ++++++++++++++++++++++++++++++-
> > > > > >  drivers/gpu/drm/xe/xe_trace.h    |  33 ++++
> > > > > >  2 files changed, 298 insertions(+), 2 deletions(-)
> > > > > >
> > > > > > diff --git a/drivers/gpu/drm/xe/xe_eu_stall.c b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > > index 12afa9720971..53f17aac7d3b 100644
> > > > > > --- a/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > > +++ b/drivers/gpu/drm/xe/xe_eu_stall.c
> > > > > > @@ -21,6 +21,7 @@
> > > > > >  #include "xe_macros.h"
> > > > > >  #include "xe_observation.h"
> > > > > >  #include "xe_pm.h"
> > > > > > +#include "xe_trace.h"
> > > > > >
> > > > > >  #include "regs/xe_eu_stall_regs.h"
> > > > > >  #include "regs/xe_gt_regs.h"
> > > > > > @@ -41,7 +42,9 @@ struct per_xecore_buf {
> > > > > >  };
> > > > > >
> > > > > >  struct xe_eu_stall_data_stream {
> > > > > > +	bool pollin;
> > > > > >	bool enabled;
> > > > > > +	wait_queue_head_t poll_wq;
> > > > > >	size_t data_record_size;
> > > > > >	size_t per_xecore_buf_size;
> > > > > >	unsigned int wait_num_reports;
> > > > > > @@ -50,6 +53,8 @@ struct xe_eu_stall_data_stream {
> > > > > >	struct xe_gt *gt;
> > > > > >	struct xe_bo *bo;
> > > > > >	struct per_xecore_buf *xecore_buf;
> > > > > > +	struct delayed_work buf_poll_work;
> > > > > > +	struct workqueue_struct *buf_poll_wq;
> > > > > >  };
> > > > > >
> > > > > >  struct xe_eu_stall_gt {
> > > > > > @@ -256,6 +261,190 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > > > > >	return 0;
> > > > > >  }
> > > > > >
> > > > > > +/**
> > > > > > + * buf_data_size - Calculate the number of bytes in a circular buffer
> > > > > > + *		   given the read and write pointers and the size of
> > > > > > + *		   the buffer.
> > > > > > + *
> > > > > > + * @buf_size: Size of the circular buffer
> > > > > > + * @read_ptr: Read pointer with an additional overflow bit
> > > > > > + * @write_ptr: Write pointer with an additional overflow bit
> > > > > > + *
> > > > > > + * Since the read and write pointers have an additional overflow bit,
> > > > > > + * this function calculates the offsets from the pointers and use the
> > > > > > + * offsets to calculate the data size in the buffer.
> > > > > > + *
> > > > > > + * Returns: number of bytes of data in the buffer
> > > > > > + */
> > > > > > +static u32 buf_data_size(size_t buf_size, u32 read_ptr, u32 write_ptr)
> > > > > > +{
> > > > > > +	u32 read_offset, write_offset, size = 0;
> > > > > > +
> > > > > > +	if (read_ptr == write_ptr)
> > > > > > +		goto exit;
> > > > > > +
> > > > > > +	read_offset = read_ptr & (buf_size - 1);
> > > > > > +	write_offset = write_ptr & (buf_size - 1);
> > > > > > +
> > > > > > +	if (write_offset > read_offset)
> > > > > > +		size = write_offset - read_offset;
> > > > > > +	else
> > > > > > +		size = buf_size - read_offset + write_offset;
> > > > > > +exit:
> > > > > > +	return size;
> > > > > > +}
> > > > >
> > > > > Looks good now :)
> > > > >
> > > > > > +
> > > > > > +/**
> > > > > > + * eu_stall_data_buf_poll - Poll for EU stall data in the buffer.
> > > > > > + *
> > > > > > + * @stream: xe EU stall data stream instance
> > > > > > + *
> > > > > > + * Returns: true if the EU stall buffer contains minimum stall data as
> > > > > > + *	    specified by the event report count, else false.
> > > > > > + */
> > > > > > +static bool eu_stall_data_buf_poll(struct xe_eu_stall_data_stream *stream)
> > > > > > +{
> > > > > > +	u32 read_ptr, write_ptr_reg, write_ptr, total_data = 0;
> > > > > > +	u32 buf_size = stream->per_xecore_buf_size;
> > > > > > +	struct per_xecore_buf *xecore_buf;
> > > > > > +	struct xe_gt *gt = stream->gt;
> > > > > > +	bool min_data_present = false;
> > > > > > +	u16 group, instance;
> > > > > > +	unsigned int xecore;
> > > > >
> > > > > u32 and move above to u32 line?
> > > > >
> > > > > > +
> > > > > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > > > > +		xecore_buf = &stream->xecore_buf[xecore];
> > > > > > +		mutex_lock(&xecore_buf->ptr_lock);
> > > > >
> > > > > One thing I am wondering about is: do we really need these per xecore_buf
> > > > > locks? How about moving ptr_lock into xe_eu_stall_data_stream and just
> > > > > cover for_each_dss_steering() calls with the ptr lock. Because the polling
> > > > > thread runs every 10 ms, this should give plenty of time for the polling
> > > > > thread and the reads to go through, even with lcontention. And it will
> > > > > eliminate all these locks and the locking/unlocking overhead.
> > > >
> > > > I used a per dss lock so that polling and read on two different
> > > > subslices can be done in parallel. I will try moving the ptr_lock into
> > > > xe_eu_stall_data_stream.
> > >
> > > If you do this, please rename it to dss_lock or something like that, to
> > > indicate it is guarding dss level info, not just the ptr's. Maybe rename
> > > the lock to dss_lock even if you end up not doing this.
> > >
> > > > >
> > > > > > +		read_ptr = xecore_buf->read;
> > > > > > +		write_ptr_reg = xe_gt_mcr_unicast_read(gt, XEHPC_EUSTALL_REPORT,
> > > > > > +						       group, instance);
> > > > > > +		write_ptr = REG_FIELD_GET(XEHPC_EUSTALL_REPORT_WRITE_PTR_MASK, write_ptr_reg);
> > > > > > +		write_ptr <<= 6;
> > > > > > +		write_ptr &= ((buf_size << 1) - 1);
> > > > > > +		if (write_ptr != read_ptr && !min_data_present) {
> > > > >
> > > > > Don't need to check for 'write_ptr != read_ptr' here, it's already
> > > > > happening in buf_data_size.
> > > >
> > > > Yes it is not needed. But eu_stall_data_buf_poll() is invoked approx every 10ms.
> > > > I am not an expert on compiler optimizations. If the compiler definitely
> > > > optimizes and prevents call to buf_data_size(), I can remove this check.
> > > > But if the compiler doesn't optimize, wouldn't this check help avoid
> > > > function calls given that this function gets executed every 10ms?
> > >
> > > The function is called every 10 ms * num_dss and then it is called every
> > > dss for every read(). Even then I am not sure why you are obsessed with the
> > > function call overhead. See here:
> > >
> > > https://github.com/torvalds/linux/blob/master/Documentation/process/4.Coding.rst#inline-functions
> > >
> > > Specially "The cost of a function call, after all, is not that high" (it is
> > > typically memory accesses which reduce performance, not code execution). I
> > > would let the compiler handle this sort of optimization and decide whether
> > > or not the function can be inlined.
> > >
> > > Another option is to use always_inline if you are really concerned:
> > > https://gcc.gnu.org/onlinedocs/gcc/Inline.html
> > >
> > >	static __always_inline u32 buf_data_size(...
> > >
> > > though I am not sure if just inline is already sufficient:
> > >
> > >	static inline u32 buf_data_size(...
> > >
> > > So let's do one of these two things and remove this check, I'll approve
> > > either. Sorry if I asked to remove inline earlier :/
> > Okay, I will remove the if write_ptr != read_ptr. But I am not sure if
> > want to add inline. My understanding is we only add inline for very
> > small functions.
> 
> You can add __always_inline, there are only 2 instances of this, it is a
> small function.
> 
> > >
> > > > >
> > > > > > +			total_data += buf_data_size(buf_size, read_ptr, write_ptr);
> > > > > > +			/*
> > > > > > +			 * Check if there are at least minimum number of stall data
> > > > > > +			 * rows for poll() to indicate that the data is present.
> > > > > > +			 * Each stall data row is 64B (cacheline size).
> > > > > > +			 */
> > > > >
> > > > > I'd say this comment is not needed and should be removed, the code below is
> > > > > clear enough.
> > > > Will remove.
> > > > >
> > > > > > +			if (num_data_rows(total_data) >= stream->wait_num_reports)
> > > > > > +				min_data_present = true;
> > > > > > +		}
> > > > > > +		xecore_buf->write = write_ptr;
> > > > > > +		mutex_unlock(&xecore_buf->ptr_lock);
> > > > > > +	}
> > > > > > +	return min_data_present;
> > > > > > +}
> > > > > > +
> > > > > > +static int xe_eu_stall_data_buf_read(struct xe_eu_stall_data_stream *stream,
> > > > > > +				     char __user *buf, size_t count,
> > > > > > +				     size_t *total_data_size, struct xe_gt *gt,
> > > > > > +				     u16 group, u16 instance, unsigned int xecore)
> > > > > > +{
> > > > > > +	size_t read_data_size, copy_size, buf_size, data_record_size;
> > > > > > +	u32 read_ptr_reg, read_ptr, write_ptr;
> > > > > > +	u8 *xecore_start_vaddr, *read_vaddr;
> > > > > > +	struct per_xecore_buf *xecore_buf;
> > > > > > +	u32 read_offset, write_offset;
> > > > > > +	int ret = 0;
> > > > > > +
> > > > > > +	/* Hardware increments the read and write pointers such that they can
> > > > > > +	 * overflow into one additional bit. For example, a 256KB size buffer
> > > > > > +	 * offset pointer needs 18 bits. But HW uses 19 bits for the read and
> > > > > > +	 * write pointers. This technique avoids wasting a slot in the buffer.
> > > > > > +	 * Read and write offsets are calculated from the pointers in order to
> > > > > > +	 * check if the write pointer has wrapped around the array.
> > > > > > +	 */
> > > > > > +	xecore_buf = &stream->xecore_buf[xecore];
> > > > > > +	mutex_lock(&xecore_buf->ptr_lock);
> > > > > > +	xecore_start_vaddr = xecore_buf->vaddr;
> > > > > > +	read_ptr = xecore_buf->read;
> > > > > > +	write_ptr = xecore_buf->write;
> > > > > > +	buf_size = stream->per_xecore_buf_size;
> > > > > > +	data_record_size = stream->data_record_size;l> > +
> > > > > > +	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> > > > > > +	/* Read only the data that the user space buffer can accommodate */
> > > > > > +	if ((*total_data_size + read_data_size) > count) {
> > > > > > +		read_data_size = count - *total_data_size;
> > > > > > +		read_data_size = (read_data_size / data_record_size) * data_record_size;
> > > > > > +	}
> > > > >
> > > > > As I said, my preferred way of writing this is as follows. Isn't this cleaner?
> > > >
> > > > Most of the times, the if condition would evaluate false and the body of
> > > > the if statement would not be executed. Whereas in your code the two
> > > > lines of code get executed all the time.
> > >
> > > The only thing extra which maybe gets executed unconditionally in my code
> > > is the ALIGN_DOWN line. the min_t() part gets executed for you too in the
> > > if () check. Correct?
> > >
> > > But once again you seem to be obsessed with these micro optimizations: it
> > > is not that simple:
> > >
> > > 1. We don't know how the compiler will optimize
> > > 2. The CPU itself does out-of-order and speculative execution, branch
> > >    prediction etc. So for you the CPU might actually be executing the code
> > >    in the if () statement (both when result of the if is true and when it
> > >    is false and then discarding the branch which is not taken).
> > > 3. Execution speed is driven more by memory accesses and lock contention
> > >    rather than code execution itself. So mostly code stalls at locks and
> > >    for memory accesses to complete.
> > >
> > > So with all this going on, my rule is to only make easy to understand and
> > > maintain. And let the compiler and CPU take care of running the code
> > > efficiently. Of course we can't do ridiculous things, which we are not
> > > doing here.
> > >
> > > Also, since you are obsessed with optimization, ALIGN_DOWN() uses bit
> > > operations (AND etc.), rather than integer division, so is more
> > > efficient. Also, use of pre-established, standard macros, like min_t and
> > > ALIGN_DOWN, is preferable, rather than rolling your own new code.
> > >
> > > > >
> > > > >	read_data_size = buf_data_size(buf_size, read_ptr, write_ptr);
> > > > >	XE_WARN_ON(count >= *total_size);
> > > > Wouldn't count (size of the user buffer) be greater than the total_size
> > > > most of the time? I am still not convinced with having a WARN_ON here.
> > >
> > > Sorry, I meant an xe_assert() here:
> > >
> > >	xe_assert(xe, count >= *total_size);
> > >
> > > To make sure that (count - *total_size >= 0) in the min_t statement
> > > below. So if we use XE_WARN_ON(), this would become:
> > >
> > >	XE_WARN_ON(count < *total_size);
> > The code has sufficient checks to make sure this doesn't happen.
> 
> OK.
> 
> > >
> > > So either is ok. I think it is good to have it.
> > >
> > > > >	read_data_size = min_t(size_t, count - *total_size, read_data_size);
> > > > >	read_data_size = ALIGN_DOWN(read_data_size, data_record_size);
> > We don't need this ALIGN_DOWN() here if we have the ALIGN_DOWN() you
> > suggested down below.
> 
> Yes, you are right, good catch.
> 
> > > > >
> > > > > Since data_record_size has to be a power of 2 for this to work (which it
> > > > > is), I would even put a
> > > > data_record_size is fixed in the hardware. As of now for both PVC and
> > > > xe2, it is 64 which is a power of 2. I am guessing that it will remain a
> > > > power of 2 in the future too. Why should we put an assert for the record
> > > > size which is determined in the hardware?
> > >
> > > Because we are explicitly making use of the property that data_record_size
> > > is a power of 2 in our code. The ALIGN_DOWN results will be wrong if
> > > somehow data_record_size were not a power of 2.
> > >
> > > And it also makes clear that the code is using this property and will break
> > > if it were to be false.
> > >
> > > That is the purpose of the assert(). If we weren't making use of that
> > > property in *our* code, we wouldn't need the assert.
> > >
> > > > >
> > > > >	xe_assert(xe, is_power_of_2(record_size));
> > > > >
> > > > > in xe_eu_stall_data_record_size().
> > > > >
> > > > >
> > > > > > +	if (read_data_size == 0)
> > > > > > +		goto exit;
> > > > > > +
> > > > > > +	read_offset = read_ptr & (buf_size - 1);
> > > > > > +	write_offset = write_ptr & (buf_size - 1);
> > > > > > +	read_vaddr = xecore_start_vaddr + read_offset;
> > > > > > +
> > > > > > +	if (write_offset > read_offset) {
> > > > > > +		if (copy_to_user((buf + *total_data_size), read_vaddr, read_data_size)) {
> > > > >
> > > > > internal brackets not needed     ^
> > > > >
> > > > > > +			ret = -EFAULT;
> > > > > > +			goto exit;
> > > > > > +		}
> > > > > > +	} else {
> > > > > > +		if (read_data_size >= (buf_size - read_offset))
> > > > >
> > > > > internal brackets not needed          ^
> > > > >
> > > > > > +			copy_size = buf_size - read_offset;
> > > > > > +		else
> > > > > > +			copy_size = read_data_size;
> > > > >
> > > > > if (write_offset < read_offset) how is this 'else' ever possible? So
> > > > > shouldn't copy_size just be set unconditionally to 'buf_size -
> > > > > read_offset'?
> > > > If the user buffer doesn't have enough space to accommodate
> > > > (buf_size - read_offset) bytes, the else will get executed.
> > >
> > > Sorry, yes, you are right here.
> > >
> > > > >
> > > > > > +		if (copy_to_user((buf + *total_data_size), read_vaddr, copy_size)) {
> > > > >
> > > > > internal brackets not needed     ^
> > > > >
> > > > > > +			ret = -EFAULT;
> > > > > > +			goto exit;
> > > > > > +		}
> > > > > > +		if (copy_to_user((buf + *total_data_size + copy_size),
> > > > >
> > > > > internal brackets not needed     ^
> > > > >
> > > > > > +				 xecore_start_vaddr, read_data_size - copy_size)) {
> > > > > > +			ret = -EFAULT;
> > > > > > +			goto exit;
> > > > > > +		}
> > > > > > +	}
> > > > > > +
> > > > > > +	*total_data_size += read_data_size;
> > > > > > +	read_ptr += read_data_size;
> > > > >
> > > > > Because there is an overflow bit we can just add without worrying about
> > > > > wraparound?
> > > > I want to make sure only one overflow bit is used and doesn't overflow
> > > > into the second bit.
> > >
> > > OK, I don't follow, but this was just something I was trying to confirm, so
> > > ignore this comment. The code is fine because of the overflow bits.
> > >
> > > > >
> > > > > > +
> > > > > > +	/* Read pointer can overflow into one additional bit */
> > > > > > +	read_ptr &= (buf_size << 1) - 1;
> > > > > > +	read_ptr_reg = REG_FIELD_PREP(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, (read_ptr >> 6));
> > > > > > +	read_ptr_reg = _MASKED_FIELD(XEHPC_EUSTALL_REPORT1_READ_PTR_MASK, read_ptr_reg);
> > > > > > +	xe_gt_mcr_unicast_write(gt, XEHPC_EUSTALL_REPORT1, read_ptr_reg, group, instance);
> > > > > > +	xecore_buf->read = read_ptr;
> > > > > > +	trace_xe_eu_stall_data_read(group, instance, read_ptr, write_ptr,
> > > > > > +				    read_offset, write_offset, *total_data_size);
> > > > > > +exit:
> > > > > > +	mutex_unlock(&xecore_buf->ptr_lock);
> > > > > > +	return ret;
> > > > > > +}
> > > > > > +
> > > > > > +/**
> > > > > > + * xe_eu_stall_stream_read_locked - copy EU stall counters data from the
> > > > > > + *				    per xecore buffers to the userspace buffer
> > > > > > + * @stream: A stream opened for EU stall count metrics
> > > > > > + * @file: An xe EU stall data stream file
> > > > > > + * @buf: destination buffer given by userspace
> > > > > > + * @count: the number of bytes userspace wants to read
> > > > > > + *
> > > > > > + * Returns: Number of bytes copied or a negative error code
> > > > > > + * If we've successfully copied any data then reporting that takes
> > > > > > + * precedence over any internal error status, so the data isn't lost.
> > > > > > + */
> > > > > > +static ssize_t xe_eu_stall_stream_read_locked(struct xe_eu_stall_data_stream *stream,
> > > > > > +					      struct file *file, char __user *buf,
> > > > > > +					      size_t count)
> > > > > > +{
> > > > > > +	struct xe_gt *gt = stream->gt;
> > > > > > +	size_t total_size = 0;
> > > > > > +	u16 group, instance;
> > > > > > +	unsigned int xecore;
> > > > > > +	int ret = 0;
> > > > > > +
> > > > > > +	for_each_dss_steering(xecore, gt, group, instance) {
> > > > > > +		ret = xe_eu_stall_data_buf_read(stream, buf, count, &total_size,
> > > > > > +						gt, group, instance, xecore);
> > > > > > +		if (ret || count == total_size)
> > > > > > +			break;
> > > > > > +	}
> > > > > > +	return total_size ?: (ret ?: -EAGAIN);
> > > > > > +}
> > > > > > +
> > > > > >  /**
> > > > > >   * xe_eu_stall_stream_read - handles userspace read() of a EU stall data stream fd.
> > > > > >   *
> > > > > > @@ -272,7 +461,35 @@ static int xe_eu_stall_user_extensions(struct xe_device *xe, u64 extension,
> > > > > >  static ssize_t xe_eu_stall_stream_read(struct file *file, char __user *buf,
> > > > > >				       size_t count, loff_t *ppos)
> > > > > >  {
> > > > > > -	ssize_t ret = 0;
> > > > > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > > > > +	struct xe_gt *gt = stream->gt;
> > > > > > +	ssize_t ret;
> > > > > > +
> > > > > > +	if (count == 0)
> > > > > > +		return -EINVAL;
> > > > >
> > > > > I believe we need to also handle the fact that count might not be a
> > > > > multiple of record_size. The easiest way to handle this seems to be right
> > > > > here:
> > > > >	ssize_t aligned_count = ALIGN_DOWN(count, stream->data_record_size);
> > If we consider the aligned_count here, we don't need the ALIGN_DOWN()
> > you suggested above.
> 
> Agreed, correct!
> 
> > > > I think the code handles buffer sizes that are not multiples of record
> > > > size. Copying few lines of code below. Wouldn't read_data_size be only a
> > > > multiple of record size ? and leave any remaining space empty that is
> > > > not a multiple of record size ?
> > > > /* Read only the data that the user space buffer can accommodate */
> > > > if ((*total_data_size + read_data_size) > count) {
> > > >	read_data_size = count - *total_data_size;
> > > >	read_data_size = (read_data_size / data_record_size) * data_record_size;
> > > >
> > >
> > > No, I don't think it is handled. The issue is we have this check here:
> > >
> > > xe_eu_stall_stream_read_locked()
> > > {
> > >	...
> > >		if (ret || count == total_size)
> > >			break;
> > > }
> > >
> > > And if count is not a multiple of record_size, the 'count == total_size'
> > > will never be true, I think. Since total_size returned by
> > > xe_eu_stall_data_buf_read() is always a multiple of record_size.
> > >
> > > > >
> > > > > And used aligned_count rather than count in xe_eu_stall_stream_read_locked
> > > > > calls. So that we don't have to worry about this in later function calls.
> > > > >
> > > > > So above will become:
> > > > >
> > > > >	if (aligned_count == 0)
> > > > >		return -EINVAL;
> > > > >
> > > > > Unless there is a minimum user buffer size we want to support, in that case
> > > > > this becomes:
> > > > >
> > > > >	if (aligned_count < minimum_user_buffer_size)
> > > > >		return -EINVAL;
> > > > >
> > > > > But to me looks like a good value for minimum_user_buffer_size is not
> > > > > available.
> > > > I guess the minimum user buffer size should be the data record size (64
> > > > for PVC and Xe2)? If smaller than the record size, the drive will be
> > > > unable to copy any data.
> > >
> > > That is this check:
> > >
> > >	if (aligned_count == 0)
> > >		return -EINVAL;
> > >
> > > Apart from that, is there a minimum_user_buffer_size which is greater than
> > > record_size? That is why I was saying it is not available.
> > >
> > > > >
> > > > > Anyway, better to handle this degenerate case here itself.
> > > > >
> > > > > > +
> > > > > > +	if (!stream->enabled) {
> > > > > > +		xe_gt_dbg(gt, "EU stall data stream not enabled to read\n");
> > > > > > +		return -EINVAL;
> > > > > > +	}
> > I will remove this check. User space should be able to read any last
> > remaining data even after EU stall is disabled.
> 
> I would advise against it. You will need to carefully consider the
> consequences of allowing reads in disabled state. When there is no data in
> disabled state (after the initial data has been read):
> 
> * Non-blocking reads will return -EAGAIN, so that is ok
> * Blocking reads will indefinitely block, unless userland unblocks these
>   via a signal.
> 
> Why can't userland read all data and then disable the stream? What kind of
> a requirement is that?
> 
> They run a workload to capture some stats. They should:
> 	1. stop the workload
> 	2. get all data for the workload: read() till non-blocking reads
> 	   return -EAGAIN or blocking reads block (unblock using signal). I
> 	   am assuming if nothing is running on the EU's there is no data?
> 	3. finally disable the stream.
> 
> So if they do that, we don't allow reading any data in disabled state.
> 
> And anyway, this is what we can implement initially. If they don't agree we
> can later add a patch to change the behavior. But they need to convince us
> why they can't do what I just said above. Our default behavior should be to
> not allow reads in disabled state, I think.
> 
> > > > > > +
> > > > > > +	if (!(file->f_flags & O_NONBLOCK)) {
> > > > > > +		do {
> > > > > > +			ret = wait_event_interruptible(stream->poll_wq, stream->pollin);
> > > > > > +			if (ret)
> > > > > > +				return -EINTR;
> > > > > > +
> > > > > > +			mutex_lock(&gt->eu_stall->stream_lock);
> > > > > > +			ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > > > > +			mutex_unlock(&gt->eu_stall->stream_lock);
> > > > > > +		} while (ret == -EAGAIN);
> > > > > > +	} else {
> > > > > > +		mutex_lock(&gt->eu_stall->stream_lock);
> > > > > > +		ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > > > > +		mutex_unlock(&gt->eu_stall->stream_lock);
> > > > > > +	}
> > > > > > +
> > > > > > +	stream->pollin = false;
> > > > >
> > > > > Carry over comment from previous rev: this breaks if user buffer is smaller
> > > > > than available data. But this is a corner case so let's fix this after the
> > > > > initial merge.
> > > > I will check your fix in OA to better understand the problem here. If
> > > > the user buffer is smaller than data record size, it just returns
> > > > without copying any data.
> > >
> > > No, it is the issue when user buffer is larger than record_size, but still
> > > smaller than the size of total data available. In that case, basically we
> > > should let stream->pollin set to true, so that the user thread does not get
> > > blocked, enabling it to rapidly consume data, even with a small buffer.
> > >
> > > Otherwise the thread is getting blocked every 10 ms, even when data is
> > > available. And because new data keeps arriving, the user thread constantly
> > > falls behind and soon HW will start dropping data (because the kernel is
> > > blocking the user thread, it's a kernel not a user thread issue)
> > >
> > > To handle this OA does:
> > >
> > >	if (ret != -ENOSPC && ret != -EIO)
> > EU stall read() never returns -ENOSPC. Even if the user buffer is
> > smaller then the size of total data in the buffer, only the data that
> > can fit into the user buffer will be copied through read().
> 
> OA read() also doesn't return -ENOSPC to userland. That is the expected
> read() behavior (return number of bytes if you are returning any data). The
> full code is this:
> 
>         if (ret != -ENOSPC && ret != -EIO)
>                 stream->pollin = false;
> 
>         return offset ?: (ret ?: -EAGAIN);
> 
> > As long as there are atleast wait_num_reports data rows in the buffer,
> > stream->pollin is set to true. It sounds to me that this issue is
> > specific to OA code only. Is there something that I missed?
> 
> No this issue is there in EU stall code. You should not block reads till
> the next time the polling thread runs, if we could not copy all data in the
> previous read (because there already is data, don't block the user thread).
The polling thread runs approximately once every 10ms. The question here
is what would be time duration between two successive reads from the
user space with no additional delay between them. If the duration is
more than 10ms, the polling thread would set pollin to true. If not,
the issue you have mentioned would occur. However, I am changing the
code here to this:

        if (!eu_stall_data_buf_poll(stream))
                stream->pollin = false;

Wouldn't this fix the issue?

> 
> > >		stream->pollin = false;
> > >
> > > Anyway, we can do this after the initial merge.
> > >
> > > > >
> > > > > Let's put it a list of to be done's in the cover letter to do after we
> > > > > merge in the next revision.
> > > > Okay.
> > > > >
> > > > > >
> > > > > >	return ret;
> > > > > >  }
> > > > > > @@ -281,6 +498,7 @@ static void free_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream)
> > > > > >  {
> > > > > >	if (stream->bo)
> > > > > >		xe_bo_unpin_map_no_vm(stream->bo);
> > > > > > +	destroy_workqueue(stream->buf_poll_wq);
> > > > >
> > > > > Don't put this here in free_eu_stall_data_buf, put this in the caller of
> > > > > this function, like the destroy/close function.
> > > > >
> > > > > >  }
> > > > > >
> > > > > >  static int alloc_eu_stall_data_buf(struct xe_eu_stall_data_stream *stream,
> > > > > > @@ -351,6 +569,21 @@ static int xe_eu_stall_stream_enable(struct xe_eu_stall_data_stream *stream)
> > > > > >	return 0;
> > > > > >  }
> > > > > >
> > > > > > +static void eu_stall_data_buf_poll_work_fn(struct work_struct *work)
> > > > > > +{
> > > > > > +	struct xe_eu_stall_data_stream *stream =
> > > > > > +		container_of(work, typeof(*stream), buf_poll_work.work);
> > > > > > +
> > > > > > +	if (eu_stall_data_buf_poll(stream)) {
> > > > > > +		stream->pollin = true;
> > > > > > +		wake_up(&stream->poll_wq);
> > > > > > +	}
> > > > > > +	if (stream->enabled)
> > > > >
> > > > > See comment at xe_eu_stall_disable_locked. If we do
> > > > > cancel_delayed_work_sync there, I think this stream->enabled check might
> > > > I will explain later why I used flush_delayed_work() instead of
> > > > cancel_delayed_work_sync()
> > >
> > > See below.
> > >
> > > > > not be needed here. Also see comments at cancel_work_sync in
> > > > > kernel/workqueue.c.
> > > > >
> > > > > Could you please check and see if it works out. xe_guc_ct.c (and
> > > > > xe_gt_tlb_invalidation.c) seem to be doing that.
> > > > >
> > > > > > +		queue_delayed_work(stream->buf_poll_wq,
> > > > > > +				   &stream->buf_poll_work,
> > > > > > +				   msecs_to_jiffies(POLL_PERIOD_MS));
> > > > > > +}
> > > > > > +
> > > > > >  static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > > > >				   struct eu_stall_open_properties *props)
> > > > > >  {
> > > > > > @@ -361,6 +594,11 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > > > >	u32 vaddr_offset;
> > > > > >	int ret, xecore;
> > > > > >
> > > > > > +	init_waitqueue_head(&stream->poll_wq);
> > > > > > +	INIT_DELAYED_WORK(&stream->buf_poll_work, eu_stall_data_buf_poll_work_fn);
> > > > > > +	stream->buf_poll_wq = alloc_ordered_workqueue("xe_eu_stall", 0);
> > > > > > +	if (!stream->buf_poll_wq)
> > > > > > +		return -ENOMEM;
> > > > >
> > > > > Now we also need to destroy_workqueue during error unwinding (see comments
> > > > > regarding this in Patch 3).
> > > > >
> > > > > >	stream->sampling_rate_mult = props->sampling_rate_mult;
> > > > > >	stream->wait_num_reports = props->wait_num_reports;
> > > > > >	stream->per_xecore_buf_size = per_xecore_buf_size;
> > > > > > @@ -391,6 +629,19 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > > > >	return 0;
> > > > > >  }
> > > > > >
> > > > > > +static __poll_t xe_eu_stall_stream_poll_locked(struct xe_eu_stall_data_stream *stream,
> > > > > > +					       struct file *file, poll_table *wait)
> > > > > > +{
> > > > > > +	__poll_t events = 0;
> > > > > > +
> > > > > > +	poll_wait(file, &stream->poll_wq, wait);
> > > > > > +
> > > > > > +	if (stream->pollin)
> > > > > > +		events |= EPOLLIN;
> > > > > > +
> > > > > > +	return events;
> > > > > > +}
> > > > > > +
> > > > > >  /**
> > > > > >   * xe_eu_stall_stream_poll - handles userspace poll() of a EU stall data stream fd.
> > > > > >   *
> > > > > > @@ -401,7 +652,13 @@ static int xe_eu_stall_stream_init(struct xe_eu_stall_data_stream *stream,
> > > > > >   */
> > > > > >  static __poll_t xe_eu_stall_stream_poll(struct file *file, poll_table *wait)
> > > > > >  {
> > > > > > -	__poll_t ret = 0;
> > > > > > +	struct xe_eu_stall_data_stream *stream = file->private_data;
> > > > > > +	struct xe_gt *gt = stream->gt;
> > > > > > +	__poll_t ret;
> > > > > > +
> > > > > > +	mutex_lock(&gt->eu_stall->stream_lock);
> > > > > > +	ret = xe_eu_stall_stream_poll_locked(stream, file, wait);
> > > > > > +	mutex_unlock(&gt->eu_stall->stream_lock);
> > > > > >
> > > > > >	return ret;
> > > > > >  }
> > > > > > @@ -416,6 +673,9 @@ static int xe_eu_stall_enable_locked(struct xe_eu_stall_data_stream *stream)
> > > > > >	stream->enabled = true;
> > > > > >
> > > > > >	ret = xe_eu_stall_stream_enable(stream);
> > > > > > +	queue_delayed_work(stream->buf_poll_wq,
> > > > >
> > > > > A blank line before this line would be nice.
> > > > >
> > > > > > +			   &stream->buf_poll_work,
> > > > > > +			   msecs_to_jiffies(POLL_PERIOD_MS));
> > > > > >	return ret;
> > > > > >  }
> > > > > >
> > > > > > @@ -429,6 +689,9 @@ static int xe_eu_stall_disable_locked(struct xe_eu_stall_data_stream *stream)
> > > > > >	stream->enabled = false;
> > > > > >
> > > > > >	xe_gt_mcr_multicast_write(gt, XEHPC_EUSTALL_BASE, 0);
> > > > > > +	/* Check for any new EU stall data one last time */
> > > > > > +	queue_delayed_work(stream->buf_poll_wq, &stream->buf_poll_work, 0);
> > > > >
> > > > > I am not sure if this is needed, especially if we use
> > > > > cancel_delayed_work_sync.
> > > > There was an ask from the user space to check for new data once after
> > > > disabling EU stall sampling to make sure we capture all the data.
> > >
> > > But they won't be able to read it because we set stream->enabled to false?
> > > So what's the point?
> > Good point. I will remove check for stream->enabled in the read function
> > xe_eu_stall_stream_read().
> 
> See above.
> 
> > >
> > > > >
> > > > > > +	flush_delayed_work(&stream->buf_poll_work);
> > > > >
> > > > > I think here we should use cancel_delayed_work_sync() instead. See
> > > > > e.g. xe_guc_ct.c (and also maybe xe_gt_tlb_invalidation.c).
> > > > I though about it and found that the difference between
> > > > flushed_delayed_work() and cancel_delayed_work_sync() is that
> > > > cancel_delayed_work_sync() cancels any pending work items and wait for
> > > > any work under execution to complete. Whereas flushed_delayed_work()
> > > > schedules any work pending and wait for it to complete. Since I want to
> > > > execute the work one last time after disable, flushed_delayed_work()
> > > > is more appropriate here than cancel_delayed_work_sync().
> > >
> > > Above I am questioning what is the purpose of the last queue_delayed_work.
> > > Also we could add the cancel_delayed_work_sync after the
> > > flush_delayed_work, if that is needed.
> > Okay, will add cancel_delayed_work_sync() after flush_delayed_work().
> > >
> > > As pointed out above, I think it is preferable to eliminate the 'if
> > > (stream->enabled)' check in eu_stall_data_buf_poll_work_fn() and handle it
> > > via cancel_delayed_work_sync(). Which I think should work, but probably
> > > needs to be checked.
> > Will check on this. I need to find a different way to check for any new
> > data and update write pointers one last time after disabling EU stall.
> > >
> > > >
> > > > >
> > > > > >
> > > > > >	xe_force_wake_put(gt_to_fw(gt), XE_FW_RENDER);
> > > > > >	xe_pm_runtime_put(gt_to_xe(gt));
> > > > > > diff --git a/drivers/gpu/drm/xe/xe_trace.h b/drivers/gpu/drm/xe/xe_trace.h
> > > > > > index d5281de04d54..1cc6bfc34ccb 100644
> > > > > > --- a/drivers/gpu/drm/xe/xe_trace.h
> > > > > > +++ b/drivers/gpu/drm/xe/xe_trace.h
> > > > > > @@ -427,6 +427,39 @@ DEFINE_EVENT(xe_pm_runtime, xe_pm_runtime_get_ioctl,
> > > > > >	     TP_ARGS(xe, caller)
> > > > > >  );
> > > > > >
> > > > > > +TRACE_EVENT(xe_eu_stall_data_read,
> > > > > > +	    TP_PROTO(u8 slice, u8 subslice,
> > > > > > +		     u32 read_ptr, u32 write_ptr,
> > > > > > +		     u32 read_offset, u32 write_offset,
> > > > > > +		     size_t total_size),
> > > > > > +	    TP_ARGS(slice, subslice, read_ptr, write_ptr,
> > > > > > +		    read_offset, write_offset, total_size),
> > > > > > +
> > > > > > +	    TP_STRUCT__entry(__field(u8, slice)
> > > > > > +			     __field(u8, subslice)
> > > > > > +			     __field(u32, read_ptr)
> > > > > > +			     __field(u32, write_ptr)
> > > > > > +			     __field(u32, read_offset)
> > > > > > +			     __field(u32, write_offset)
> > > > > > +			     __field(size_t, total_size)
> > > > > > +			     ),
> > > > > > +
> > > > > > +	    TP_fast_assign(__entry->slice = slice;
> > > > > > +			   __entry->subslice = subslice;
> > > > > > +			   __entry->read_ptr = read_ptr;
> > > > > > +			   __entry->write_ptr = write_ptr;
> > > > > > +			   __entry->read_offset = read_offset;
> > > > > > +			   __entry->write_offset = write_offset;
> > > > > > +			   __entry->total_size = total_size;
> > > > > > +			   ),
> > > > > > +
> > > > > > +	    TP_printk("slice:%u subslice:%u readptr:0x%x writeptr:0x%x read off:%u write off:%u size:%zu ",
> > > > > > +		      __entry->slice, __entry->subslice,
> > > > > > +		      __entry->read_ptr, __entry->write_ptr,
> > > > > > +		      __entry->read_offset, __entry->write_offset,
> > > > > > +		      __entry->total_size)
> > > > > > +);
> > > > > > +
> > > > > >  #endif
> > > > > >
> > > > > >  /* This part must be outside protection */
> > > > > > --
> > > > > > 2.48.1
> > > > > >
> > >
> > > Thanks.
> > > --
> > > Ashutosh

Re: [PATCH v9 4/8] drm/xe/eustall: Add support to read() and poll() EU stall data

[Dixit, Ashutosh]

On Mon, 17 Feb 2025 16:35:35 -0800, Harish Chegondi wrote:
>
> > > > > > > +	if (!(file->f_flags & O_NONBLOCK)) {
> > > > > > > +		do {
> > > > > > > +			ret = wait_event_interruptible(stream->poll_wq, stream->pollin);
> > > > > > > +			if (ret)
> > > > > > > +				return -EINTR;
> > > > > > > +
> > > > > > > +			mutex_lock(&gt->eu_stall->stream_lock);
> > > > > > > +			ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > > > > > +			mutex_unlock(&gt->eu_stall->stream_lock);
> > > > > > > +		} while (ret == -EAGAIN);
> > > > > > > +	} else {
> > > > > > > +		mutex_lock(&gt->eu_stall->stream_lock);
> > > > > > > +		ret = xe_eu_stall_stream_read_locked(stream, file, buf, count);
> > > > > > > +		mutex_unlock(&gt->eu_stall->stream_lock);
> > > > > > > +	}
> > > > > > > +
> > > > > > > +	stream->pollin = false;
> > > > > >
> > > > > > Carry over comment from previous rev: this breaks if user buffer is smaller
> > > > > > than available data. But this is a corner case so let's fix this after the
> > > > > > initial merge.
> > > > > I will check your fix in OA to better understand the problem here. If
> > > > > the user buffer is smaller than data record size, it just returns
> > > > > without copying any data.
> > > >
> > > > No, it is the issue when user buffer is larger than record_size, but still
> > > > smaller than the size of total data available. In that case, basically we
> > > > should let stream->pollin set to true, so that the user thread does not get
> > > > blocked, enabling it to rapidly consume data, even with a small buffer.
> > > >
> > > > Otherwise the thread is getting blocked every 10 ms, even when data is
> > > > available. And because new data keeps arriving, the user thread constantly
> > > > falls behind and soon HW will start dropping data (because the kernel is
> > > > blocking the user thread, it's a kernel not a user thread issue)
> > > >
> > > > To handle this OA does:
> > > >
> > > >	if (ret != -ENOSPC && ret != -EIO)
> > > EU stall read() never returns -ENOSPC. Even if the user buffer is
> > > smaller then the size of total data in the buffer, only the data that
> > > can fit into the user buffer will be copied through read().
> >
> > OA read() also doesn't return -ENOSPC to userland. That is the expected
> > read() behavior (return number of bytes if you are returning any data). The
> > full code is this:
> >
> >         if (ret != -ENOSPC && ret != -EIO)
> >                 stream->pollin = false;
> >
> >         return offset ?: (ret ?: -EAGAIN);
> >
> > > As long as there are atleast wait_num_reports data rows in the buffer,
> > > stream->pollin is set to true. It sounds to me that this issue is
> > > specific to OA code only. Is there something that I missed?
> >
> > No this issue is there in EU stall code. You should not block reads till
> > the next time the polling thread runs, if we could not copy all data in the
> > previous read (because there already is data, don't block the user thread).
> The polling thread runs approximately once every 10ms. The question here
> is what would be time duration between two successive reads from the
> user space with no additional delay between them. If the duration is
> more than 10ms, the polling thread would set pollin to true. If not,
> the issue you have mentioned would occur.

If we don't block the user thread in the kernel, ideally it would call into
the kernel continuously to read data, let's say every few us. Say a memcpy
in userspace and then back into the kernel to read more data.

> However, I am changing the code here to this:
>
>         if (!eu_stall_data_buf_poll(stream))
>                 stream->pollin = false;
>
> Wouldn't this fix the issue?

No, this is not correct. There are two requirements:

1. Don't wake up the user thread too frequently, that is why we have the 10
   ms timer, so ordinarily, with a large buffer, the user thread only wakes
   up only every 10 ms.

2. Only when the user buffer is small, that is we have data which we could
   not copy in the user buffer, we shouldn't block the user thread.

In the above code, you are checking for data after completing the memcpy
into the user buffer. This would solve 2., but might break 1. Because the
code does not take into account that we should not block the user thread
only if the user buffer is small.

Let's not introduce this into the existing patches, this small user buffer
handling would need a new patch. As I said, let's do this after we merge
what we currently have. I don't want to review this stuff now.

Thanks.
--
Ashutosh

Re: [PATCH v9 2/8] drm/xe/uapi: Introduce API for EU stall sampling

[Jani Nikula]

On Sat, 15 Feb 2025, "Dixit, Ashutosh" <ashutosh.dixit@intel.com> wrote:
> On Sat, 15 Feb 2025 17:49:16 -0800, Harish Chegondi wrote:
>>
>> > > > > +struct eu_stall_open_properties {
>> > > > > +	unsigned int sampling_rate_mult;
>> > > > > +	unsigned int wait_num_reports;
>> > > >
>> > > > I already said no need to be so specific. Just use int or u32 as types for
>> > > > these.
>> > > Okay, will try to change these back to u8/u32 in the next version.
>> >
>> > Use int or u32, not u8.
>> Any reason why I can't use u8? The maximum value of sampling_rate_mult
>> is 7.

There is zero benefit in using a smaller type just because you think
your value range fits the type.

Default to using an int. You need a reason to use smaller types or
unsigned, not the other way round.

For example, many hardware registers are u32. That's a good reason to
use u32 when reading/writing registers. Sometimes reducing the memory
footprint matters, and you may want to use a smaller type. Likely not
the case here.


BR,
Jani.


>
> Use whatever you want. The real question to ask is why can't we use a
> generic type like int? Whether you use u8 or int, the CPU will still fetch
> a 64 byte cacheline. And this structure is only used at initialization, so
> performance is not a concern.

-- 
Jani Nikula, Intel