This patchset is to proviode the USB offload function which allows to
offload some xHCI operations on co-processor.
*** BLURB HERE ***
Albert Wang (1):
usb: host: add the xhci offload hooks implementations
Howard Yen (2):
usb: host: add xhci hooks for USB offload
usb: xhci-plat: add xhci_plat_priv_overwrite
drivers/usb/host/xhci-mem.c | 97 +++++-
drivers/usb/host/xhci-offload-impl.c | 492 +++++++++++++++++++++++++++
drivers/usb/host/xhci-plat.c | 43 +++
drivers/usb/host/xhci-plat.h | 8 +
drivers/usb/host/xhci.c | 21 ++
drivers/usb/host/xhci.h | 31 ++
6 files changed, 679 insertions(+), 13 deletions(-)
create mode 100644 drivers/usb/host/xhci-offload-impl.c
--
2.38.0.135.g90850a2211-goog
From: Howard Yen <[email protected]>
This change is to provide USB offload function which allows to offload some
xHCI operations on co-processor. This is especially designed for USB audio
usecase. The co-processor is able to manipulate some USB structures in his
own memory, like SRAM.
There are several offload_ops introduced by this patch:
struct xhci_offload_ops - function callbacks for offlad specific operations
{
@offload_init:
- called for vendor init process during xhci-plat-hcd
probe.
@offload_cleanup:
- called for vendor cleanup process during xhci-plat-hcd
remove.
@is_usb_offload_enabled:
- called to check if usb offload enabled.
@alloc_dcbaa:
- called when allocating vendor specific dcbaa during
memory initializtion.
@free_dcbaa:
- called to free vendor specific dcbaa when cleanup the
memory.
@alloc_transfer_ring:
- called when vendor specific transfer ring allocation is required
@free_transfer_ring:
- called to free vendor specific transfer ring
@usb_offload_skip_urb:
- called to check if need to skip urb enqueue
}
The xhci hooks with prefix "xhci_vendor_" on the ops in xhci_offload_ops.
For example, offload_init ops will be invoked by xhci_vendor_offload_init()
hook,is_usb_offload_enabled ops will be invoked by
xhci_vendor_is_usb_offload_enabled(), and so on.
Signed-off-by: Howard Yen <[email protected]>
Link: https://lore.kernel.org/r/[email protected]
Signed-off-by: Greg Kroah-Harktman <[email protected]>
---
drivers/usb/host/xhci-mem.c | 97 +++++++++++++++++++++++++++++++-----
drivers/usb/host/xhci-plat.c | 23 +++++++++
drivers/usb/host/xhci-plat.h | 1 +
drivers/usb/host/xhci.c | 21 ++++++++
drivers/usb/host/xhci.h | 31 ++++++++++++
5 files changed, 160 insertions(+), 13 deletions(-)
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 9e56aa28efcd..0449109a973d 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -361,6 +361,38 @@ static int xhci_alloc_segments_for_ring(struct xhci_hcd *xhci,
return 0;
}
+static struct xhci_ring *xhci_vendor_alloc_transfer_ring(struct xhci_hcd *xhci,
+ u32 endpoint_type, enum xhci_ring_type ring_type,
+ unsigned int max_packet, gfp_t mem_flags)
+{
+ struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci);
+
+ if (ops && ops->alloc_transfer_ring)
+ return ops->alloc_transfer_ring(xhci, endpoint_type, ring_type,
+ max_packet, mem_flags);
+ return 0;
+}
+
+static void xhci_vendor_free_transfer_ring(struct xhci_hcd *xhci,
+ struct xhci_virt_device *virt_dev, unsigned int ep_index)
+{
+ struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci);
+
+ if (ops && ops->free_transfer_ring)
+ ops->free_transfer_ring(xhci, virt_dev, ep_index);
+}
+
+static bool xhci_vendor_is_offload_enabled(struct xhci_hcd *xhci,
+ struct xhci_virt_device *virt_dev, unsigned int ep_index)
+{
+ struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci);
+
+ if (ops && ops->is_offload_enabled)
+ return ops->is_offload_enabled(xhci, virt_dev, ep_index);
+
+ return false;
+}
+
/*
* Create a new ring with zero or more segments.
*
@@ -412,7 +444,11 @@ void xhci_free_endpoint_ring(struct xhci_hcd *xhci,
struct xhci_virt_device *virt_dev,
unsigned int ep_index)
{
- xhci_ring_free(xhci, virt_dev->eps[ep_index].ring);
+ if (xhci_vendor_is_offload_enabled(xhci, virt_dev, ep_index))
+ xhci_vendor_free_transfer_ring(xhci, virt_dev, ep_index);
+ else
+ xhci_ring_free(xhci, virt_dev->eps[ep_index].ring);
+
virt_dev->eps[ep_index].ring = NULL;
}
@@ -885,7 +921,7 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
for (i = 0; i < 31; i++) {
if (dev->eps[i].ring)
- xhci_ring_free(xhci, dev->eps[i].ring);
+ xhci_free_endpoint_ring(xhci, dev, i);
if (dev->eps[i].stream_info)
xhci_free_stream_info(xhci,
dev->eps[i].stream_info);
@@ -1483,8 +1519,16 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
mult = 0;
/* Set up the endpoint ring */
- virt_dev->eps[ep_index].new_ring =
- xhci_ring_alloc(xhci, 2, 1, ring_type, max_packet, mem_flags);
+ if (xhci_vendor_is_offload_enabled(xhci, virt_dev, ep_index) &&
+ usb_endpoint_xfer_isoc(&ep->desc)) {
+ virt_dev->eps[ep_index].new_ring =
+ xhci_vendor_alloc_transfer_ring(xhci, endpoint_type, ring_type,
+ max_packet, mem_flags);
+ } else {
+ virt_dev->eps[ep_index].new_ring =
+ xhci_ring_alloc(xhci, 2, 1, ring_type, max_packet, mem_flags);
+ }
+
if (!virt_dev->eps[ep_index].new_ring)
return -ENOMEM;
@@ -1828,6 +1872,23 @@ void xhci_free_erst(struct xhci_hcd *xhci, struct xhci_erst *erst)
erst->entries = NULL;
}
+static void xhci_vendor_alloc_dcbaa(
+ struct xhci_hcd *xhci, gfp_t flags)
+{
+ struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci);
+
+ if (ops && ops->alloc_dcbaa)
+ return ops->alloc_dcbaa(xhci, flags);
+}
+
+static void xhci_vendor_free_dcbaa(struct xhci_hcd *xhci)
+{
+ struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci);
+
+ if (ops && ops->free_dcbaa)
+ ops->free_dcbaa(xhci);
+}
+
void xhci_mem_cleanup(struct xhci_hcd *xhci)
{
struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
@@ -1879,9 +1940,13 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
xhci_dbg_trace(xhci, trace_xhci_dbg_init,
"Freed medium stream array pool");
- if (xhci->dcbaa)
- dma_free_coherent(dev, sizeof(*xhci->dcbaa),
- xhci->dcbaa, xhci->dcbaa->dma);
+ if (xhci_vendor_is_offload_enabled(xhci, NULL, 0)) {
+ xhci_vendor_free_dcbaa(xhci);
+ } else {
+ if (xhci->dcbaa)
+ dma_free_coherent(dev, sizeof(*xhci->dcbaa),
+ xhci->dcbaa, xhci->dcbaa->dma);
+ }
xhci->dcbaa = NULL;
scratchpad_free(xhci);
@@ -2418,15 +2483,21 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
* xHCI section 5.4.6 - Device Context array must be
* "physically contiguous and 64-byte (cache line) aligned".
*/
- xhci->dcbaa = dma_alloc_coherent(dev, sizeof(*xhci->dcbaa), &dma,
- flags);
- if (!xhci->dcbaa)
- goto fail;
- xhci->dcbaa->dma = dma;
+ if (xhci_vendor_is_offload_enabled(xhci, NULL, 0)) {
+ xhci_vendor_alloc_dcbaa(xhci, flags);
+ if (!xhci->dcbaa)
+ goto fail;
+ } else {
+ xhci->dcbaa = dma_alloc_coherent(dev, sizeof(*xhci->dcbaa), &dma,
+ flags);
+ if (!xhci->dcbaa)
+ goto fail;
+ xhci->dcbaa->dma = dma;
+ }
xhci_dbg_trace(xhci, trace_xhci_dbg_init,
"// Device context base array address = 0x%llx (DMA), %p (virt)",
(unsigned long long)xhci->dcbaa->dma, xhci->dcbaa);
- xhci_write_64(xhci, dma, &xhci->op_regs->dcbaa_ptr);
+ xhci_write_64(xhci, xhci->dcbaa->dma, &xhci->op_regs->dcbaa_ptr);
/*
* Initialize the ring segment pool. The ring must be a contiguous
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 5fb55bf19493..2f04acb42fa6 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -173,6 +173,23 @@ static const struct of_device_id usb_xhci_of_match[] = {
MODULE_DEVICE_TABLE(of, usb_xhci_of_match);
#endif
+static int xhci_vendor_init(struct xhci_hcd *xhci)
+{
+ struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci);
+
+ if (ops && ops->offload_init)
+ return ops->offload_init(xhci);
+ return 0;
+}
+
+static void xhci_vendor_cleanup(struct xhci_hcd *xhci)
+{
+ struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci);
+
+ if (ops && ops->offload_cleanup)
+ ops->offload_cleanup(xhci);
+}
+
static int xhci_plat_probe(struct platform_device *pdev)
{
const struct xhci_plat_priv *priv_match;
@@ -317,6 +334,10 @@ static int xhci_plat_probe(struct platform_device *pdev)
goto disable_clk;
}
+ ret = xhci_vendor_init(xhci);
+ if (ret)
+ goto disable_usb_phy;
+
hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node);
if (priv && (priv->quirks & XHCI_SKIP_PHY_INIT))
@@ -410,6 +431,8 @@ static int xhci_plat_remove(struct platform_device *dev)
if (shared_hcd)
usb_put_hcd(shared_hcd);
+ xhci_vendor_cleanup(xhci);
+
clk_disable_unprepare(clk);
clk_disable_unprepare(reg_clk);
usb_put_hcd(hcd);
diff --git a/drivers/usb/host/xhci-plat.h b/drivers/usb/host/xhci-plat.h
index 1fb149d1fbce..5aa0d38fa01a 100644
--- a/drivers/usb/host/xhci-plat.h
+++ b/drivers/usb/host/xhci-plat.h
@@ -13,6 +13,7 @@
struct xhci_plat_priv {
const char *firmware_name;
unsigned long long quirks;
+ struct xhci_offload_ops *offload_ops;
void (*plat_start)(struct usb_hcd *);
int (*init_quirk)(struct usb_hcd *);
int (*suspend_quirk)(struct usb_hcd *);
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 5176765c4013..aa3a44733bbe 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -22,6 +22,7 @@
#include "xhci-trace.h"
#include "xhci-debugfs.h"
#include "xhci-dbgcap.h"
+#include "xhci-plat.h"
#define DRIVER_AUTHOR "Sarah Sharp"
#define DRIVER_DESC "'eXtensible' Host Controller (xHC) Driver"
@@ -1663,6 +1664,11 @@ static int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flag
return -ENODEV;
}
+ if (xhci_vendor_usb_offload_skip_urb(xhci, urb)) {
+ xhci_dbg(xhci, "skip urb for usb offload\n");
+ return -EOPNOTSUPP;
+ }
+
if (usb_endpoint_xfer_isoc(&urb->ep->desc))
num_tds = urb->number_of_packets;
else if (usb_endpoint_is_bulk_out(&urb->ep->desc) &&
@@ -4435,6 +4441,21 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci,
return ret;
}
+struct xhci_offload_ops *xhci_offload_get_ops(struct xhci_hcd *xhci)
+{
+ return xhci_to_priv(xhci)->offload_ops;
+}
+EXPORT_SYMBOL_GPL(xhci_offload_get_ops);
+
+bool xhci_vendor_usb_offload_skip_urb(struct xhci_hcd *xhci, struct urb *urb)
+{
+ struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci);
+
+ if (ops && ops->usb_offload_skip_urb)
+ return ops->usb_offload_skip_urb(xhci, urb);
+ return false;
+}
+
#ifdef CONFIG_PM
/* BESL to HIRD Encoding array for USB2 LPM */
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index c0964fe8ac12..5368c66f5cec 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -2228,6 +2228,37 @@ static inline struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci,
urb->stream_id);
}
+/**
+ * struct xhci_offload_ops - function callbacks for offload specific operations
+ * @offload_init: called for offload init process
+ * @offload_cleanup: called for offload cleanup process
+ * @is_usb_offload_enabled: called to check if xhci offload enabled
+ * @alloc_dcbaa: called when allocating specific dcbaa for offload
+ * @free_dcbaa: called to free specific dcbaa for offload
+ * @alloc_transfer_ring: called when remote transfer ring allocation is required
+ * @free_transfer_ring: called to free specific transfer ring for offload
+ * @usb_offload_skip_urb: called to check if need to skip urb
+ */
+struct xhci_offload_ops {
+ int (*offload_init)(struct xhci_hcd *xhci);
+ void (*offload_cleanup)(struct xhci_hcd *xhci);
+ bool (*is_offload_enabled)(struct xhci_hcd *xhci,
+ struct xhci_virt_device *vdev,
+ unsigned int ep_index);
+ void (*alloc_dcbaa)(struct xhci_hcd *xhci, gfp_t flags);
+ void (*free_dcbaa)(struct xhci_hcd *xhci);
+
+ struct xhci_ring *(*alloc_transfer_ring)(struct xhci_hcd *xhci,
+ u32 endpoint_type, enum xhci_ring_type ring_type,
+ unsigned int max_packet, gfp_t mem_flags);
+ void (*free_transfer_ring)(struct xhci_hcd *xhci,
+ struct xhci_virt_device *virt_dev, unsigned int ep_index);
+ bool (*usb_offload_skip_urb)(struct xhci_hcd *xhci, struct urb *urb);
+};
+
+struct xhci_offload_ops *xhci_offload_get_ops(struct xhci_hcd *xhci);
+bool xhci_vendor_usb_offload_skip_urb(struct xhci_hcd *xhci, struct urb *urb);
+
/*
* TODO: As per spec Isochronous IDT transmissions are supported. We bypass
* them anyways as we where unable to find a device that matches the
--
2.38.0.135.g90850a2211-goog
On Thu, Oct 27, 2022 at 08:40:48AM +0800, Albert Wang wrote:
> From: Howard Yen <[email protected]>
>
> This change is to provide USB offload function which allows to offload some
> xHCI operations on co-processor. This is especially designed for USB audio
> usecase. The co-processor is able to manipulate some USB structures in his
> own memory, like SRAM.
>
> There are several offload_ops introduced by this patch:
>
> struct xhci_offload_ops - function callbacks for offlad specific operations
> {
> @offload_init:
> - called for vendor init process during xhci-plat-hcd
> probe.
> @offload_cleanup:
> - called for vendor cleanup process during xhci-plat-hcd
> remove.
> @is_usb_offload_enabled:
> - called to check if usb offload enabled.
> @alloc_dcbaa:
> - called when allocating vendor specific dcbaa during
> memory initializtion.
> @free_dcbaa:
> - called to free vendor specific dcbaa when cleanup the
> memory.
> @alloc_transfer_ring:
> - called when vendor specific transfer ring allocation is required
> @free_transfer_ring:
> - called to free vendor specific transfer ring
> @usb_offload_skip_urb:
> - called to check if need to skip urb enqueue
> }
>
> The xhci hooks with prefix "xhci_vendor_" on the ops in xhci_offload_ops.
> For example, offload_init ops will be invoked by xhci_vendor_offload_init()
> hook,is_usb_offload_enabled ops will be invoked by
> xhci_vendor_is_usb_offload_enabled(), and so on.
>
> Signed-off-by: Howard Yen <[email protected]>
> Link: https://lore.kernel.org/r/[email protected]
> Signed-off-by: Greg Kroah-Harktman <[email protected]>
Sorry, but no, I did NOT sign of on this patch for submission here.
And if you read the link above, you will see that I explicitly rejected
this commit for inclusion.
What changed from this previous series? Is any of the issues raised
there now resolved? If so, how? If not, why not?
thanks,
greg k-h
On Thu, Oct 27, 2022 at 08:40:47AM +0800, Albert Wang wrote:
> This patchset is to proviode the USB offload function which allows to
> offload some xHCI operations on co-processor.
>
> *** BLURB HERE ***
No blurb?
And isn't this a v2 of this patchset? What changed from the previous
submission?
thanks,
greg k-h
Greeting,
FYI, we noticed BUG:KASAN:slab-out-of-bounds_in_xhci_offload_get_ops due to commit (built with gcc-11):
commit: 45fd37984e97f2392fa6a4ebc7367965cb55ef7f ("[PATCH 1/3] usb: host: add xhci hooks for USB offload")
url: https://github.com/intel-lab-lkp/linux/commits/Albert-Wang/add-xhci-hooks-for-USB-offload/20221027-084252
base: https://git.kernel.org/cgit/linux/kernel/git/gregkh/usb.git usb-testing
patch link: https://lore.kernel.org/lkml/[email protected]
patch subject: [PATCH 1/3] usb: host: add xhci hooks for USB offload
in testcase: kernel-selftests
version: kernel-selftests-x86_64-9313ba54-1_20221017
with following parameters:
sc_nr_hugepages: 2
group: vm
test-description: The kernel contains a set of "self tests" under the tools/testing/selftests/ directory. These are intended to be small unit tests to exercise individual code paths in the kernel.
test-url: https://www.kernel.org/doc/Documentation/kselftest.txt
on test machine: 88 threads 2 sockets Intel(R) Xeon(R) Gold 6238M CPU @ 2.10GHz (Cascade Lake) with 128G memory
caused below changes (please refer to attached dmesg/kmsg for entire log/backtrace):
kern :err : [ 35.546226] BUG: KASAN: slab-out-of-bounds in xhci_offload_get_ops (??:?)
kern :err : [ 35.546226] Read of size 8 at addr ffff88816f6d3cf0 by task kworker/0:3/642
kern :err : [ 35.546226] CPU: 0 PID: 642 Comm: kworker/0:3 Not tainted 6.1.0-rc1-00023-g45fd37984e97 #1
kern :err : [ 35.546226] Hardware name: Intel Corporation S2600WFT/S2600WFT, BIOS SE5C620.86B.02.01.0012.070720200218 07/07/2020
kern :err : [ 35.546226] Workqueue: events work_for_cpu_fn
kern :err : [ 35.546226] Call Trace:
kern :err : [ 35.546226] <TASK>
kern :err : [ 35.546226] dump_stack_lvl (??:?)
kern :err : [ 35.546226] print_address_description+0x87/0x2a1
kern :err : [ 35.546226] print_report (report.c:?)
kern :err : [ 35.546226] ? kasan_addr_to_slab (??:?)
kern :err : [ 35.546226] ? xhci_offload_get_ops (??:?)
kern :err : [ 35.546226] kasan_report (??:?)
kern :err : [ 35.546226] ? xhci_offload_get_ops (??:?)
kern :err : [ 35.546226] xhci_offload_get_ops (??:?)
kern :err : [ 35.546226] xhci_mem_init (??:?)
kern :err : [ 35.546226] ? lockdep_hardirqs_on_prepare (lockdep.c:?)
kern :err : [ 35.546226] ? xhci_mem_cleanup (??:?)
kern :err : [ 35.546226] ? lockdep_init_map_type (??:?)
kern :err : [ 35.546226] xhci_init (xhci.c:?)
kern :err : [ 35.546226] xhci_gen_setup (??:?)
kern :err : [ 35.546226] ? xhci_pci_suspend (xhci-pci.c:?)
kern :err : [ 35.546226] xhci_pci_setup (xhci-pci.c:?)
kern :err : [ 35.546226] usb_add_hcd.cold (hcd.c:?)
kern :err : [ 35.546226] usb_hcd_pci_probe (??:?)
kern :err : [ 35.546226] ? lockdep_hardirqs_on_prepare (lockdep.c:?)
kern :err : [ 35.546226] ? xhci_pci_resume (xhci-pci.c:?)
kern :err : [ 35.546226] xhci_pci_probe (xhci-pci.c:?)
kern :err : [ 35.546226] ? xhci_pci_resume (xhci-pci.c:?)
kern :err : [ 35.546226] local_pci_probe (pci-driver.c:?)
kern :err : [ 35.546226] ? lock_is_held_type (??:?)
kern :err : [ 35.546226] ? pci_device_shutdown (pci-driver.c:?)
kern :err : [ 35.546226] work_for_cpu_fn (workqueue.c:?)
kern :err : [ 35.546226] process_one_work (workqueue.c:?)
kern :err : [ 35.546226] ? rcu_read_unlock (main.c:?)
kern :err : [ 35.546226] ? pwq_dec_nr_in_flight (workqueue.c:?)
kern :err : [ 35.546226] ? rwlock_bug+0x90/0x90
kern :err : [ 35.546226] ? move_linked_works (workqueue.c:?)
kern :err : [ 35.546226] worker_thread (workqueue.c:?)
kern :err : [ 35.546226] ? process_one_work (workqueue.c:?)
kern :err : [ 35.546226] ? process_one_work (workqueue.c:?)
kern :err : [ 35.546226] kthread (kthread.c:?)
kern :err : [ 35.546226] ? kthread_complete_and_exit (kthread.c:?)
kern :err : [ 35.546226] ret_from_fork (??:?)
kern :err : [ 35.546226] </TASK>
kern :err : [ 35.546226] The buggy address belongs to the physical page:
kern :warn : [ 35.546226] page:000000005a3d962c refcount:1 mapcount:0 mapping:0000000000000000 index:0x0 pfn:0x16f6d0
kern :warn : [ 35.546226] head:000000005a3d962c order:2 compound_mapcount:0 compound_pincount:0
kern :warn : [ 35.546226] flags: 0x17ffffc0010000(head|node=0|zone=2|lastcpupid=0x1fffff)
kern :warn : [ 35.546226] raw: 0017ffffc0010000 0000000000000000 dead000000000122 0000000000000000
kern :warn : [ 35.546226] raw: 0000000000000000 0000000000000000 00000001ffffffff 0000000000000000
kern :warn : [ 35.546226] page dumped because: kasan: bad access detected
kern :err : [ 35.546226] Memory state around the buggy address:
kern :err : [ 35.546226] ffff88816f6d3b80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
kern :err : [ 35.546226] ffff88816f6d3c00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
kern :err : [ 35.546226] >ffff88816f6d3c80: 00 00 00 00 00 00 00 00 00 00 00 00 fe fe fe fe
kern :err : [ 35.546226] ^
kern :err : [ 35.546226] ffff88816f6d3d00: fe fe fe fe fe fe fe fe fe fe fe fe fe fe fe fe
kern :err : [ 35.546226] ffff88816f6d3d80: fe fe fe fe fe fe fe fe fe fe fe fe fe fe fe fe
kern :err : [ 35.546226] ==================================================================
kern :warn : [ 35.905561] Disabling lock debugging due to kernel taint
kern :info : [ 35.911736] xhci_hcd 0000:00:14.0: hcc params 0x200077c1 hci version 0x100 quirks 0x0000000000009810
kern :info : [ 35.923138] xhci_hcd 0000:00:14.0: xHCI Host Controller
kern :info : [ 35.929321] xhci_hcd 0000:00:14.0: new USB bus registered, assigned bus number 2
kern :info : [ 35.937431] xhci_hcd 0000:00:14.0: Host supports USB 3.0 SuperSpeed
If you fix the issue, kindly add following tag
| Reported-by: kernel test robot <[email protected]>
| Link: https://lore.kernel.org/oe-lkp/[email protected]
To reproduce:
git clone https://github.com/intel/lkp-tests.git
cd lkp-tests
sudo bin/lkp install job.yaml # job file is attached in this email
bin/lkp split-job --compatible job.yaml # generate the yaml file for lkp run
sudo bin/lkp run generated-yaml-file
# if come across any failure that blocks the test,
# please remove ~/.lkp and /lkp dir to run from a clean state.
--
0-DAY CI Kernel Test Service
https://01.org/lkp