* [PATCH v8 01/12] PCI: liveupdate: Set up FLB handler for the PCI core
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
@ 2026-07-28 22:09 ` David Matlack
2026-07-28 22:19 ` sashiko-bot
2026-07-28 22:09 ` [PATCH v8 02/12] PCI: liveupdate: Track outgoing preserved PCI devices David Matlack
` (10 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:09 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Set up a File-Lifecycle-Bound (FLB) handler for the PCI core to enable
it to participate in the preservation of PCI devices across Live Update.
Essentially, this commit enables the PCI core to allocate a struct
(struct pci_ser) and preserve it across a Live Update whenever at least
one device is preserved.
Preserving PCI devices across Live Update is built on top of the Live
Update Orchestrator's (LUO) support for file preservation. Drivers are
expected to expose a file to userspace to represent a single PCI device
and support preservation of that file. This is intended primarily to
support preservation of PCI devices bound to VFIO drivers.
This commit enables drivers to register their liveupdate_file_handler
with the PCI core so that the PCI core can do its own tracking and
enforcement of which devices are preserved.
pci_liveupdate_register_flb(driver_file_handler);
pci_liveupdate_unregister_flb(driver_file_handler);
When the first file (with a handler registered with the PCI core) is
preserved, the PCI core will be notified to allocate its tracking struct
(pci_ser). When the last file is unpreserved (i.e. preservation
cancelled) the PCI core will be notified to free struct pci_ser.
This struct is preserved across a Live Update using KHO and can be
fetched by the PCI core during early boot (e.g. during device
enumeration) so that it knows which devices were preserved.
Note: This commit only allocates struct pci_ser and preserves it across
Live Update. A subsequent commit will add an API for drivers to tell the
PCI core exactly which devices are being preserved.
Note: There is no reason to check for kho_is_enabled() since it can be
assumed to return true. If KHO was not enabled then Live Update would
not be enabled and these routines would never run.
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
Documentation/core-api/liveupdate.rst | 4 +
MAINTAINERS | 13 +++
drivers/pci/Kconfig | 15 +++
drivers/pci/Makefile | 1 +
drivers/pci/liveupdate.c | 158 ++++++++++++++++++++++++++
include/linux/kho/abi/pci.h | 63 ++++++++++
include/linux/pci.h | 1 +
include/linux/pci_liveupdate.h | 30 +++++
8 files changed, 285 insertions(+)
create mode 100644 drivers/pci/liveupdate.c
create mode 100644 include/linux/kho/abi/pci.h
create mode 100644 include/linux/pci_liveupdate.h
diff --git a/Documentation/core-api/liveupdate.rst b/Documentation/core-api/liveupdate.rst
index 5a292d0f3706..b3c689e633c1 100644
--- a/Documentation/core-api/liveupdate.rst
+++ b/Documentation/core-api/liveupdate.rst
@@ -1,5 +1,7 @@
.. SPDX-License-Identifier: GPL-2.0
+.. _luo:
+
========================
Live Update Orchestrator
========================
@@ -18,6 +20,8 @@ LUO Preserving File Descriptors
.. kernel-doc:: kernel/liveupdate/luo_file.c
:doc: LUO File Descriptors
+.. _flb:
+
LUO File Lifecycle Bound Global Data
====================================
.. kernel-doc:: kernel/liveupdate/luo_flb.c
diff --git a/MAINTAINERS b/MAINTAINERS
index a3ed337e827d..9cc7b9291ace 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -20824,6 +20824,19 @@ L: linux-pci@vger.kernel.org
S: Supported
F: Documentation/PCI/pci-error-recovery.rst
+PCI LIVE UPDATE
+M: David Matlack <dmatlack@google.com>
+R: Pasha Tatashin <pasha.tatashin@soleen.com>
+R: Mike Rapoport <rppt@kernel.org>
+R: Pratyush Yadav <pratyush@kernel.org>
+L: kexec@lists.infradead.org
+L: linux-pci@vger.kernel.org
+S: Maintained
+T: git git://git.kernel.org/pub/scm/linux/kernel/git/liveupdate/linux.git
+F: drivers/pci/liveupdate.c
+F: include/linux/kho/abi/pci.h
+F: include/linux/pci_liveupdate.h
+
PCI MSI DRIVER FOR ALTERA MSI IP
L: linux-pci@vger.kernel.org
S: Orphan
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 0c7408509ba2..3781e2b5f095 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -271,6 +271,21 @@ config VGA_ARB_MAX_GPUS
Reserves space in the kernel to maintain resource locking for
multiple GPUS. The overhead for each GPU is very small.
+config PCI_LIVEUPDATE
+ bool "PCI Live Update Support"
+ depends on PCI && LIVEUPDATE
+ help
+ Enable PCI core support for preserving PCI devices across Live
+ Update. This, in combination with support in a device's driver,
+ enables PCI devices to run and perform memory transactions
+ uninterrupted during a kexec for Live Update.
+
+ This option should only be enabled by users who plan to use Live
+ Update for kernel upgrades and require preserving PCI devices during
+ those upgrades.
+
+ If unsure, say N.
+
source "drivers/pci/hotplug/Kconfig"
source "drivers/pci/controller/Kconfig"
source "drivers/pci/endpoint/Kconfig"
diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile
index 41ebc3b9a518..e8d003cb6757 100644
--- a/drivers/pci/Makefile
+++ b/drivers/pci/Makefile
@@ -16,6 +16,7 @@ obj-$(CONFIG_PROC_FS) += proc.o
obj-$(CONFIG_SYSFS) += pci-sysfs.o slot.o
obj-$(CONFIG_ACPI) += pci-acpi.o
obj-$(CONFIG_GENERIC_PCI_IOMAP) += iomap.o
+obj-$(CONFIG_PCI_LIVEUPDATE) += liveupdate.o
endif
obj-$(CONFIG_OF) += of.o
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
new file mode 100644
index 000000000000..fffb41a66ca7
--- /dev/null
+++ b/drivers/pci/liveupdate.c
@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/*
+ * Copyright (c) 2026, Google LLC.
+ * David Matlack <dmatlack@google.com>
+ */
+
+/**
+ * DOC: PCI Live Update
+ *
+ * The PCI subsystem participates in the Live Update process to enable drivers
+ * to preserve their PCI devices across kexec.
+ *
+ * :ref:`FLB <flb>` Data
+ * =====================
+ *
+ * PCI device preservation across Live Update is built on top of the
+ * :ref:`LUO <luo>` support for file preservation across kexec. Drivers are
+ * expected to expose a file to represent a single PCI device and support
+ * preservation of that file with ``ioctl(LIVEUPDATE_SESSION_PRESERVE_FD)``.
+ * This allows userspace to control the preservation of devices and ensure
+ * proper lifecycle management while a device is preserved. The first intended
+ * use-case is preserving vfio-pci device files.
+ *
+ * The PCI core maintains its own state about what devices are being preserved
+ * across Live Update using FLB data in LUO. Essentially, this allows the PCI
+ * core to allocate struct pci_ser when the first device (file) is preserved
+ * and free it when the last device (file) is unpreserved. After kexec, the
+ * PCI core can fetch the struct pci_ser (which was constructed by the previous
+ * kernel) from LUO at any time (e.g. during enumeration) so that it knows
+ * which devices were preserved.
+ *
+ * To enable the PCI core to be notified whenever a file representing a device
+ * is preserved, drivers must register their struct liveupdate_file_handler with
+ * the PCI core by using the following APIs:
+ *
+ * * ``pci_liveupdate_register_flb(driver_file_handler)``
+ * * ``pci_liveupdate_unregister_flb(driver_file_handler)``
+ */
+
+#define pr_fmt(fmt) "PCI: liveupdate: " fmt
+
+#include <linux/io.h>
+#include <linux/kexec_handover.h>
+#include <linux/kho/abi/pci.h>
+#include <linux/kho_block.h>
+#include <linux/liveupdate.h>
+#include <linux/mm.h>
+#include <linux/mutex.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
+
+/**
+ * struct pci_flb_outgoing - Outgoing PCI FLB object
+ * @ser: Pointer to the preserved struct pci_ser.
+ * @block_set: The KHO block set holding the outgoing devices.
+ *
+ * This structure holds the runtime state for the outgoing PCI Live Update
+ * state. It wraps the serialized pci_ser and the block_set used to manage
+ * the serialized entries.
+ */
+struct pci_flb_outgoing {
+ struct pci_ser *ser;
+ struct kho_block_set block_set;
+};
+
+static int pci_flb_preserve(struct liveupdate_flb_op_args *args)
+{
+ struct pci_flb_outgoing *outgoing __free(kfree) = NULL;
+ struct pci_ser *ser;
+
+ outgoing = kzalloc_obj(*outgoing);
+ if (!outgoing)
+ return -ENOMEM;
+
+ ser = kho_alloc_preserve(sizeof(*ser));
+ if (IS_ERR(ser))
+ return PTR_ERR(ser);
+
+ ser->version = PCI_LUO_FLB_VERSION;
+ ser->nr_devices = 0;
+ ser->devices = 0;
+
+ outgoing->ser = ser;
+ kho_block_set_init(&outgoing->block_set, sizeof(struct pci_dev_ser));
+
+ args->obj = no_free_ptr(outgoing);
+ args->data = virt_to_phys(ser);
+ pr_debug("Preserved struct pci_ser (0x%llx)\n", args->data);
+ return 0;
+}
+
+static void pci_flb_unpreserve(struct liveupdate_flb_op_args *args)
+{
+ struct pci_flb_outgoing *outgoing = args->obj;
+
+ pr_debug("Unpreserving struct pci_ser (0x%llx)\n", args->data);
+
+ WARN_ON(outgoing->ser->nr_devices);
+ kho_block_set_destroy(&outgoing->block_set);
+ kho_unpreserve_free(outgoing->ser);
+ kfree(outgoing);
+}
+
+static int pci_flb_retrieve(struct liveupdate_flb_op_args *args)
+{
+ pr_debug("Retrieving struct pci_ser (0x%llx)\n", args->data);
+ args->obj = phys_to_virt(args->data);
+ return 0;
+}
+
+static void pci_flb_finish(struct liveupdate_flb_op_args *args)
+{
+ pr_debug("Finished struct pci_ser (0x%llx)\n", args->data);
+ kho_restore_free(args->obj);
+}
+
+static struct liveupdate_flb_ops pci_liveupdate_flb_ops = {
+ .preserve = pci_flb_preserve,
+ .unpreserve = pci_flb_unpreserve,
+ .retrieve = pci_flb_retrieve,
+ .finish = pci_flb_finish,
+ .owner = THIS_MODULE,
+};
+
+static struct liveupdate_flb pci_liveupdate_flb = {
+ .ops = &pci_liveupdate_flb_ops,
+ .compatible = PCI_LUO_FLB_COMPATIBLE,
+};
+
+/**
+ * pci_liveupdate_register_flb() - Register a file handler with the PCI core
+ * @fh: The file handler to register.
+ *
+ * Drivers should call pci_liveupdate_register_flb() to register their
+ * struct liveupdate_file_handler with the PCI core. This enables the PCI core
+ * to allocate its outgoing struct pci_ser whenever the first device is
+ * preserved, and free it when the last device is unpreserved.
+ *
+ * Return: 0 on success, <0 on failure.
+ */
+int pci_liveupdate_register_flb(struct liveupdate_file_handler *fh)
+{
+ pr_debug("Registering file handler \"%s\"\n", fh->compatible);
+ return liveupdate_register_flb(fh, &pci_liveupdate_flb);
+}
+EXPORT_SYMBOL_GPL(pci_liveupdate_register_flb);
+
+/**
+ * pci_liveupdate_unregister_flb() - Unregister a file handler with the PCI core
+ * @fh: The file handler to unregister.
+ */
+void pci_liveupdate_unregister_flb(struct liveupdate_file_handler *fh)
+{
+ pr_debug("Unregistering file handler \"%s\"\n", fh->compatible);
+ liveupdate_unregister_flb(fh, &pci_liveupdate_flb);
+}
+EXPORT_SYMBOL_GPL(pci_liveupdate_unregister_flb);
diff --git a/include/linux/kho/abi/pci.h b/include/linux/kho/abi/pci.h
new file mode 100644
index 000000000000..d4881c2d2fc9
--- /dev/null
+++ b/include/linux/kho/abi/pci.h
@@ -0,0 +1,63 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+/*
+ * Copyright (c) 2026, Google LLC.
+ * David Matlack <dmatlack@google.com>
+ */
+
+#ifndef _LINUX_KHO_ABI_PCI_H
+#define _LINUX_KHO_ABI_PCI_H
+
+#include <linux/bug.h>
+#include <linux/compiler.h>
+#include <linux/types.h>
+
+/**
+ * DOC: PCI File-Lifecycle Bound (FLB) Live Update ABI
+ *
+ * This header defines the ABI for preserving core PCI state across kexec using
+ * Live Update File-Lifecycle Bound (FLB) data.
+ *
+ * This interface is a contract. Any modification to any of the serialization
+ * structs defined here constitutes a breaking change. Such changes require
+ * incrementing the version number in the PCI_LUO_FLB_VERSION number.
+ */
+
+#define PCI_LUO_FLB_COMPATIBLE "pci"
+#define PCI_LUO_FLB_VERSION 1
+
+/**
+ * struct pci_dev_ser - Serialized state about a single PCI device.
+ *
+ * @domain: The device's PCI domain number (segment).
+ * @bdf: The device's PCI bus, device, and function number.
+ * @refcount: Reference count used by the PCI core to keep track of whether it
+ * is done using a device's struct pci_dev_ser. The value of the
+ * refcount is equal to 1 when the struct pci_dev_ser is in use, and
+ * 0 otherwise.
+ */
+struct pci_dev_ser {
+ u32 domain;
+ u16 bdf;
+ u16 refcount;
+} __packed;
+
+/**
+ * struct pci_ser - PCI Subsystem Live Update State
+ *
+ * This struct tracks state about all devices that are being preserved across
+ * a Live Update for the next kernel.
+ *
+ * @version: The version of the "pci" FLB struct. This field must never be
+ * deleted, moved, or resized, as the kernel depends on always being
+ * able to check the struct pci_ser version number.
+ * @nr_devices: The number of devices that were preserved.
+ * @devices: Physical address of the first KHO block containing pci_dev_ser.
+ */
+struct pci_ser {
+ u32 version;
+ u32 nr_devices;
+ u64 devices;
+} __packed;
+
+#endif /* _LINUX_KHO_ABI_PCI_H */
diff --git a/include/linux/pci.h b/include/linux/pci.h
index ebb5b9d76360..da58aa101e4c 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -43,6 +43,7 @@
#include <uapi/linux/pci.h>
#include <linux/pci_ids.h>
+#include <linux/pci_liveupdate.h>
#define PCI_STATUS_ERROR_BITS (PCI_STATUS_DETECTED_PARITY | \
PCI_STATUS_SIG_SYSTEM_ERROR | \
diff --git a/include/linux/pci_liveupdate.h b/include/linux/pci_liveupdate.h
new file mode 100644
index 000000000000..8ec98beefcb4
--- /dev/null
+++ b/include/linux/pci_liveupdate.h
@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * PCI Live Update support (Public/Driver API)
+ *
+ * Copyright (c) 2026, Google LLC.
+ * David Matlack <dmatlack@google.com>
+ */
+#ifndef LINUX_PCI_LIVEUPDATE_H
+#define LINUX_PCI_LIVEUPDATE_H
+
+#include <linux/liveupdate.h>
+#include <linux/types.h>
+
+struct pci_dev;
+
+#ifdef CONFIG_PCI_LIVEUPDATE
+int pci_liveupdate_register_flb(struct liveupdate_file_handler *fh);
+void pci_liveupdate_unregister_flb(struct liveupdate_file_handler *fh);
+#else
+static inline int pci_liveupdate_register_flb(struct liveupdate_file_handler *fh)
+{
+ return -EOPNOTSUPP;
+}
+
+static inline void pci_liveupdate_unregister_flb(struct liveupdate_file_handler *fh)
+{
+}
+#endif
+
+#endif /* LINUX_PCI_LIVEUPDATE_H */
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v8 01/12] PCI: liveupdate: Set up FLB handler for the PCI core
2026-07-28 22:09 ` [PATCH v8 01/12] PCI: liveupdate: Set up FLB handler for the PCI core David Matlack
@ 2026-07-28 22:19 ` sashiko-bot
0 siblings, 0 replies; 26+ messages in thread
From: sashiko-bot @ 2026-07-28 22:19 UTC (permalink / raw)
To: David Matlack; +Cc: linux-pci
> Set up a File-Lifecycle-Bound (FLB) handler for the PCI core to enable
> it to participate in the preservation of PCI devices across Live Update.
> Essentially, this commit enables the PCI core to allocate a struct
> (struct pci_ser) and preserve it across a Live Update whenever at least
> one device is preserved.
>
> Preserving PCI devices across Live Update is built on top of the Live
> Update Orchestrator's (LUO) support for file preservation. Drivers are
> expected to expose a file to userspace to represent a single PCI device
> and support preservation of that file. This is intended primarily to
> support preservation of PCI devices bound to VFIO drivers.
>
> This commit enables drivers to register their liveupdate_file_handler
> with the PCI core so that the PCI core can do its own tracking and
> enforcement of which devices are preserved.
> [ ... ]
> assumed to return true. If KHO was not enabled then Live Update would
> not be enabled and these routines would never run.
>
> Reviewed-by: Pranjal Shrivastava <praan@google.com>
> Signed-off-by: David Matlack <dmatlack@google.com>
Sashiko has reviewed this patch and found no issues. It looks great!
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260728221007.2098560-1-dmatlack@google.com?part=1
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v8 02/12] PCI: liveupdate: Track outgoing preserved PCI devices
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
2026-07-28 22:09 ` [PATCH v8 01/12] PCI: liveupdate: Set up FLB handler for the PCI core David Matlack
@ 2026-07-28 22:09 ` David Matlack
2026-07-28 22:19 ` sashiko-bot
2026-07-28 22:09 ` [PATCH v8 03/12] PCI: liveupdate: Track incoming " David Matlack
` (9 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:09 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Add APIs to allow drivers to notify the PCI core of which devices are
being preserved across a Live Update for the next kernel, i.e.
"outgoing" devices.
Drivers must notify the PCI core when devices are preserved so that the
PCI core can update its FLB data (struct pci_ser) and track the list of
outgoing devices. pci_liveupdate_preserve() notifies the PCI core that a
device must be preserved across Live Update. pci_liveupdate_unpreserve()
reverses this (cancels the preservation of the device).
This tracking ensures the PCI core is fully aware of which devices may
need special handling during shutdown and kexec, and so the list of
preserved devices can be handed off to the next kernel.
For now, the API only supports preserving non-VF devices on a root bus
(not behind an PCI-to-PCI bridges).
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Reviewed-by: Bjorn Helgaas <bhelgaas@google.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
drivers/pci/liveupdate.c | 210 +++++++++++++++++++++++++++++++++
drivers/pci/liveupdate.h | 21 ++++
drivers/pci/probe.c | 2 +
include/linux/pci.h | 3 +
include/linux/pci_liveupdate.h | 21 ++++
5 files changed, 257 insertions(+)
create mode 100644 drivers/pci/liveupdate.h
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index fffb41a66ca7..b003b7069cdb 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -36,6 +36,27 @@
*
* * ``pci_liveupdate_register_flb(driver_file_handler)``
* * ``pci_liveupdate_unregister_flb(driver_file_handler)``
+ *
+ * Device Tracking
+ * ===============
+ *
+ * Drivers must notify the PCI core when specific devices are preserved or
+ * unpreserved with the following APIs:
+ *
+ * * ``pci_liveupdate_preserve(pci_dev)``
+ * * ``pci_liveupdate_unpreserve(pci_dev)``
+ *
+ * This allows the PCI core to keep its FLB data (struct pci_ser) up to date
+ * with the list of **outgoing** preserved devices for the next kernel.
+ *
+ * Restrictions
+ * ============
+ *
+ * The PCI core enforces the following restrictions on which devices can be
+ * preserved. These may be relaxed in the future:
+ *
+ * * The device cannot be a Virtual Function (VF).
+ * * The device cannot be behind a PCI-to-PCI bridge.
*/
#define pr_fmt(fmt) "PCI: liveupdate: " fmt
@@ -50,6 +71,21 @@
#include <linux/pci.h>
#include <linux/slab.h>
+#include "liveupdate.h"
+
+/**
+ * struct pci_liveupdate_global - Global state for PCI Live Update support
+ * @rwsem: Reader/writer semaphore used to protect the incoming and outgoing
+ * FLBs, and the references to them in struct pci_dev.
+ */
+struct pci_liveupdate_global {
+ struct rw_semaphore rwsem;
+};
+
+static struct pci_liveupdate_global pci_liveupdate = {
+ .rwsem = __RWSEM_INITIALIZER(pci_liveupdate.rwsem),
+};
+
/**
* struct pci_flb_outgoing - Outgoing PCI FLB object
* @ser: Pointer to the preserved struct pci_ser.
@@ -128,6 +164,180 @@ static struct liveupdate_flb pci_liveupdate_flb = {
.compatible = PCI_LUO_FLB_COMPATIBLE,
};
+static void pci_liveupdate_flb_put_outgoing(void)
+{
+ liveupdate_flb_put_outgoing(&pci_liveupdate_flb);
+}
+
+static struct pci_flb_outgoing *pci_liveupdate_flb_get_outgoing(void)
+{
+ struct pci_flb_outgoing *outgoing = NULL;
+ int ret;
+
+ ret = liveupdate_flb_get_outgoing(&pci_liveupdate_flb, (void **)&outgoing);
+ if (ret)
+ return ERR_PTR(ret);
+
+ if (!outgoing)
+ return ERR_PTR(-ENOENT);
+
+ return outgoing;
+}
+
+static struct pci_dev_ser *pci_flb_alloc_dev_ser(struct pci_flb_outgoing *outgoing)
+{
+ struct pci_dev_ser *dev_ser;
+ struct kho_block_set_it it;
+ u64 count = 0;
+ int err;
+
+ kho_block_set_it_init(&it, &outgoing->block_set);
+
+ /* Try to find an existing, previously unpreserved, entry. */
+ while ((dev_ser = kho_block_set_it_read_entry(&it))) {
+ if (!dev_ser->refcount)
+ return dev_ser;
+
+ count++;
+ }
+
+ /* Otherwise grow the block set and reserve a new entry. */
+ err = kho_block_set_grow(&outgoing->block_set, count + 1);
+ if (err)
+ return ERR_PTR(err);
+
+ if (!count)
+ kho_block_set_it_init(&it, &outgoing->block_set);
+
+ /* This should always succeed since kho_block_set_grow() succeeded. */
+ dev_ser = kho_block_set_it_reserve_entry(&it);
+ if (WARN_ON_ONCE(!dev_ser))
+ return ERR_PTR(-ENOSPC);
+
+ return dev_ser;
+}
+
+static void pci_liveupdate_unpreserve_device(struct pci_flb_outgoing *outgoing,
+ struct pci_dev *dev)
+{
+ struct pci_dev_ser *dev_ser = dev->liveupdate.outgoing;
+
+ if (!dev_ser) {
+ pci_warn(dev, "Cannot unpreserve device that is not preserved\n");
+ return;
+ }
+
+ pci_info(dev, "Device will no longer be preserved across next Live Update\n");
+ outgoing->ser->nr_devices--;
+ memset(dev_ser, 0, sizeof(*dev_ser));
+ dev->liveupdate.outgoing = NULL;
+}
+
+static int pci_liveupdate_preserve_device(struct pci_flb_outgoing *outgoing,
+ struct pci_dev *dev)
+{
+ struct pci_dev_ser *dev_ser;
+
+ if (dev->is_virtfn) {
+ pci_warn(dev, "Cannot preserve Virtual Functions\n");
+ return -EINVAL;
+ }
+
+ if (dev->liveupdate.outgoing) {
+ pci_warn(dev, "Device is already preserved\n");
+ return -EBUSY;
+ }
+
+ if (!pci_is_root_bus(dev->bus)) {
+ pci_warn(dev, "Cannot preserve devices behind bridges\n");
+ return -EINVAL;
+ }
+
+ dev_ser = pci_flb_alloc_dev_ser(outgoing);
+ if (IS_ERR(dev_ser))
+ return PTR_ERR(dev_ser);
+
+ pci_info(dev, "Device will be preserved across next Live Update\n");
+ outgoing->ser->nr_devices++;
+ outgoing->ser->devices = kho_block_set_head_pa(&outgoing->block_set);
+
+ dev_ser->domain = pci_domain_nr(dev->bus);
+ dev_ser->bdf = pci_dev_id(dev);
+ dev_ser->refcount = 1;
+
+ dev->liveupdate.outgoing = dev_ser;
+ return 0;
+}
+
+/**
+ * pci_liveupdate_preserve() - Preserve a PCI device across Live Update
+ * @dev: The PCI device to preserve.
+ *
+ * pci_liveupdate_preserve() notifies the PCI core that a PCI device should be
+ * preserved across the next Live Update. Drivers are expected to call
+ * pci_liveupdate_preserve() from their struct liveupdate_file_handler
+ * preserve() callback to ensure the outgoing struct pci_ser is already set up.
+ *
+ * Returns: 0 on success, <0 on failure.
+ */
+int pci_liveupdate_preserve(struct pci_dev *dev)
+{
+ struct pci_flb_outgoing *outgoing = NULL;
+ int ret;
+
+ guard(rwsem_write)(&pci_liveupdate.rwsem);
+
+ outgoing = pci_liveupdate_flb_get_outgoing();
+ if (IS_ERR(outgoing))
+ return PTR_ERR(outgoing);
+
+ ret = pci_liveupdate_preserve_device(outgoing, dev);
+
+ pci_liveupdate_flb_put_outgoing();
+ return ret;
+}
+EXPORT_SYMBOL_GPL(pci_liveupdate_preserve);
+
+/**
+ * pci_liveupdate_unpreserve() - Cancel preservation of a PCI device
+ * @dev: The PCI device to unpreserve.
+ *
+ * pci_liveupdate_unpreserve() notifies the PCI core that a PCI device should no
+ * longer be preserved across the next Live Update. Drivers are expected to call
+ * pci_liveupdate_unpreserve() from their struct liveupdate_file_handler
+ * unpreserve() callback to ensure the outgoing struct pci_ser is already set
+ * up.
+ */
+void pci_liveupdate_unpreserve(struct pci_dev *dev)
+{
+ struct pci_flb_outgoing *outgoing = NULL;
+
+ guard(rwsem_write)(&pci_liveupdate.rwsem);
+
+ outgoing = pci_liveupdate_flb_get_outgoing();
+ if (IS_ERR(outgoing)) {
+ pci_warn(dev, "Cannot unpreserve device without outgoing Live Update state\n");
+ return;
+ }
+
+ pci_liveupdate_unpreserve_device(outgoing, dev);
+ pci_liveupdate_flb_put_outgoing();
+}
+EXPORT_SYMBOL_GPL(pci_liveupdate_unpreserve);
+
+void pci_liveupdate_cleanup_device(struct pci_dev *dev)
+{
+ /*
+ * It should be safe to READ_ONCE() outside of the rwsem during cleanup
+ * since there should no longer be any references to @dev on the system.
+ *
+ * This should never happen in practice. Drivers should block removal
+ * while a device is preserved.
+ */
+ if (READ_ONCE(dev->liveupdate.outgoing))
+ pci_WARN(dev, 1, "Destroying outgoing-preserved device!\n");
+}
+
/**
* pci_liveupdate_register_flb() - Register a file handler with the PCI core
* @fh: The file handler to register.
diff --git a/drivers/pci/liveupdate.h b/drivers/pci/liveupdate.h
new file mode 100644
index 000000000000..b2335581f8d0
--- /dev/null
+++ b/drivers/pci/liveupdate.h
@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * PCI Live Update support (core API)
+ *
+ * Copyright (c) 2026, Google LLC.
+ * David Matlack <dmatlack@google.com>
+ */
+#ifndef DRIVERS_PCI_LIVEUPDATE_H
+#define DRIVERS_PCI_LIVEUPDATE_H
+
+#include <linux/pci.h>
+
+#ifdef CONFIG_PCI_LIVEUPDATE
+void pci_liveupdate_cleanup_device(struct pci_dev *dev);
+#else
+static inline void pci_liveupdate_cleanup_device(struct pci_dev *dev)
+{
+}
+#endif
+
+#endif /* DRIVERS_PCI_LIVEUPDATE_H */
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index dd0abbc63e18..14b66acbdb15 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -24,6 +24,7 @@
#include <linux/pm_runtime.h>
#include <linux/bitfield.h>
#include <trace/events/pci.h>
+#include "liveupdate.h"
#include "pci.h"
static struct resource busn_resource = {
@@ -2485,6 +2486,7 @@ static void pci_release_dev(struct device *dev)
pci_dev = to_pci_dev(dev);
pci_release_capabilities(pci_dev);
+ pci_liveupdate_cleanup_device(pci_dev);
pci_release_of_node(pci_dev);
pcibios_release_device(pci_dev);
pci_bus_put(pci_dev->bus);
diff --git a/include/linux/pci.h b/include/linux/pci.h
index da58aa101e4c..b41dd572a2d6 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -593,6 +593,9 @@ struct pci_dev {
u8 tph_mode; /* TPH mode */
u8 tph_req_type; /* TPH requester type */
#endif
+#ifdef CONFIG_PCI_LIVEUPDATE
+ struct pci_liveupdate liveupdate;
+#endif
};
static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
diff --git a/include/linux/pci_liveupdate.h b/include/linux/pci_liveupdate.h
index 8ec98beefcb4..894052ad6961 100644
--- a/include/linux/pci_liveupdate.h
+++ b/include/linux/pci_liveupdate.h
@@ -8,14 +8,26 @@
#ifndef LINUX_PCI_LIVEUPDATE_H
#define LINUX_PCI_LIVEUPDATE_H
+#include <linux/kho/abi/pci.h>
#include <linux/liveupdate.h>
+#include <linux/spinlock_types.h>
#include <linux/types.h>
+/**
+ * struct pci_liveupdate - PCI Live Update state for a struct pci_dev
+ * @outgoing: State preserved for the next kernel.
+ */
+struct pci_liveupdate {
+ struct pci_dev_ser *outgoing;
+};
+
struct pci_dev;
#ifdef CONFIG_PCI_LIVEUPDATE
int pci_liveupdate_register_flb(struct liveupdate_file_handler *fh);
void pci_liveupdate_unregister_flb(struct liveupdate_file_handler *fh);
+int pci_liveupdate_preserve(struct pci_dev *dev);
+void pci_liveupdate_unpreserve(struct pci_dev *dev);
#else
static inline int pci_liveupdate_register_flb(struct liveupdate_file_handler *fh)
{
@@ -25,6 +37,15 @@ static inline int pci_liveupdate_register_flb(struct liveupdate_file_handler *fh
static inline void pci_liveupdate_unregister_flb(struct liveupdate_file_handler *fh)
{
}
+
+static inline int pci_liveupdate_preserve(struct pci_dev *dev)
+{
+ return -EOPNOTSUPP;
+}
+
+static inline void pci_liveupdate_unpreserve(struct pci_dev *dev)
+{
+}
#endif
#endif /* LINUX_PCI_LIVEUPDATE_H */
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v8 02/12] PCI: liveupdate: Track outgoing preserved PCI devices
2026-07-28 22:09 ` [PATCH v8 02/12] PCI: liveupdate: Track outgoing preserved PCI devices David Matlack
@ 2026-07-28 22:19 ` sashiko-bot
0 siblings, 0 replies; 26+ messages in thread
From: sashiko-bot @ 2026-07-28 22:19 UTC (permalink / raw)
To: David Matlack; +Cc: linux-pci
> Add APIs to allow drivers to notify the PCI core of which devices are
> being preserved across a Live Update for the next kernel, i.e.
> "outgoing" devices.
>
> Drivers must notify the PCI core when devices are preserved so that the
> PCI core can update its FLB data (struct pci_ser) and track the list of
> outgoing devices. pci_liveupdate_preserve() notifies the PCI core that a
> device must be preserved across Live Update. pci_liveupdate_unpreserve()
> reverses this (cancels the preservation of the device).
>
> This tracking ensures the PCI core is fully aware of which devices may
> need special handling during shutdown and kexec, and so the list of
> preserved devices can be handed off to the next kernel.
>
> For now, the API only supports preserving non-VF devices on a root bus
> (not behind an PCI-to-PCI bridges).
>
> Reviewed-by: Pranjal Shrivastava <praan@google.com>
> Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
> Reviewed-by: Bjorn Helgaas <bhelgaas@google.com>
> Signed-off-by: David Matlack <dmatlack@google.com>
Sashiko has reviewed this patch and found no issues. It looks great!
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260728221007.2098560-1-dmatlack@google.com?part=2
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v8 03/12] PCI: liveupdate: Track incoming preserved PCI devices
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
2026-07-28 22:09 ` [PATCH v8 01/12] PCI: liveupdate: Set up FLB handler for the PCI core David Matlack
2026-07-28 22:09 ` [PATCH v8 02/12] PCI: liveupdate: Track outgoing preserved PCI devices David Matlack
@ 2026-07-28 22:09 ` David Matlack
2026-07-28 22:22 ` sashiko-bot
2026-07-28 22:09 ` [PATCH v8 04/12] PCI: liveupdate: Document driver binding responsibilities David Matlack
` (8 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:09 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
During PCI enumeration, the previous kernel might have passed state about
devices that were preserved across kexec. The PCI core needs to fetch
this state to identify which devices are "incoming" and require special
handling.
Add pci_liveupdate_setup_device() which is called during device setup
to fetch the serialized state (struct pci_ser) from the Live Update
Orchestrator. The first time this happens, pci_flb_retrieve() will run
and convert the array of pci_dev_ser structs into an xarray so that it
can be looked up efficiently.
If a device is found in the xarray, the PCI core stores a pointer to its
state in dev->liveupdate_incoming until pci_liveupdate_finish() is
called by the driver. This pointer allows the PCI core and drivers to
apply Live Update-specific logic to incoming devices in subsequent
commits.
Drivers can check if a device is an incoming preserved device (e.g.
during probe) by calling pci_liveupdate_is_incoming().
CONFIG_64BIT is now required to enable CONFIG_PCI_LIVEUPDATE so that the
domain and bdf can be guaranteed to fit in an unsigned long and be used
as the xarray key.
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
MAINTAINERS | 1 +
drivers/pci/Kconfig | 2 +-
drivers/pci/liveupdate.c | 256 ++++++++++++++++++++++++++++++++-
drivers/pci/liveupdate.h | 5 +
drivers/pci/probe.c | 3 +
include/linux/pci_liveupdate.h | 13 ++
6 files changed, 277 insertions(+), 3 deletions(-)
diff --git a/MAINTAINERS b/MAINTAINERS
index 9cc7b9291ace..08a724b860dc 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -20834,6 +20834,7 @@ L: linux-pci@vger.kernel.org
S: Maintained
T: git git://git.kernel.org/pub/scm/linux/kernel/git/liveupdate/linux.git
F: drivers/pci/liveupdate.c
+F: drivers/pci/liveupdate.h
F: include/linux/kho/abi/pci.h
F: include/linux/pci_liveupdate.h
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 3781e2b5f095..8af20f558086 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -273,7 +273,7 @@ config VGA_ARB_MAX_GPUS
config PCI_LIVEUPDATE
bool "PCI Live Update Support"
- depends on PCI && LIVEUPDATE
+ depends on PCI && LIVEUPDATE && 64BIT
help
Enable PCI core support for preserving PCI devices across Live
Update. This, in combination with support in a device's driver,
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index b003b7069cdb..5ce5f8b36902 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -49,6 +49,20 @@
* This allows the PCI core to keep its FLB data (struct pci_ser) up to date
* with the list of **outgoing** preserved devices for the next kernel.
*
+ * After kexec, whenever a device is enumerated, the PCI core will check if it
+ * is an **incoming** preserved device (i.e. preserved by the previous kernel)
+ * by checking the incoming FLB data (struct pci_ser).
+ *
+ * Drivers must notify the PCI core when an **incoming** device is done
+ * participating in the incoming Live Update with the following API:
+ *
+ * * ``pci_liveupdate_finish(pci_dev)``
+ *
+ * The PCI core does not enforce any ordering of ``pci_liveupdate_finish()`` and
+ * ``pci_liveupdate_preserve()``. i.e. A PCI device can be **outgoing**
+ * (preserved for next kernel) and **incoming** (preserved by previous kernel)
+ * at the same time.
+ *
* Restrictions
* ============
*
@@ -100,6 +114,26 @@ struct pci_flb_outgoing {
struct kho_block_set block_set;
};
+/**
+ * struct pci_flb_incoming - Incoming PCI FLB object
+ * @ser: The incoming struct pci_ser from the previous kernel.
+ * @xa: Xarray used to quickly lookup devices in @ser.
+ * @block_set: The KHO block set holding the incoming devices.
+ *
+ * This structure holds the runtime state for the incoming PCI Live Update
+ * state. It wraps the serialized pci_ser, the block_set used to restore
+ * the serialized entries, and an xarray for fast lookups.
+ */
+struct pci_flb_incoming {
+ struct pci_ser *ser;
+ struct xarray xa;
+ struct kho_block_set block_set;
+};
+
+static unsigned long pci_ser_xa_key(u32 domain, u16 bdf)
+{
+ return (unsigned long)domain << 16 | bdf;
+}
static int pci_flb_preserve(struct liveupdate_flb_op_args *args)
{
struct pci_flb_outgoing *outgoing __free(kfree) = NULL;
@@ -140,15 +174,91 @@ static void pci_flb_unpreserve(struct liveupdate_flb_op_args *args)
static int pci_flb_retrieve(struct liveupdate_flb_op_args *args)
{
+ struct pci_ser *ser = phys_to_virt(args->data);
+ struct pci_flb_incoming *incoming;
+ struct pci_dev_ser *dev_ser;
+ struct kho_block_set_it it;
+ int ret;
+
pr_debug("Retrieving struct pci_ser (0x%llx)\n", args->data);
- args->obj = phys_to_virt(args->data);
+
+ if (ser->version != PCI_LUO_FLB_VERSION) {
+ pr_err("Incoming PCI FLB version (v%d) is incompatible with this kernel (v%d)\n",
+ ser->version, PCI_LUO_FLB_VERSION);
+ ret = -EINVAL;
+ goto err_restore_free;
+ }
+
+ incoming = kzalloc_obj(*incoming);
+ if (!incoming) {
+ ret = -ENOMEM;
+ goto err_restore_free;
+ }
+
+ incoming->ser = ser;
+ xa_init(&incoming->xa);
+
+ kho_block_set_init(&incoming->block_set, sizeof(struct pci_dev_ser));
+ ret = kho_block_set_restore(&incoming->block_set, ser->devices);
+ if (ret)
+ goto err_free_incoming;
+
+ kho_block_set_it_init(&it, &incoming->block_set);
+ while ((dev_ser = kho_block_set_it_read_entry(&it))) {
+ unsigned long key;
+
+ if (!dev_ser->refcount)
+ continue;
+
+ key = pci_ser_xa_key(dev_ser->domain, dev_ser->bdf);
+ ret = xa_insert(&incoming->xa, key, dev_ser, GFP_KERNEL);
+ if (ret)
+ goto err_block_set_destroy;
+ }
+
+ args->obj = incoming;
return 0;
+
+err_block_set_destroy:
+ kho_block_set_destroy(&incoming->block_set);
+err_free_incoming:
+ xa_destroy(&incoming->xa);
+ kfree(incoming);
+err_restore_free:
+ kho_restore_free(ser);
+ return ret;
+}
+
+static void pci_check_all_devices_finished(struct pci_flb_incoming *incoming)
+{
+ struct pci_dev *dev = NULL;
+
+ if (READ_ONCE(incoming->ser->nr_devices) == 0)
+ return;
+
+ for_each_pci_dev(dev) {
+ if (READ_ONCE(dev->liveupdate.incoming))
+ pci_emerg(dev, "Preserved device was never finished!\n");
+ }
+
+ /*
+ * This should only happen if a driver violated the contract to call
+ * pci_liveupdate_finish() (something is extremely broken).
+ */
+ panic("Some preserved devices were never finished!\n");
}
static void pci_flb_finish(struct liveupdate_flb_op_args *args)
{
+ struct pci_flb_incoming *incoming = args->obj;
+
pr_debug("Finished struct pci_ser (0x%llx)\n", args->data);
- kho_restore_free(args->obj);
+ pci_check_all_devices_finished(incoming);
+
+ xa_destroy(&incoming->xa);
+ kho_block_set_destroy(&incoming->block_set);
+ kho_restore_free(incoming->ser);
+ kfree(incoming);
}
static struct liveupdate_flb_ops pci_liveupdate_flb_ops = {
@@ -325,6 +435,75 @@ void pci_liveupdate_unpreserve(struct pci_dev *dev)
}
EXPORT_SYMBOL_GPL(pci_liveupdate_unpreserve);
+static struct pci_flb_incoming *pci_liveupdate_flb_get_incoming(void)
+{
+ struct pci_flb_incoming *incoming = NULL;
+ int ret;
+
+ ret = liveupdate_flb_get_incoming(&pci_liveupdate_flb, (void **)&incoming);
+
+ /* Live Update is not enabled. */
+ if (ret == -EOPNOTSUPP)
+ return NULL;
+
+ /* Live Update is enabled, but there is no incoming FLB data. */
+ if (ret == -ENODATA)
+ return NULL;
+
+ /*
+ * Live Update is enabled and there is incoming FLB data, but none of it
+ * matches pci_liveupdate_flb.compatible.
+ */
+ if (ret == -ENOENT)
+ return NULL;
+
+ /*
+ * There is incoming FLB data that matches pci_liveupdate_flb.compatible
+ * but retrieve failed (pci_flb_retrieve() returned an error or LUO
+ * failed to acquire a reference to pci_liveupdate_flb_ops.owner).
+ */
+ if (ret)
+ panic("Failed to retrieve incoming FLB data (%d)\n", ret);
+
+ return incoming;
+}
+
+static void pci_liveupdate_flb_put_incoming(void)
+{
+ liveupdate_flb_put_incoming(&pci_liveupdate_flb);
+}
+
+void pci_liveupdate_setup_device(struct pci_dev *dev)
+{
+ struct pci_flb_incoming *incoming;
+ struct pci_dev_ser *dev_ser;
+ unsigned long key;
+
+ guard(rwsem_write)(&pci_liveupdate.rwsem);
+
+ incoming = pci_liveupdate_flb_get_incoming();
+ if (!incoming)
+ return;
+
+ key = pci_ser_xa_key(pci_domain_nr(dev->bus), pci_dev_id(dev));
+ dev_ser = xa_load(&incoming->xa, key);
+
+ /*
+ * This device was not preserved across Live Update, or it was preserved
+ * but has already been probed and gone through pci_liveupdate_finish(),
+ * e.g. due to removing and re-adding the device. Either way, it's not
+ * treated as incoming-preserved.
+ */
+ if (!dev_ser || !dev_ser->refcount) {
+ pci_liveupdate_flb_put_incoming();
+ return;
+ }
+
+ pci_info(dev, "Device was preserved by previous kernel across Live Update\n");
+ dev->liveupdate.incoming = dev_ser;
+ pci_liveupdate_flb_put_incoming();
+}
+
void pci_liveupdate_cleanup_device(struct pci_dev *dev)
{
/*
@@ -336,7 +515,80 @@ void pci_liveupdate_cleanup_device(struct pci_dev *dev)
*/
if (READ_ONCE(dev->liveupdate.outgoing))
pci_WARN(dev, 1, "Destroying outgoing-preserved device!\n");
+
+ if (READ_ONCE(dev->liveupdate.incoming))
+ pci_WARN(dev, 1, "Destroying incoming-preserved device!\n");
+}
+
+static void pci_liveupdate_finish_device(struct pci_ser *ser, struct pci_dev *dev)
+{
+ if (!dev->liveupdate.incoming) {
+ pci_warn(dev, "Cannot finish preserving an unpreserved device\n");
+ return;
+ }
+
+ if (dev->liveupdate.incoming->refcount != 1) {
+ pci_WARN(dev, 1, "Preserved device has a corrupted refcount!\n");
+ return;
+ }
+
+ /*
+ * Drop the refcount so this device does not get treated as an incoming
+ * device again, e.g. in case pci_liveupdate_setup_device() gets called
+ * again because the device is hot-plugged.
+ */
+ dev->liveupdate.incoming->refcount = 0;
+
+ pci_info(dev, "Device is finished participating in Live Update\n");
+ dev->liveupdate.incoming = NULL;
+ ser->nr_devices--;
+}
+
+/**
+ * pci_liveupdate_finish() - Finish the preservation of a PCI device
+ * @dev: The PCI device
+ *
+ * pci_liveupdate_finish() notifies the PCI core that a PCI device that was
+ * preserved across the previous Live Update has finished participating in Live
+ * Update. Drivers must call pci_liveupdate_finish() from their struct
+ * liveupdate_file_handler finish() callback to ensure the incoming struct
+ * pci_ser is allocated.
+ */
+void pci_liveupdate_finish(struct pci_dev *dev)
+{
+ struct pci_flb_incoming *incoming;
+
+ guard(rwsem_write)(&pci_liveupdate.rwsem);
+
+ incoming = pci_liveupdate_flb_get_incoming();
+ if (!incoming) {
+ pci_warn(dev, "Cannot finish preserving device without incoming FLB\n");
+ return;
+ }
+
+ pci_liveupdate_finish_device(incoming->ser, dev);
+ pci_liveupdate_flb_put_incoming();
+}
+EXPORT_SYMBOL_GPL(pci_liveupdate_finish);
+
+/**
+ * pci_liveupdate_is_incoming() - Check if a device is incoming-preserved
+ * @dev: The PCI device to check
+ *
+ * Check if a device was preserved across Live Update by the previous kernel,
+ * i.e. the device is incoming-preserved. Note that a device is only considered
+ * incoming-preserved prior to pci_liveupdate_finish(). It is up to drivers to
+ * synchronize usage of pci_liveupdate_is_incoming() with their own call to
+ * pci_liveupdate_finish() to avoid acting on stale data.
+ *
+ * Returns: True if the device is incoming-preserved, false otherwise.
+ */
+bool pci_liveupdate_is_incoming(struct pci_dev *dev)
+{
+ guard(rwsem_read)(&pci_liveupdate.rwsem);
+ return dev->liveupdate.incoming;
}
+EXPORT_SYMBOL_GPL(pci_liveupdate_is_incoming);
/**
* pci_liveupdate_register_flb() - Register a file handler with the PCI core
diff --git a/drivers/pci/liveupdate.h b/drivers/pci/liveupdate.h
index b2335581f8d0..eaaa3559fd77 100644
--- a/drivers/pci/liveupdate.h
+++ b/drivers/pci/liveupdate.h
@@ -11,8 +11,13 @@
#include <linux/pci.h>
#ifdef CONFIG_PCI_LIVEUPDATE
+void pci_liveupdate_setup_device(struct pci_dev *dev);
void pci_liveupdate_cleanup_device(struct pci_dev *dev);
#else
+static inline void pci_liveupdate_setup_device(struct pci_dev *dev)
+{
+}
+
static inline void pci_liveupdate_cleanup_device(struct pci_dev *dev)
{
}
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 14b66acbdb15..5dc9d86e3597 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -2065,6 +2065,8 @@ int pci_setup_device(struct pci_dev *dev)
if (pci_early_dump)
early_dump_pci_device(dev);
+ pci_liveupdate_setup_device(dev);
+
/* Need to have dev->class ready */
dev->cfg_size = pci_cfg_space_size(dev);
@@ -2188,6 +2190,7 @@ int pci_setup_device(struct pci_dev *dev)
default: /* unknown header */
pci_err(dev, "unknown header type %02x, ignoring device\n",
dev->hdr_type);
+ pci_liveupdate_cleanup_device(dev);
pci_release_of_node(dev);
return -EIO;
diff --git a/include/linux/pci_liveupdate.h b/include/linux/pci_liveupdate.h
index 894052ad6961..710026ada2d5 100644
--- a/include/linux/pci_liveupdate.h
+++ b/include/linux/pci_liveupdate.h
@@ -16,9 +16,11 @@
/**
* struct pci_liveupdate - PCI Live Update state for a struct pci_dev
* @outgoing: State preserved for the next kernel.
+ * @incoming: State preserved by the previous kernel.
*/
struct pci_liveupdate {
struct pci_dev_ser *outgoing;
+ struct pci_dev_ser *incoming;
};
struct pci_dev;
@@ -28,6 +30,8 @@ int pci_liveupdate_register_flb(struct liveupdate_file_handler *fh);
void pci_liveupdate_unregister_flb(struct liveupdate_file_handler *fh);
int pci_liveupdate_preserve(struct pci_dev *dev);
void pci_liveupdate_unpreserve(struct pci_dev *dev);
+void pci_liveupdate_finish(struct pci_dev *dev);
+bool pci_liveupdate_is_incoming(struct pci_dev *dev);
#else
static inline int pci_liveupdate_register_flb(struct liveupdate_file_handler *fh)
{
@@ -46,6 +50,15 @@ static inline int pci_liveupdate_preserve(struct pci_dev *dev)
static inline void pci_liveupdate_unpreserve(struct pci_dev *dev)
{
}
+
+static inline void pci_liveupdate_finish(struct pci_dev *dev)
+{
+}
+
+static inline bool pci_liveupdate_is_incoming(struct pci_dev *dev)
+{
+ return false;
+}
#endif
#endif /* LINUX_PCI_LIVEUPDATE_H */
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v8 03/12] PCI: liveupdate: Track incoming preserved PCI devices
2026-07-28 22:09 ` [PATCH v8 03/12] PCI: liveupdate: Track incoming " David Matlack
@ 2026-07-28 22:22 ` sashiko-bot
2026-07-28 23:37 ` David Matlack
0 siblings, 1 reply; 26+ messages in thread
From: sashiko-bot @ 2026-07-28 22:22 UTC (permalink / raw)
To: David Matlack; +Cc: linux-pci
Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
- [High] Unconditional kernel panic in the incoming FLB finish path if a preserved PCI device is missing or fails setup.
- [High] `pci_flb_unpreserve()` destroys outgoing FLB memory without clearing device pointers, leading to a Use-After-Free.
- [High] Transient errors or version mismatches during FLB retrieval cause an immediate kernel panic on device setup.
- [Medium] Leaking preserved KHO memory for `ser->devices` on early error paths in `pci_flb_retrieve()`.
--
--- Patch [3]: [PATCH v8 03/12] PCI: liveupdate: Track incoming preserved PCI devices ---
commit 8fdc703d6dd44076cd03589af0bcffa13c79e7f4
Author: David Matlack <dmatlack@google.com>
PCI: liveupdate: Track incoming preserved PCI devices
This patch allows the PCI core to track incoming preserved PCI devices
during enumeration. It fetches the serialized state from the Live Update
Orchestrator and exposes APIs for drivers to handle incoming devices.
> diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
> index b003b7069cdb0..5ce5f8b369029 100644
> --- a/drivers/pci/liveupdate.c
> +++ b/drivers/pci/liveupdate.c
[ ... ]
> @@ -140,15 +174,91 @@ static int pci_flb_retrieve(struct liveupdate_flb_op_args *args)
> {
> + struct pci_ser *ser = phys_to_virt(args->data);
> + struct pci_flb_incoming *incoming;
> + struct pci_dev_ser *dev_ser;
> + struct kho_block_set_it it;
> + int ret;
>
> pr_debug("Retrieving struct pci_ser (0x%llx)\n", args->data);
> - args->obj = phys_to_virt(args->data);
> +
> + if (ser->version != PCI_LUO_FLB_VERSION) {
> + pr_err("Incoming PCI FLB version (v%d) is incompatible with this kernel (v%d)\n",
> + ser->version, PCI_LUO_FLB_VERSION);
> + ret = -EINVAL;
> + goto err_restore_free;
> + }
> +
> + incoming = kzalloc_obj(*incoming);
> + if (!incoming) {
> + ret = -ENOMEM;
> + goto err_restore_free;
> + }
[ ... ]
> +err_restore_free:
> + kho_restore_free(ser);
> + return ret;
> +}
[Severity: Medium]
Does this error path leak the KHO memory for ser->devices?
When jumping to err_restore_free (e.g. due to a version mismatch or kzalloc
failure), kho_restore_free(ser) is called, but it doesn't appear to restore
or free the memory pointed to by ser->devices.
Since KHO pages are reserved across kexec, will this permanently leak the
memory for the uptime of the successor kernel?
[ ... ]
> +static void pci_check_all_devices_finished(struct pci_flb_incoming *incoming)
> +{
> + struct pci_dev *dev = NULL;
> +
> + if (READ_ONCE(incoming->ser->nr_devices) == 0)
> + return;
> +
> + for_each_pci_dev(dev) {
> + if (READ_ONCE(dev->liveupdate.incoming))
> + pci_emerg(dev, "Preserved device was never finished!\n");
> + }
> +
> + /*
> + * This should only happen if a driver violated the contract to call
> + * pci_liveupdate_finish() (something is extremely broken).
> + */
> + panic("Some preserved devices were never finished!\n");
> +}
[Severity: High]
Is an unconditional panic here safe if a preserved device is missing or
fails to probe?
If a PCI device that was preserved by the previous kernel fails to probe in
the new kernel (e.g. the driver module is missing, or it encounters a
transient error), pci_liveupdate_finish() will never be called and
incoming->ser->nr_devices will not be decremented.
When the Live Update orchestrator concludes the update and calls
pci_flb_finish(), pci_check_all_devices_finished() is invoked and sees
that nr_devices is still > 0. Does this mean normal system conditions like
a missing driver will trigger a kernel panic?
[ ... ]
> @@ -325,6 +435,75 @@ void pci_liveupdate_unpreserve(struct pci_dev *dev)
> }
> EXPORT_SYMBOL_GPL(pci_liveupdate_unpreserve);
>
> +static struct pci_flb_incoming *pci_liveupdate_flb_get_incoming(void)
> +{
> + struct pci_flb_incoming *incoming = NULL;
> + int ret;
[ ... ]
> + /*
> + * There is incoming FLB data that matches pci_liveupdate_flb.compatible
> + * but retrieve failed (pci_flb_retrieve() returned an error or LUO
> + * failed to acquire a reference to pci_liveupdate_flb_ops.owner).
> + */
> + if (ret)
> + panic("Failed to retrieve incoming FLB data (%d)\n", ret);
> +
> + return incoming;
> +}
[Severity: High]
Does this panic prevent the new kernel from booting if there's a simple
FLB version mismatch?
During PCI enumeration in the new kernel, pci_setup_device() calls
pci_liveupdate_setup_device(), which invokes
pci_liveupdate_flb_get_incoming().
If pci_flb_retrieve() encounters an error like a version mismatch (-EINVAL)
or an allocation failure (-ENOMEM), it returns that error code. This branch
then catches the error and unconditionally panics. Will this reliably crash
the new kernel during early boot and break the kexec handover fallback
mechanism?
[ ... ]
I also have a question about the unpreserve path in pci_flb_unpreserve()
which might lead to a regression:
drivers/pci/liveupdate.c:pci_flb_unpreserve() {
...
WARN_ON(outgoing->ser->nr_devices);
kho_block_set_destroy(&outgoing->block_set);
kho_unpreserve_free(outgoing->ser);
kfree(outgoing);
}
[Severity: High]
Does pci_flb_unpreserve() destroy outgoing FLB memory without clearing the
device pointers?
If a driver fails to unpreserve its devices before the orchestrator aborts a
Live Update, pci_flb_unpreserve() will issue a WARN_ON but proceed to
destroy the block set and free the outgoing FLB object.
The dev->liveupdate.outgoing pointers on the pci_dev structs are left
dangling. If a new Live Update is subsequently initiated and the driver
attempts to preserve the device again, pci_liveupdate_preserve_device()
will access dev->liveupdate.outgoing->refcount via the dangling pointer:
drivers/pci/liveupdate.c:pci_liveupdate_preserve_device() {
...
if (dev->liveupdate.outgoing) {
if (!dev->liveupdate.outgoing->refcount) {
...
}
Can this lead to a use-after-free of the KHO block set memory?
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260728221007.2098560-1-dmatlack@google.com?part=3
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v8 03/12] PCI: liveupdate: Track incoming preserved PCI devices
2026-07-28 22:22 ` sashiko-bot
@ 2026-07-28 23:37 ` David Matlack
0 siblings, 0 replies; 26+ messages in thread
From: David Matlack @ 2026-07-28 23:37 UTC (permalink / raw)
To: sashiko-reviews; +Cc: linux-pci
On Tue, Jul 28, 2026 at 3:22 PM <sashiko-bot@kernel.org> wrote:
>
> Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
> - [High] Unconditional kernel panic in the incoming FLB finish path if a preserved PCI device is missing or fails setup.
> - [High] `pci_flb_unpreserve()` destroys outgoing FLB memory without clearing device pointers, leading to a Use-After-Free.
> - [High] Transient errors or version mismatches during FLB retrieval cause an immediate kernel panic on device setup.
> - [Medium] Leaking preserved KHO memory for `ser->devices` on early error paths in `pci_flb_retrieve()`.
> --
>
> --- Patch [3]: [PATCH v8 03/12] PCI: liveupdate: Track incoming preserved PCI devices ---
> commit 8fdc703d6dd44076cd03589af0bcffa13c79e7f4
> Author: David Matlack <dmatlack@google.com>
>
> PCI: liveupdate: Track incoming preserved PCI devices
>
> This patch allows the PCI core to track incoming preserved PCI devices
> during enumeration. It fetches the serialized state from the Live Update
> Orchestrator and exposes APIs for drivers to handle incoming devices.
>
> > diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
> > index b003b7069cdb0..5ce5f8b369029 100644
> > --- a/drivers/pci/liveupdate.c
> > +++ b/drivers/pci/liveupdate.c
> [ ... ]
> > @@ -140,15 +174,91 @@ static int pci_flb_retrieve(struct liveupdate_flb_op_args *args)
> > {
> > + struct pci_ser *ser = phys_to_virt(args->data);
> > + struct pci_flb_incoming *incoming;
> > + struct pci_dev_ser *dev_ser;
> > + struct kho_block_set_it it;
> > + int ret;
> >
> > pr_debug("Retrieving struct pci_ser (0x%llx)\n", args->data);
> > - args->obj = phys_to_virt(args->data);
> > +
> > + if (ser->version != PCI_LUO_FLB_VERSION) {
> > + pr_err("Incoming PCI FLB version (v%d) is incompatible with this kernel (v%d)\n",
> > + ser->version, PCI_LUO_FLB_VERSION);
> > + ret = -EINVAL;
> > + goto err_restore_free;
> > + }
> > +
> > + incoming = kzalloc_obj(*incoming);
> > + if (!incoming) {
> > + ret = -ENOMEM;
> > + goto err_restore_free;
> > + }
> [ ... ]
> > +err_restore_free:
> > + kho_restore_free(ser);
> > + return ret;
> > +}
>
> [Severity: Medium]
> Does this error path leak the KHO memory for ser->devices?
>
> When jumping to err_restore_free (e.g. due to a version mismatch or kzalloc
> failure), kho_restore_free(ser) is called, but it doesn't appear to restore
> or free the memory pointed to by ser->devices.
>
> Since KHO pages are reserved across kexec, will this permanently leak the
> memory for the uptime of the successor kernel?
Yes, but PCI FLB retrieve errors are fatal (panic).
>
> [ ... ]
> > +static void pci_check_all_devices_finished(struct pci_flb_incoming *incoming)
> > +{
> > + struct pci_dev *dev = NULL;
> > +
> > + if (READ_ONCE(incoming->ser->nr_devices) == 0)
> > + return;
> > +
> > + for_each_pci_dev(dev) {
> > + if (READ_ONCE(dev->liveupdate.incoming))
> > + pci_emerg(dev, "Preserved device was never finished!\n");
> > + }
> > +
> > + /*
> > + * This should only happen if a driver violated the contract to call
> > + * pci_liveupdate_finish() (something is extremely broken).
> > + */
> > + panic("Some preserved devices were never finished!\n");
> > +}
>
> [Severity: High]
> Is an unconditional panic here safe if a preserved device is missing or
> fails to probe?
>
> If a PCI device that was preserved by the previous kernel fails to probe in
> the new kernel (e.g. the driver module is missing, or it encounters a
> transient error), pci_liveupdate_finish() will never be called and
> incoming->ser->nr_devices will not be decremented.
>
> When the Live Update orchestrator concludes the update and calls
> pci_flb_finish(), pci_check_all_devices_finished() is invoked and sees
> that nr_devices is still > 0. Does this mean normal system conditions like
> a missing driver will trigger a kernel panic?
The file associated with a device that fails to be enumerated or
probed cannever be retrieved by userspace, and therefore never go
through its finish() callback. So LUO will never call
pci_flb_finish(). This panic will only happen if there is a serious
bug in the driver or LUO.
>
> [ ... ]
> > @@ -325,6 +435,75 @@ void pci_liveupdate_unpreserve(struct pci_dev *dev)
> > }
> > EXPORT_SYMBOL_GPL(pci_liveupdate_unpreserve);
> >
> > +static struct pci_flb_incoming *pci_liveupdate_flb_get_incoming(void)
> > +{
> > + struct pci_flb_incoming *incoming = NULL;
> > + int ret;
> [ ... ]
> > + /*
> > + * There is incoming FLB data that matches pci_liveupdate_flb.compatible
> > + * but retrieve failed (pci_flb_retrieve() returned an error or LUO
> > + * failed to acquire a reference to pci_liveupdate_flb_ops.owner).
> > + */
> > + if (ret)
> > + panic("Failed to retrieve incoming FLB data (%d)\n", ret);
> > +
> > + return incoming;
> > +}
>
> [Severity: High]
> Does this panic prevent the new kernel from booting if there's a simple
> FLB version mismatch?
>
> During PCI enumeration in the new kernel, pci_setup_device() calls
> pci_liveupdate_setup_device(), which invokes
> pci_liveupdate_flb_get_incoming().
>
> If pci_flb_retrieve() encounters an error like a version mismatch (-EINVAL)
> or an allocation failure (-ENOMEM), it returns that error code. This branch
> then catches the error and unconditionally panics. Will this reliably crash
> the new kernel during early boot and break the kexec handover fallback
> mechanism?
Yes all FLB retrieve errors are considered fatal. A version mismatch
is considered a retrieve error because it means the current kernel
can't understand the data passed by the previous kernel.
We do want more graceful versioning support to handle
upgrade/downgrade scenarios, but that requires deeper design work in
LUO before the PCI core can use it. We aren't going to build a
PCI-specific versioning solution.
>
> [ ... ]
>
> I also have a question about the unpreserve path in pci_flb_unpreserve()
> which might lead to a regression:
>
> drivers/pci/liveupdate.c:pci_flb_unpreserve() {
> ...
> WARN_ON(outgoing->ser->nr_devices);
> kho_block_set_destroy(&outgoing->block_set);
> kho_unpreserve_free(outgoing->ser);
> kfree(outgoing);
> }
>
> [Severity: High]
> Does pci_flb_unpreserve() destroy outgoing FLB memory without clearing the
> device pointers?
>
> If a driver fails to unpreserve its devices before the orchestrator aborts a
> Live Update, pci_flb_unpreserve() will issue a WARN_ON but proceed to
> destroy the block set and free the outgoing FLB object.
>
> The dev->liveupdate.outgoing pointers on the pci_dev structs are left
> dangling. If a new Live Update is subsequently initiated and the driver
> attempts to preserve the device again, pci_liveupdate_preserve_device()
> will access dev->liveupdate.outgoing->refcount via the dangling pointer:
>
> drivers/pci/liveupdate.c:pci_liveupdate_preserve_device() {
> ...
> if (dev->liveupdate.outgoing) {
> if (!dev->liveupdate.outgoing->refcount) {
> ...
> }
>
> Can this lead to a use-after-free of the KHO block set memory?
Yes. We can handle that the same way as dangling incoming pointers and
panic. This will only happen if the driver or LUO are very broken.
>
> --
> Sashiko AI review · https://sashiko.dev/#/patchset/20260728221007.2098560-1-dmatlack@google.com?part=3
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v8 04/12] PCI: liveupdate: Document driver binding responsibilities
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (2 preceding siblings ...)
2026-07-28 22:09 ` [PATCH v8 03/12] PCI: liveupdate: Track incoming " David Matlack
@ 2026-07-28 22:09 ` David Matlack
2026-07-28 22:12 ` sashiko-bot
2026-07-28 22:09 ` [PATCH v8 05/12] PCI: liveupdate: Preserve bus numbers during Live Update David Matlack
` (7 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:09 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Document how driver binding works during a Live Update and what the PCI
core expects of drivers and users. Note that this is only a description
of the current division of responsibilities. These can change in the
future if we decide.
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Reviewed-by: Samiullah Khawaja <skhawaja@google.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
drivers/pci/liveupdate.c | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index 5ce5f8b36902..0f7a018ddc66 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -71,6 +71,22 @@
*
* * The device cannot be a Virtual Function (VF).
* * The device cannot be behind a PCI-to-PCI bridge.
+ *
+ * Driver Binding
+ * ==============
+ *
+ * In the outgoing kernel, it is the driver's responsibility to ensure that it
+ * does not release a device between pci_liveupdate_preserve() and
+ * pci_liveupdate_unpreserve().
+ *
+ * In the incoming kernel, it is the driver's responsibility to ensure that it
+ * does not release a preserved device between probe() and
+ * pci_liveupdate_finish().
+ *
+ * It is the user's responsibility to ensure that incoming preserved devices are
+ * bound to the correct driver. i.e. The PCI core does not protect against a
+ * device getting preserved by driver A in the outgoing kernel and then getting
+ * bound to driver B in the incoming kernel. This may change in the future.
*/
#define pr_fmt(fmt) "PCI: liveupdate: " fmt
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* [PATCH v8 05/12] PCI: liveupdate: Preserve bus numbers during Live Update
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (3 preceding siblings ...)
2026-07-28 22:09 ` [PATCH v8 04/12] PCI: liveupdate: Document driver binding responsibilities David Matlack
@ 2026-07-28 22:09 ` David Matlack
2026-07-28 22:19 ` sashiko-bot
2026-07-28 22:10 ` [PATCH v8 06/12] PCI: liveupdate: Auto-preserve upstream bridges across " David Matlack
` (6 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:09 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
During a Live Update, preserved devices must be allowed to continue
performing memory transactions so the kernel cannot change the fabric
topology, including bus numbers, since that would require disabling and
flushing any memory transactions first.
To keep bus numbers constant, always preserve the secondary and
subordinate bus numbers assigned to bridges during scanning, instead of
assigning new ones, if any PCI devices were preserved. Note that the
kernel preserves bus numbers even on bridges without any downstream
endpoints that were preserved. This avoids accidentally assigning a
bridge a new window that overlaps with a preserved device that is
downstream of a different bridge.
If a bridge is scanned with a broken topology or has no bus numbers set
during a Live Update, refuse to assign it new bus numbers and refuse to
enumerate devices below it until the Live Update is finished. This is a
safety measure to prevent topology conflicts.
Require that CONFIG_CARDBUS is not enabled to enable
CONFIG_PCI_LIVEUPDATE since preserving bus numbers on PCI-to-CardBus
bridges requires additional work but is not a priority at the moment.
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Reviewed-by: Samiullah Khawaja <skhawaja@google.com>
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
.../admin-guide/kernel-parameters.txt | 6 +-
drivers/pci/Kconfig | 2 +-
drivers/pci/liveupdate.c | 95 +++++++++++++++++++
drivers/pci/liveupdate.h | 13 +++
drivers/pci/probe.c | 18 +++-
include/linux/pci_liveupdate.h | 4 +
6 files changed, 132 insertions(+), 6 deletions(-)
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 4f65b2a37521..c394a0df8e31 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -5105,7 +5105,11 @@ Kernel parameters
explicitly which ones they are.
assign-busses [X86] Always assign all PCI bus
numbers ourselves, overriding
- whatever the firmware may have done.
+ whatever the firmware may have done. Ignored
+ during a Live Update, where the kernel must
+ preserve the PCI topology (including bus
+ numbers) to avoid interrupting ongoing memory
+ transactions of preserved devices.
usepirqmask [X86] Honor the possible IRQ mask stored
in the BIOS $PIR table. This is needed on
some systems with broken BIOSes, notably
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 8af20f558086..16fbd4212e0f 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -273,7 +273,7 @@ config VGA_ARB_MAX_GPUS
config PCI_LIVEUPDATE
bool "PCI Live Update Support"
- depends on PCI && LIVEUPDATE && 64BIT
+ depends on PCI && LIVEUPDATE && 64BIT && !CARDBUS
help
Enable PCI core support for preserving PCI devices across Live
Update. This, in combination with support in a device's driver,
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index 0f7a018ddc66..d312381c9e10 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -87,6 +87,21 @@
* bound to the correct driver. i.e. The PCI core does not protect against a
* device getting preserved by driver A in the outgoing kernel and then getting
* bound to driver B in the incoming kernel. This may change in the future.
+ *
+ * BDF Stability
+ * =============
+ *
+ * The PCI core guarantees that preserved devices can be identified by the same
+ * bus, device, and function numbers for as long as they are preserved
+ * (including across kexec). To accomplish this, the PCI core always preserves
+ * the secondary and subordinate bus numbers assigned to bridges during scanning
+ * if any device is preserved. This is true even on architectures that always
+ * assign new bus numbers during scanning. The kernel assumes the previous
+ * kernel established a sane bus topology across kexec.
+ *
+ * If a misconfigured or unconfigured bridge is encountered during enumeration
+ * while there are preserved devices, its secondary and subordinate bus numbers
+ * will be cleared and devices below it will not be enumerated.
*/
#define pr_fmt(fmt) "PCI: liveupdate: " fmt
@@ -489,6 +504,86 @@ static void pci_liveupdate_flb_put_incoming(void)
liveupdate_flb_put_incoming(&pci_liveupdate_flb);
}
+static bool pci_has_incoming_preserved_devices(void)
+{
+ struct pci_flb_incoming *incoming;
+ u32 nr_devices;
+
+ guard(rwsem_read)(&pci_liveupdate.rwsem);
+
+ incoming = pci_liveupdate_flb_get_incoming();
+ if (!incoming)
+ return false;
+
+ nr_devices = incoming->ser->nr_devices;
+ pci_liveupdate_flb_put_incoming();
+
+ return nr_devices > 0;
+}
+
+/**
+ * pci_liveupdate_preserve_bus_numbers() - Determine if the PCI core should
+ * preserve bus numbers when scanning
+ * the provided bridge.
+ * @bus: The parent bus of the bridge.
+ * @dev: The PCI bridge device.
+ *
+ * This function is called by the PCI core when it is scanning a bridge. It
+ * determines whether the PCI core should preserve the secondary and subordinate
+ * bus numbers assigned to @dev by the previous kernel. This is necessary to
+ * keep RequesterIDs constant for preserved devices issuing memory transactions.
+ *
+ * Return: True if bus numbers should be preserved, false otherwise.
+ */
+bool pci_liveupdate_preserve_bus_numbers(struct pci_bus *bus, struct pci_dev *dev)
+{
+ struct pci_dev *parent = bus->self;
+
+ if (dev->liveupdate.preserve_bus_numbers)
+ return true;
+
+ if (parent && parent->liveupdate.preserve_bus_numbers) {
+ /*
+ * Preserve bus numbers if the parent bridge is required to
+ * preserve bus numbers. Otherwise the PCI core could expand
+ * this bridge's reservation beyond its parent (which cannot
+ * expand).
+ */
+ dev->liveupdate.preserve_bus_numbers = true;
+ } else {
+ /*
+ * Otherwise preserve bus numbers if there are any incoming
+ * preserved devices. This ensures that the PCI core does not
+ * allocate a bus number to a non-preserved device that
+ * conflicts with the bus number already assigned to a preserved
+ * device.
+ *
+ * This is slightly more restrictive than it needs to be. For
+ * example, each host bridges have their own range of bus
+ * numbers that won't conflict with other host bridges. But the
+ * previous kernel should have assigned a sane bus topology and
+ * it is simpler to just adopt that entire topology.
+ */
+ dev->liveupdate.preserve_bus_numbers =
+ pci_has_incoming_preserved_devices();
+ }
+
+ return dev->liveupdate.preserve_bus_numbers;
+}
+
+/**
+ * pci_liveupdate_scan_bridge_end() - Finish scanning a PCI bridge
+ * @dev: The PCI bridge device.
+ *
+ * This function is called by the PCI core when it finishes scanning a bridge.
+ * It clears the bus number preservation status of the bridge so it can be
+ * re-evaluated on future scans.
+ */
+void pci_liveupdate_scan_bridge_end(struct pci_dev *dev)
+{
+ dev->liveupdate.preserve_bus_numbers = false;
+}
+
void pci_liveupdate_setup_device(struct pci_dev *dev)
{
struct pci_flb_incoming *incoming;
diff --git a/drivers/pci/liveupdate.h b/drivers/pci/liveupdate.h
index eaaa3559fd77..107881183fda 100644
--- a/drivers/pci/liveupdate.h
+++ b/drivers/pci/liveupdate.h
@@ -13,6 +13,9 @@
#ifdef CONFIG_PCI_LIVEUPDATE
void pci_liveupdate_setup_device(struct pci_dev *dev);
void pci_liveupdate_cleanup_device(struct pci_dev *dev);
+bool pci_liveupdate_preserve_bus_numbers(struct pci_bus *bus,
+ struct pci_dev *dev);
+void pci_liveupdate_scan_bridge_end(struct pci_dev *dev);
#else
static inline void pci_liveupdate_setup_device(struct pci_dev *dev)
{
@@ -21,6 +24,16 @@ static inline void pci_liveupdate_setup_device(struct pci_dev *dev)
static inline void pci_liveupdate_cleanup_device(struct pci_dev *dev)
{
}
+
+static inline bool pci_liveupdate_preserve_bus_numbers(struct pci_bus *bus,
+ struct pci_dev *dev)
+{
+ return false;
+}
+
+static inline void pci_liveupdate_scan_bridge_end(struct pci_dev *dev)
+{
+}
#endif
#endif /* DRIVERS_PCI_LIVEUPDATE_H */
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 5dc9d86e3597..5ecb55412854 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -1397,6 +1397,7 @@ static int pci_scan_bridge_extend(struct pci_bus *bus, struct pci_dev *dev,
int max, unsigned int available_buses,
int pass)
{
+ bool preserve_bus_numbers = !pcibios_assign_all_busses();
struct pci_bus *child;
u32 buses;
u16 bctl;
@@ -1406,6 +1407,9 @@ static int pci_scan_bridge_extend(struct pci_bus *bus, struct pci_dev *dev,
u8 fixed_sec, fixed_sub;
int next_busnr;
+ if (pci_liveupdate_preserve_bus_numbers(bus, dev))
+ preserve_bus_numbers = true;
+
/*
* Make sure the bridge is powered on to be able to access config
* space of devices below it.
@@ -1449,8 +1453,7 @@ static int pci_scan_bridge_extend(struct pci_bus *bus, struct pci_dev *dev,
goto out;
}
- if ((secondary || subordinate) &&
- !pcibios_assign_all_busses() && !broken) {
+ if ((secondary || subordinate) && preserve_bus_numbers && !broken) {
unsigned int cmax, buses;
/*
@@ -1492,8 +1495,7 @@ static int pci_scan_bridge_extend(struct pci_bus *bus, struct pci_dev *dev,
* do in the second pass.
*/
if (!pass) {
- if (pcibios_assign_all_busses() || broken)
-
+ if (!preserve_bus_numbers || broken)
/*
* Temporarily disable forwarding of the
* configuration cycles on all bridges in
@@ -1507,6 +1509,11 @@ static int pci_scan_bridge_extend(struct pci_bus *bus, struct pci_dev *dev,
goto out;
}
+ if (pci_liveupdate_preserve_bus_numbers(bus, dev)) {
+ pci_err(dev, "Cannot reconfigure bridge during Live Update, skipping\n");
+ goto out;
+ }
+
/* Clear errors */
pci_write_config_word(dev, PCI_STATUS, 0xffff);
@@ -1568,6 +1575,9 @@ static int pci_scan_bridge_extend(struct pci_bus *bus, struct pci_dev *dev,
pm_runtime_put(&dev->dev);
+ if (pass)
+ pci_liveupdate_scan_bridge_end(dev);
+
return max;
}
diff --git a/include/linux/pci_liveupdate.h b/include/linux/pci_liveupdate.h
index 710026ada2d5..fc1f5640968a 100644
--- a/include/linux/pci_liveupdate.h
+++ b/include/linux/pci_liveupdate.h
@@ -17,10 +17,14 @@
* struct pci_liveupdate - PCI Live Update state for a struct pci_dev
* @outgoing: State preserved for the next kernel.
* @incoming: State preserved by the previous kernel.
+ * @preserve_bus_numbers: True if the PCI core should preserve the secondary and
+ * subordinate bus numbers assigned to this device due to
+ * an ongoing Live Update.
*/
struct pci_liveupdate {
struct pci_dev_ser *outgoing;
struct pci_dev_ser *incoming;
+ bool preserve_bus_numbers;
};
struct pci_dev;
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v8 05/12] PCI: liveupdate: Preserve bus numbers during Live Update
2026-07-28 22:09 ` [PATCH v8 05/12] PCI: liveupdate: Preserve bus numbers during Live Update David Matlack
@ 2026-07-28 22:19 ` sashiko-bot
0 siblings, 0 replies; 26+ messages in thread
From: sashiko-bot @ 2026-07-28 22:19 UTC (permalink / raw)
To: David Matlack; +Cc: linux-pci
> During a Live Update, preserved devices must be allowed to continue
> performing memory transactions so the kernel cannot change the fabric
> topology, including bus numbers, since that would require disabling and
> flushing any memory transactions first.
>
> To keep bus numbers constant, always preserve the secondary and
> subordinate bus numbers assigned to bridges during scanning, instead of
> assigning new ones, if any PCI devices were preserved. Note that the
> kernel preserves bus numbers even on bridges without any downstream
> endpoints that were preserved. This avoids accidentally assigning a
> bridge a new window that overlaps with a preserved device that is
> downstream of a different bridge.
>
> If a bridge is scanned with a broken topology or has no bus numbers set
> during a Live Update, refuse to assign it new bus numbers and refuse to
> enumerate devices below it until the Live Update is finished. This is a
> safety measure to prevent topology conflicts.
>
> Require that CONFIG_CARDBUS is not enabled to enable
> CONFIG_PCI_LIVEUPDATE since preserving bus numbers on PCI-to-CardBus
> bridges requires additional work but is not a priority at the moment.
>
> Reviewed-by: Pranjal Shrivastava <praan@google.com>
> Reviewed-by: Samiullah Khawaja <skhawaja@google.com>
> Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
> Signed-off-by: David Matlack <dmatlack@google.com>
Sashiko has reviewed this patch and found no issues. It looks great!
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260728221007.2098560-1-dmatlack@google.com?part=5
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v8 06/12] PCI: liveupdate: Auto-preserve upstream bridges across Live Update
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (4 preceding siblings ...)
2026-07-28 22:09 ` [PATCH v8 05/12] PCI: liveupdate: Preserve bus numbers during Live Update David Matlack
@ 2026-07-28 22:10 ` David Matlack
2026-07-28 22:18 ` sashiko-bot
2026-07-28 22:10 ` [PATCH v8 07/12] PCI: Refactor matching logic for pci_dev_acs_ops David Matlack
` (5 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:10 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
When a PCI device is preserved across a Live Update, all of its upstream
bridges up to the root port must also be preserved. This enables the PCI
core and any drivers bound to the bridges to manage bridges correctly
across a Live Update.
Notably, this will be used in subsequent commits to ensure that
preserved devices can continue performing memory transactions without a
disruption or change in routing.
To preserve bridges, the PCI core tracks the number of downstream
devices preserved under each bridge using a reference count in struct
pci_dev_ser. This allows a bridge to remain preserved until all its
downstream preserved devices are unpreserved or finish their
participation in the Live Update.
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
drivers/pci/liveupdate.c | 110 ++++++++++++++++++++++++++++--------
include/linux/kho/abi/pci.h | 5 +-
include/linux/pci.h | 3 +
3 files changed, 93 insertions(+), 25 deletions(-)
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index d312381c9e10..08e5ff8c1fe7 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -70,7 +70,6 @@
* preserved. These may be relaxed in the future:
*
* * The device cannot be a Virtual Function (VF).
- * * The device cannot be behind a PCI-to-PCI bridge.
*
* Driver Binding
* ==============
@@ -102,6 +101,18 @@
* If a misconfigured or unconfigured bridge is encountered during enumeration
* while there are preserved devices, its secondary and subordinate bus numbers
* will be cleared and devices below it will not be enumerated.
+ *
+ * PCI-to-PCI Bridges
+ * ==================
+ *
+ * Any PCI-to-PCI bridges upstream of a preserved device are automatically
+ * preserved when the device is preserved. The PCI core keeps track of the
+ * number of downstream devices that are preserved under a bridge so that the
+ * bridge is only unpreserved once all downstream devices are unpreserved.
+ *
+ * This enables the PCI core and any drivers bound to the bridge to participate
+ * in the Live Update so that preserved endpoints can continue issuing memory
+ * transactions during the Live Update.
*/
#define pr_fmt(fmt) "PCI: liveupdate: " fmt
@@ -358,20 +369,42 @@ static struct pci_dev_ser *pci_flb_alloc_dev_ser(struct pci_flb_outgoing *outgoi
return dev_ser;
}
-static void pci_liveupdate_unpreserve_device(struct pci_flb_outgoing *outgoing,
- struct pci_dev *dev)
+static int pci_liveupdate_unpreserve_device(struct pci_flb_outgoing *outgoing,
+ struct pci_dev *dev)
{
struct pci_dev_ser *dev_ser = dev->liveupdate.outgoing;
if (!dev_ser) {
pci_warn(dev, "Cannot unpreserve device that is not preserved\n");
- return;
+ return -EINVAL;
+ }
+
+ if (!dev_ser->refcount) {
+ pci_WARN(dev, 1, "Preserved device has a 0 refcount!\n");
+ return -EINVAL;
}
+ if (--dev_ser->refcount)
+ return 0;
+
pci_info(dev, "Device will no longer be preserved across next Live Update\n");
outgoing->ser->nr_devices--;
memset(dev_ser, 0, sizeof(*dev_ser));
dev->liveupdate.outgoing = NULL;
+ return 0;
+}
+
+static void pci_liveupdate_unpreserve_path(struct pci_flb_outgoing *outgoing,
+ struct pci_dev *dev,
+ struct pci_dev *end)
+{
+ for_each_pci_dev_in_path(dev) {
+ if (dev == end)
+ break;
+
+ if (pci_liveupdate_unpreserve_device(outgoing, dev))
+ return;
+ }
}
static int pci_liveupdate_preserve_device(struct pci_flb_outgoing *outgoing,
@@ -385,13 +418,23 @@ static int pci_liveupdate_preserve_device(struct pci_flb_outgoing *outgoing,
}
if (dev->liveupdate.outgoing) {
- pci_warn(dev, "Device is already preserved\n");
- return -EBUSY;
- }
+ if (!dev->liveupdate.outgoing->refcount) {
+ pci_WARN(dev, 1, "Preserved device with 0 refcount!\n");
+ return -EINVAL;
+ }
- if (!pci_is_root_bus(dev->bus)) {
- pci_warn(dev, "Cannot preserve devices behind bridges\n");
- return -EINVAL;
+ /*
+ * Endpoint devices should not be preserved more than once.
+ * Bridges are preserved once for every downstream device that
+ * is preserved.
+ */
+ if (!dev->subordinate) {
+ pci_warn(dev, "Device is already preserved\n");
+ return -EBUSY;
+ }
+
+ dev->liveupdate.outgoing->refcount++;
+ return 0;
}
dev_ser = pci_flb_alloc_dev_ser(outgoing);
@@ -419,12 +462,16 @@ static int pci_liveupdate_preserve_device(struct pci_flb_outgoing *outgoing,
* pci_liveupdate_preserve() from their struct liveupdate_file_handler
* preserve() callback to ensure the outgoing struct pci_ser is already set up.
*
+ * pci_liveupdate_preserve() automatically preserves all bridges upstream of
+ * @dev.
+ *
* Returns: 0 on success, <0 on failure.
*/
int pci_liveupdate_preserve(struct pci_dev *dev)
{
struct pci_flb_outgoing *outgoing = NULL;
- int ret;
+ struct pci_dev *start = dev;
+ int ret = -ENODEV;
guard(rwsem_write)(&pci_liveupdate.rwsem);
@@ -432,7 +479,13 @@ int pci_liveupdate_preserve(struct pci_dev *dev)
if (IS_ERR(outgoing))
return PTR_ERR(outgoing);
- ret = pci_liveupdate_preserve_device(outgoing, dev);
+ for_each_pci_dev_in_path(dev) {
+ ret = pci_liveupdate_preserve_device(outgoing, dev);
+ if (ret) {
+ pci_liveupdate_unpreserve_path(outgoing, start, dev);
+ break;
+ }
+ }
pci_liveupdate_flb_put_outgoing();
return ret;
@@ -448,6 +501,9 @@ EXPORT_SYMBOL_GPL(pci_liveupdate_preserve);
* pci_liveupdate_unpreserve() from their struct liveupdate_file_handler
* unpreserve() callback to ensure the outgoing struct pci_ser is already set
* up.
+ *
+ * pci_liveupdate_unpreserve() automatically unpreserves all bridges upstream of
+ * @dev.
*/
void pci_liveupdate_unpreserve(struct pci_dev *dev)
{
@@ -461,7 +517,7 @@ void pci_liveupdate_unpreserve(struct pci_dev *dev)
return;
}
- pci_liveupdate_unpreserve_device(outgoing, dev);
+ pci_liveupdate_unpreserve_path(outgoing, dev, /*end=*/NULL);
pci_liveupdate_flb_put_outgoing();
}
EXPORT_SYMBOL_GPL(pci_liveupdate_unpreserve);
@@ -631,28 +687,30 @@ void pci_liveupdate_cleanup_device(struct pci_dev *dev)
pci_WARN(dev, 1, "Destroying incoming-preserved device!\n");
}
-static void pci_liveupdate_finish_device(struct pci_ser *ser, struct pci_dev *dev)
+static int pci_liveupdate_finish_device(struct pci_ser *ser, struct pci_dev *dev)
{
if (!dev->liveupdate.incoming) {
pci_warn(dev, "Cannot finish preserving an unpreserved device\n");
- return;
+ return -EINVAL;
}
- if (dev->liveupdate.incoming->refcount != 1) {
- pci_WARN(dev, 1, "Preserved device has a corrupted refcount!\n");
- return;
+ if (!dev->liveupdate.incoming->refcount) {
+ pci_WARN(dev, 1, "Preserved device has a 0 refcount!\n");
+ return -EINVAL;
}
/*
- * Drop the refcount so this device does not get treated as an incoming
- * device again, e.g. in case pci_liveupdate_setup_device() gets called
- * again because the device is hot-plugged.
+ * Decrement the refcount so this device does not get treated as an
+ * incoming device again, e.g. in case pci_liveupdate_setup_device()
+ * gets called again because the device is hot-plugged.
*/
- dev->liveupdate.incoming->refcount = 0;
+ if (--dev->liveupdate.incoming->refcount)
+ return 0;
pci_info(dev, "Device is finished participating in Live Update\n");
dev->liveupdate.incoming = NULL;
ser->nr_devices--;
+ return 0;
}
/**
@@ -664,6 +722,8 @@ static void pci_liveupdate_finish_device(struct pci_ser *ser, struct pci_dev *de
* Update. Drivers must call pci_liveupdate_finish() from their struct
* liveupdate_file_handler finish() callback to ensure the incoming struct
* pci_ser is allocated.
+ *
+ * pci_liveupdate_finish() automatically finishes all bridges upstream of @dev.
*/
void pci_liveupdate_finish(struct pci_dev *dev)
{
@@ -677,7 +737,11 @@ void pci_liveupdate_finish(struct pci_dev *dev)
return;
}
- pci_liveupdate_finish_device(incoming->ser, dev);
+ for_each_pci_dev_in_path(dev) {
+ if (pci_liveupdate_finish_device(incoming->ser, dev))
+ break;
+ }
+
pci_liveupdate_flb_put_incoming();
}
EXPORT_SYMBOL_GPL(pci_liveupdate_finish);
diff --git a/include/linux/kho/abi/pci.h b/include/linux/kho/abi/pci.h
index d4881c2d2fc9..aecace02d8ac 100644
--- a/include/linux/kho/abi/pci.h
+++ b/include/linux/kho/abi/pci.h
@@ -24,7 +24,7 @@
*/
#define PCI_LUO_FLB_COMPATIBLE "pci"
-#define PCI_LUO_FLB_VERSION 1
+#define PCI_LUO_FLB_VERSION 2
/**
* struct pci_dev_ser - Serialized state about a single PCI device.
@@ -33,7 +33,8 @@
* @bdf: The device's PCI bus, device, and function number.
* @refcount: Reference count used by the PCI core to keep track of whether it
* is done using a device's struct pci_dev_ser. The value of the
- * refcount is equal to 1 when the struct pci_dev_ser is in use, and
+ * refcount is equal to the number of preserved devices at or below
+ * it in the PCI hierarchy when the struct pci_dev_ser is in use, and
* 0 otherwise.
*/
struct pci_dev_ser {
diff --git a/include/linux/pci.h b/include/linux/pci.h
index b41dd572a2d6..6267c83813d5 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -829,6 +829,9 @@ static inline struct pci_dev *pci_upstream_bridge(struct pci_dev *dev)
return dev->bus->self;
}
+#define for_each_pci_dev_in_path(dev) \
+ for (; dev; dev = pci_upstream_bridge(dev))
+
#ifdef CONFIG_PCI_MSI
static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev)
{
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v8 06/12] PCI: liveupdate: Auto-preserve upstream bridges across Live Update
2026-07-28 22:10 ` [PATCH v8 06/12] PCI: liveupdate: Auto-preserve upstream bridges across " David Matlack
@ 2026-07-28 22:18 ` sashiko-bot
0 siblings, 0 replies; 26+ messages in thread
From: sashiko-bot @ 2026-07-28 22:18 UTC (permalink / raw)
To: David Matlack; +Cc: linux-pci
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The `for_each_pci_dev_in_path` macro violates standard kernel iterator conventions by not initializing its iterator variable, creating a confusing API that may lead to misuse.
--
--- Patch [6]: [PATCH v8 06/12] PCI: liveupdate: Auto-preserve upstream bridges across Live Update ---
commit 5f902c08492796d638f5197db23659b872ce5e10
Author: David Matlack <dmatlack@google.com>
PCI: liveupdate: Auto-preserve upstream bridges across Live Update
This commit updates the PCI Live Update mechanism to automatically preserve
upstream PCI-to-PCI bridges when a downstream device is preserved. It tracks
the number of downstream devices preserved under each bridge using a
reference count in struct pci_dev_ser.
> diff --git a/include/linux/pci.h b/include/linux/pci.h
> index b41dd572a2d6b..6267c83813d55 100644
> --- a/include/linux/pci.h
> +++ b/include/linux/pci.h
> @@ -829,6 +829,9 @@ static inline struct pci_dev *pci_upstream_bridge(struct pci_dev *dev)
> return dev->bus->self;
> }
>
> +#define for_each_pci_dev_in_path(dev) \
> + for (; dev; dev = pci_upstream_bridge(dev))
[Severity: Low]
Does this macro violate standard kernel iterator conventions by not
initializing its iterator variable?
Standard Linux kernel for_each iterators typically initialize their loop
variables. By omitting the initialization here, the macro expects the caller
to pre-initialize the variable and then mutates it in place.
While the current usages in this patch are functionally correct, could this
unexpected behavior lead to confusion and API misuse for future callers?
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260728221007.2098560-1-dmatlack@google.com?part=6
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v8 07/12] PCI: Refactor matching logic for pci_dev_acs_ops
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (5 preceding siblings ...)
2026-07-28 22:10 ` [PATCH v8 06/12] PCI: liveupdate: Auto-preserve upstream bridges across " David Matlack
@ 2026-07-28 22:10 ` David Matlack
2026-07-28 22:18 ` sashiko-bot
2026-07-28 22:10 ` [PATCH v8 08/12] PCI: liveupdate: Adopt ACS controls in incoming preserved devices David Matlack
` (4 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:10 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Refactor the logic to match devices to pci_dev_acs_ops by factoring out
the device matching loop into its own routine, pci_dev_acs_ops_get().
This eliminates duplicate code between pci_dev_specific_enable_acs() and
pci_dev_specific_disable_acs_redir(), and will also be used in a
subsequent commit to check if a device requires device-specific
enable_acs() during a Live Update.
No functional change intended.
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Reviewed-by: Bjorn Helgaas <bhelgaas@google.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
drivers/pci/quirks.c | 51 ++++++++++++++++++--------------------------
1 file changed, 21 insertions(+), 30 deletions(-)
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index b09f27f7846f..7ac39ec2843e 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -5374,9 +5374,6 @@ static void pci_quirk_enable_intel_rp_mpc_acs(struct pci_dev *dev)
*/
static int pci_quirk_enable_intel_pch_acs(struct pci_dev *dev)
{
- if (!pci_quirk_intel_pch_acs_match(dev))
- return -ENOTTY;
-
if (pci_quirk_enable_intel_lpc_acs(dev)) {
pci_warn(dev, "Failed to enable Intel PCH ACS quirk\n");
return 0;
@@ -5396,9 +5393,6 @@ static int pci_quirk_enable_intel_spt_pch_acs(struct pci_dev *dev)
int pos;
u32 cap, ctrl;
- if (!pci_quirk_intel_spt_pch_acs_match(dev))
- return -ENOTTY;
-
pos = dev->acs_cap;
if (!pos)
return -ENOTTY;
@@ -5426,9 +5420,6 @@ static int pci_quirk_disable_intel_spt_pch_acs_redir(struct pci_dev *dev)
int pos;
u32 cap, ctrl;
- if (!pci_quirk_intel_spt_pch_acs_match(dev))
- return -ENOTTY;
-
pos = dev->acs_cap;
if (!pos)
return -ENOTTY;
@@ -5448,56 +5439,56 @@ static int pci_quirk_disable_intel_spt_pch_acs_redir(struct pci_dev *dev)
static const struct pci_dev_acs_ops {
u16 vendor;
u16 device;
+ bool (*match)(struct pci_dev *dev);
int (*enable_acs)(struct pci_dev *dev);
int (*disable_acs_redir)(struct pci_dev *dev);
} pci_dev_acs_ops[] = {
{ PCI_VENDOR_ID_INTEL, PCI_ANY_ID,
+ .match = pci_quirk_intel_pch_acs_match,
.enable_acs = pci_quirk_enable_intel_pch_acs,
},
{ PCI_VENDOR_ID_INTEL, PCI_ANY_ID,
+ .match = pci_quirk_intel_spt_pch_acs_match,
.enable_acs = pci_quirk_enable_intel_spt_pch_acs,
.disable_acs_redir = pci_quirk_disable_intel_spt_pch_acs_redir,
},
};
-int pci_dev_specific_enable_acs(struct pci_dev *dev)
+static const struct pci_dev_acs_ops *pci_dev_acs_ops_get(struct pci_dev *dev)
{
const struct pci_dev_acs_ops *p;
- int i, ret;
+ int i;
for (i = 0; i < ARRAY_SIZE(pci_dev_acs_ops); i++) {
p = &pci_dev_acs_ops[i];
if ((p->vendor == dev->vendor ||
p->vendor == (u16)PCI_ANY_ID) &&
(p->device == dev->device ||
- p->device == (u16)PCI_ANY_ID) &&
- p->enable_acs) {
- ret = p->enable_acs(dev);
- if (ret >= 0)
- return ret;
+ p->device == (u16)PCI_ANY_ID)) {
+ if (!p->match || p->match(dev))
+ return p;
}
}
+ return NULL;
+}
+
+int pci_dev_specific_enable_acs(struct pci_dev *dev)
+{
+ const struct pci_dev_acs_ops *p = pci_dev_acs_ops_get(dev);
+
+ if (p && p->enable_acs)
+ return p->enable_acs(dev);
+
return -ENOTTY;
}
int pci_dev_specific_disable_acs_redir(struct pci_dev *dev)
{
- const struct pci_dev_acs_ops *p;
- int i, ret;
+ const struct pci_dev_acs_ops *p = pci_dev_acs_ops_get(dev);
- for (i = 0; i < ARRAY_SIZE(pci_dev_acs_ops); i++) {
- p = &pci_dev_acs_ops[i];
- if ((p->vendor == dev->vendor ||
- p->vendor == (u16)PCI_ANY_ID) &&
- (p->device == dev->device ||
- p->device == (u16)PCI_ANY_ID) &&
- p->disable_acs_redir) {
- ret = p->disable_acs_redir(dev);
- if (ret >= 0)
- return ret;
- }
- }
+ if (p && p->disable_acs_redir)
+ return p->disable_acs_redir(dev);
return -ENOTTY;
}
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* [PATCH v8 08/12] PCI: liveupdate: Adopt ACS controls in incoming preserved devices
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (6 preceding siblings ...)
2026-07-28 22:10 ` [PATCH v8 07/12] PCI: Refactor matching logic for pci_dev_acs_ops David Matlack
@ 2026-07-28 22:10 ` David Matlack
2026-07-28 22:22 ` sashiko-bot
2026-07-28 22:10 ` [PATCH v8 09/12] PCI: liveupdate: Adopt ARI Forwarding Enable on preserved bridges David Matlack
` (3 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:10 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Adopt Access Control Services (ACS) controls on all incoming preserved
devices (endpoints and upstream bridges) during a Live Update.
Inheriting ACS flags avoids changing routing rules while memory
transactions are in flight from preserved devices. This is also strictly
necessary to ensure that IOMMU group assignments do not change during or
after Live Update.
Cache the inherited ACS controls established by the previous kernel in
struct pci_dev so that ACS controls do not change after a reset
(pci_restore_state() calls pci_enable_acs()).
To simplify ACS inheritance, reject preserving any devices that require
quirks to enable ACS as those quirks would also have to take Live Update
into account.
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
drivers/pci/liveupdate.c | 87 ++++++++++++++++++++++++++++++++++
drivers/pci/liveupdate.h | 11 +++++
drivers/pci/pci.c | 6 +++
drivers/pci/pci.h | 5 ++
drivers/pci/quirks.c | 7 +++
include/linux/pci_liveupdate.h | 6 +++
6 files changed, 122 insertions(+)
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index 08e5ff8c1fe7..fb602dd3933e 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -71,6 +71,9 @@
*
* * The device cannot be a Virtual Function (VF).
*
+ * * The device cannot require device-specific quirks to enable Access
+ * Control Services (ACS).
+ *
* Driver Binding
* ==============
*
@@ -113,6 +116,18 @@
* This enables the PCI core and any drivers bound to the bridge to participate
* in the Live Update so that preserved endpoints can continue issuing memory
* transactions during the Live Update.
+ *
+ * Handling Preserved Devices
+ * ==========================
+ *
+ * The PCI core treats preserved devices differently than non-preserved devices.
+ * This section enumerates those differences.
+ *
+ * * The PCI core adopts all ACS controls enabled on incoming preserved devices
+ * rather than assigning new ones. This ensures that TLPs are routed the same
+ * way after Live Update and ensures that IOMMU groups do not change. Note
+ * that a device will use its adopted ACS controls for the lifetime of its
+ * struct pci_dev (i.e. even after pci_liveupdate_finish()).
*/
#define pr_fmt(fmt) "PCI: liveupdate: " fmt
@@ -128,6 +143,7 @@
#include <linux/slab.h>
#include "liveupdate.h"
+#include "pci.h"
/**
* struct pci_liveupdate_global - Global state for PCI Live Update support
@@ -417,6 +433,16 @@ static int pci_liveupdate_preserve_device(struct pci_flb_outgoing *outgoing,
return -EINVAL;
}
+ /*
+ * Do not preserve devices that rely on device-specific ACS equivalents
+ * (for now) since that would complicate keeping ACS constant across
+ * Live Update.
+ */
+ if (pci_need_dev_specific_enable_acs(dev)) {
+ pci_warn(dev, "Refusing to preserve device that relies on ACS quirks\n");
+ return -EINVAL;
+ }
+
if (dev->liveupdate.outgoing) {
if (!dev->liveupdate.outgoing->refcount) {
pci_WARN(dev, 1, "Preserved device with 0 refcount!\n");
@@ -668,6 +694,7 @@ void pci_liveupdate_setup_device(struct pci_dev *dev)
pci_info(dev, "Device was preserved by previous kernel across Live Update\n");
dev->liveupdate.incoming = dev_ser;
+ dev->liveupdate.was_preserved = true;
pci_liveupdate_flb_put_incoming();
}
@@ -746,6 +773,66 @@ void pci_liveupdate_finish(struct pci_dev *dev)
}
EXPORT_SYMBOL_GPL(pci_liveupdate_finish);
+/**
+ * pci_liveupdate_cache_adopted_acs_controls() - Cache adopted ACS controls
+ * @dev: The PCI device to cache ACS controls from
+ *
+ * If @dev is an incoming Live Update device, read its current ACS configuration
+ * from hardware (which was set by the previous kernel) and cache it.
+ */
+void pci_liveupdate_cache_adopted_acs_controls(struct pci_dev *dev)
+{
+ guard(rwsem_read)(&pci_liveupdate.rwsem);
+
+ if (!dev->liveupdate.incoming)
+ return;
+
+ pci_read_config_word(dev, dev->acs_cap + PCI_ACS_CTRL, &dev->liveupdate.acs_ctrl);
+}
+
+/**
+ * pci_liveupdate_enable_adopted_acs_controls() - Enable adopted ACS controls
+ * @dev: The PCI device to enable adopted ACS controls for
+ *
+ * For devices preserved across a Live Update, write the cached ACS controls
+ * back into the hardware's ACS Capability. This ensures that the device
+ * continues to use the ACS rules established by the previous kernel.
+ *
+ * Return: 0 on success, or -EINVAL if the device was not preserved or requires
+ * device-specific quirks.
+ */
+int pci_liveupdate_enable_adopted_acs_controls(struct pci_dev *dev)
+{
+ u16 acs_ctrl = dev->liveupdate.acs_ctrl;
+ u16 acs_cap = dev->acs_cap;
+
+ /*
+ * Check if the device was preserved over a previous Live Update (even
+ * if it has already gone through pci_liveupdate_finish()). This ensures
+ * that the device continues to use the ACS controls established by the
+ * previous kernel.
+ */
+ if (!dev->liveupdate.was_preserved)
+ return -EINVAL;
+
+ /*
+ * The previous kernel should not have preserved any devices that
+ * require device-specific quirks to enable ACS, but if such a device is
+ * detected (e.g. new device-specific ACS quirk in the current kernel),
+ * log a big warning and fall back to the normal enable ACS path.
+ */
+ if (pci_need_dev_specific_enable_acs(dev)) {
+ pci_warn(dev, "Device-specific quirk required to enable ACS!\n");
+ WARN_ON_ONCE(true);
+ return -EINVAL;
+ }
+
+ if (acs_cap)
+ pci_write_config_word(dev, acs_cap + PCI_ACS_CTRL, acs_ctrl);
+
+ return 0;
+}
+
/**
* pci_liveupdate_is_incoming() - Check if a device is incoming-preserved
* @dev: The PCI device to check
diff --git a/drivers/pci/liveupdate.h b/drivers/pci/liveupdate.h
index 107881183fda..ac5b8bf2edf5 100644
--- a/drivers/pci/liveupdate.h
+++ b/drivers/pci/liveupdate.h
@@ -16,6 +16,8 @@ void pci_liveupdate_cleanup_device(struct pci_dev *dev);
bool pci_liveupdate_preserve_bus_numbers(struct pci_bus *bus,
struct pci_dev *dev);
void pci_liveupdate_scan_bridge_end(struct pci_dev *dev);
+void pci_liveupdate_cache_adopted_acs_controls(struct pci_dev *dev);
+int pci_liveupdate_enable_adopted_acs_controls(struct pci_dev *dev);
#else
static inline void pci_liveupdate_setup_device(struct pci_dev *dev)
{
@@ -34,6 +36,15 @@ static inline bool pci_liveupdate_preserve_bus_numbers(struct pci_bus *bus,
static inline void pci_liveupdate_scan_bridge_end(struct pci_dev *dev)
{
}
+
+static inline void pci_liveupdate_cache_adopted_acs_controls(struct pci_dev *dev)
+{
+}
+
+static inline int pci_liveupdate_enable_adopted_acs_controls(struct pci_dev *dev)
+{
+ return -EINVAL;
+}
#endif
#endif /* DRIVERS_PCI_LIVEUPDATE_H */
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 77b17b13ee61..22001bdf4c97 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -34,6 +34,8 @@
#include <linux/aer.h>
#include <linux/bitfield.h>
#include <linux/suspend.h>
+
+#include "liveupdate.h"
#include "pci.h"
DEFINE_MUTEX(pci_slot_mutex);
@@ -1008,6 +1010,9 @@ void pci_enable_acs(struct pci_dev *dev)
bool enable_acs = false;
int pos;
+ if (!pci_liveupdate_enable_adopted_acs_controls(dev))
+ return;
+
/* If an iommu is present we start with kernel default caps */
if (pci_acs_enable) {
if (pci_dev_specific_enable_acs(dev))
@@ -3689,6 +3694,7 @@ void pci_acs_init(struct pci_dev *dev)
pci_read_config_word(dev, pos + PCI_ACS_CAP, &dev->acs_capabilities);
pci_disable_broken_acs_cap(dev);
+ pci_liveupdate_cache_adopted_acs_controls(dev);
}
/**
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 4469e1a77f3c..988a18b3204a 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -1047,6 +1047,7 @@ void pci_acs_init(struct pci_dev *dev);
void pci_enable_acs(struct pci_dev *dev);
#ifdef CONFIG_PCI_QUIRKS
int pci_dev_specific_acs_enabled(struct pci_dev *dev, u16 acs_flags);
+bool pci_need_dev_specific_enable_acs(struct pci_dev *dev);
int pci_dev_specific_enable_acs(struct pci_dev *dev);
int pci_dev_specific_disable_acs_redir(struct pci_dev *dev);
void pci_disable_broken_acs_cap(struct pci_dev *pdev);
@@ -1057,6 +1058,10 @@ static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
{
return -ENOTTY;
}
+static inline bool pci_need_dev_specific_enable_acs(struct pci_dev *dev)
+{
+ return false;
+}
static inline int pci_dev_specific_enable_acs(struct pci_dev *dev)
{
return -ENOTTY;
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 7ac39ec2843e..99b819f38e49 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -5473,6 +5473,13 @@ static const struct pci_dev_acs_ops *pci_dev_acs_ops_get(struct pci_dev *dev)
return NULL;
}
+bool pci_need_dev_specific_enable_acs(struct pci_dev *dev)
+{
+ const struct pci_dev_acs_ops *p = pci_dev_acs_ops_get(dev);
+
+ return p && p->enable_acs;
+}
+
int pci_dev_specific_enable_acs(struct pci_dev *dev)
{
const struct pci_dev_acs_ops *p = pci_dev_acs_ops_get(dev);
diff --git a/include/linux/pci_liveupdate.h b/include/linux/pci_liveupdate.h
index fc1f5640968a..04a2b2a3102a 100644
--- a/include/linux/pci_liveupdate.h
+++ b/include/linux/pci_liveupdate.h
@@ -17,14 +17,20 @@
* struct pci_liveupdate - PCI Live Update state for a struct pci_dev
* @outgoing: State preserved for the next kernel.
* @incoming: State preserved by the previous kernel.
+ * @acs_ctrl: ACS features established by the previous kernel.
* @preserve_bus_numbers: True if the PCI core should preserve the secondary and
* subordinate bus numbers assigned to this device due to
* an ongoing Live Update.
+ * @was_preserved: True if this struct pci_dev was preserved by the previous
+ * kernel. Unlike @incoming, this field is not cleared after
+ * the device is finished participating in Live Update.
*/
struct pci_liveupdate {
struct pci_dev_ser *outgoing;
struct pci_dev_ser *incoming;
+ u16 acs_ctrl;
bool preserve_bus_numbers;
+ bool was_preserved;
};
struct pci_dev;
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v8 08/12] PCI: liveupdate: Adopt ACS controls in incoming preserved devices
2026-07-28 22:10 ` [PATCH v8 08/12] PCI: liveupdate: Adopt ACS controls in incoming preserved devices David Matlack
@ 2026-07-28 22:22 ` sashiko-bot
0 siblings, 0 replies; 26+ messages in thread
From: sashiko-bot @ 2026-07-28 22:22 UTC (permalink / raw)
To: David Matlack; +Cc: linux-pci
> Adopt Access Control Services (ACS) controls on all incoming preserved
> devices (endpoints and upstream bridges) during a Live Update.
>
> Inheriting ACS flags avoids changing routing rules while memory
> transactions are in flight from preserved devices. This is also strictly
> necessary to ensure that IOMMU group assignments do not change during or
> after Live Update.
>
> Cache the inherited ACS controls established by the previous kernel in
> struct pci_dev so that ACS controls do not change after a reset
> (pci_restore_state() calls pci_enable_acs()).
>
> To simplify ACS inheritance, reject preserving any devices that require
> quirks to enable ACS as those quirks would also have to take Live Update
> into account.
>
> Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
> Signed-off-by: David Matlack <dmatlack@google.com>
Sashiko has reviewed this patch and found no issues. It looks great!
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260728221007.2098560-1-dmatlack@google.com?part=8
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v8 09/12] PCI: liveupdate: Adopt ARI Forwarding Enable on preserved bridges
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (7 preceding siblings ...)
2026-07-28 22:10 ` [PATCH v8 08/12] PCI: liveupdate: Adopt ACS controls in incoming preserved devices David Matlack
@ 2026-07-28 22:10 ` David Matlack
2026-07-28 22:19 ` sashiko-bot
2026-07-28 22:10 ` [PATCH v8 10/12] PCI: liveupdate: Freeze preservation status during shutdown David Matlack
` (2 subsequent siblings)
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:10 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Adopt the ARI Forwarding Enable bit on preserved bridges and update
pci_dev->ari_enabled accordingly during a Live Update. This ensures that
the preserved devices on the bridge's secondary bus can be identified
with the same expanded 8-bit function number after a Live Update.
Signed-off-by: David Matlack <dmatlack@google.com>
---
drivers/pci/liveupdate.c | 30 ++++++++++++++++++++++++++++++
drivers/pci/liveupdate.h | 6 ++++++
drivers/pci/pci.c | 8 +++++++-
3 files changed, 43 insertions(+), 1 deletion(-)
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index fb602dd3933e..744513ee11ed 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -128,6 +128,10 @@
* way after Live Update and ensures that IOMMU groups do not change. Note
* that a device will use its adopted ACS controls for the lifetime of its
* struct pci_dev (i.e. even after pci_liveupdate_finish()).
+ *
+ * * The PCI core adopts ARI Forwarding Enable on all bridges with downstream
+ * preserved devices to ensure that all preserved devices on the bridge's
+ * secondary bus are addressable after the Live Update.
*/
#define pr_fmt(fmt) "PCI: liveupdate: " fmt
@@ -833,6 +837,32 @@ int pci_liveupdate_enable_adopted_acs_controls(struct pci_dev *dev)
return 0;
}
+/**
+ * pci_liveupdate_adopt_ari() - Adopt ARI configuration
+ * @dev: The PCI device to adopt ARI configuration for
+ *
+ * For devices preserved across a Live Update, read the ARI state from
+ * hardware and adopt it. This ensures the device continues to use the ARI
+ * configuration established by the previous kernel.
+ *
+ * Return: 0 on success, or -EINVAL if the device was not preserved.
+ */
+int pci_liveupdate_adopt_ari(struct pci_dev *dev)
+{
+ u16 val;
+
+ guard(rwsem_read)(&pci_liveupdate.rwsem);
+
+ if (!dev->liveupdate.incoming)
+ return -EINVAL;
+
+ pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &val);
+
+ /* Safe to modify dev->ari_enabled bitfield during enumeration. */
+ dev->ari_enabled = !!(val & PCI_EXP_DEVCTL2_ARI);
+ return 0;
+}
+
/**
* pci_liveupdate_is_incoming() - Check if a device is incoming-preserved
* @dev: The PCI device to check
diff --git a/drivers/pci/liveupdate.h b/drivers/pci/liveupdate.h
index ac5b8bf2edf5..ccc23031e99d 100644
--- a/drivers/pci/liveupdate.h
+++ b/drivers/pci/liveupdate.h
@@ -18,6 +18,7 @@ bool pci_liveupdate_preserve_bus_numbers(struct pci_bus *bus,
void pci_liveupdate_scan_bridge_end(struct pci_dev *dev);
void pci_liveupdate_cache_adopted_acs_controls(struct pci_dev *dev);
int pci_liveupdate_enable_adopted_acs_controls(struct pci_dev *dev);
+int pci_liveupdate_adopt_ari(struct pci_dev *dev);
#else
static inline void pci_liveupdate_setup_device(struct pci_dev *dev)
{
@@ -45,6 +46,11 @@ static inline int pci_liveupdate_enable_adopted_acs_controls(struct pci_dev *dev
{
return -EINVAL;
}
+
+static inline int pci_liveupdate_adopt_ari(struct pci_dev *dev)
+{
+ return -EINVAL;
+}
#endif
#endif /* DRIVERS_PCI_LIVEUPDATE_H */
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 22001bdf4c97..6922f361a89e 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -3528,7 +3528,7 @@ void pci_configure_ari(struct pci_dev *dev)
u32 cap;
struct pci_dev *bridge;
- if (pcie_ari_disabled || !pci_is_pcie(dev) || dev->devfn)
+ if (!pci_is_pcie(dev) || dev->devfn)
return;
bridge = dev->bus->self;
@@ -3539,6 +3539,12 @@ void pci_configure_ari(struct pci_dev *dev)
if (!(cap & PCI_EXP_DEVCAP2_ARI))
return;
+ if (!pci_liveupdate_adopt_ari(bridge))
+ return;
+
+ if (pcie_ari_disabled)
+ return;
+
if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI)) {
pcie_capability_set_word(bridge, PCI_EXP_DEVCTL2,
PCI_EXP_DEVCTL2_ARI);
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* [PATCH v8 10/12] PCI: liveupdate: Freeze preservation status during shutdown
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (8 preceding siblings ...)
2026-07-28 22:10 ` [PATCH v8 09/12] PCI: liveupdate: Adopt ARI Forwarding Enable on preserved bridges David Matlack
@ 2026-07-28 22:10 ` David Matlack
2026-07-28 22:21 ` sashiko-bot
2026-07-28 22:10 ` [PATCH v8 11/12] PCI: liveupdate: Do not disable bus mastering on preserved devices during kexec David Matlack
2026-07-28 22:10 ` [PATCH v8 12/12] Documentation: PCI: Add documentation for Live Update David Matlack
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:10 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Freeze a device's outgoing preservation status (preserved or not
preserved) during shutdown. This enables the PCI core and drivers to
safely make decisions based on the device's preservation status during
shutdown.
Note that pci_liveupdate_freeze() is triggered by the PCI core rather
than from drivers participating in Live Update so that all devices can
have their status frozen (i.e. prevent non-preserved devices from
getting preserved late).
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
drivers/pci/liveupdate.c | 16 ++++++++++++++++
drivers/pci/liveupdate.h | 4 ++++
drivers/pci/pci-driver.c | 2 ++
include/linux/pci_liveupdate.h | 3 +++
4 files changed, 25 insertions(+)
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index 744513ee11ed..65bcecb1b64e 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -394,6 +394,11 @@ static int pci_liveupdate_unpreserve_device(struct pci_flb_outgoing *outgoing,
{
struct pci_dev_ser *dev_ser = dev->liveupdate.outgoing;
+ if (dev->liveupdate.frozen) {
+ pci_warn(dev, "Cannot unpreserve device after it is frozen!\n");
+ return -EINVAL;
+ }
+
if (!dev_ser) {
pci_warn(dev, "Cannot unpreserve device that is not preserved\n");
return -EINVAL;
@@ -447,6 +452,11 @@ static int pci_liveupdate_preserve_device(struct pci_flb_outgoing *outgoing,
return -EINVAL;
}
+ if (dev->liveupdate.frozen) {
+ pci_warn(dev, "Cannot preserve device after it is frozen!\n");
+ return -EINVAL;
+ }
+
if (dev->liveupdate.outgoing) {
if (!dev->liveupdate.outgoing->refcount) {
pci_WARN(dev, 1, "Preserved device with 0 refcount!\n");
@@ -718,6 +728,12 @@ void pci_liveupdate_cleanup_device(struct pci_dev *dev)
pci_WARN(dev, 1, "Destroying incoming-preserved device!\n");
}
+void pci_liveupdate_freeze(struct pci_dev *dev)
+{
+ guard(rwsem_write)(&pci_liveupdate.rwsem);
+ dev->liveupdate.frozen = 1;
+}
+
static int pci_liveupdate_finish_device(struct pci_ser *ser, struct pci_dev *dev)
{
if (!dev->liveupdate.incoming) {
diff --git a/drivers/pci/liveupdate.h b/drivers/pci/liveupdate.h
index ccc23031e99d..49d07fd02132 100644
--- a/drivers/pci/liveupdate.h
+++ b/drivers/pci/liveupdate.h
@@ -13,6 +13,7 @@
#ifdef CONFIG_PCI_LIVEUPDATE
void pci_liveupdate_setup_device(struct pci_dev *dev);
void pci_liveupdate_cleanup_device(struct pci_dev *dev);
+void pci_liveupdate_freeze(struct pci_dev *dev);
bool pci_liveupdate_preserve_bus_numbers(struct pci_bus *bus,
struct pci_dev *dev);
void pci_liveupdate_scan_bridge_end(struct pci_dev *dev);
@@ -28,6 +29,9 @@ static inline void pci_liveupdate_cleanup_device(struct pci_dev *dev)
{
}
+static inline void pci_liveupdate_freeze(struct pci_dev *dev)
+{
+}
static inline bool pci_liveupdate_preserve_bus_numbers(struct pci_bus *bus,
struct pci_dev *dev)
{
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index f36778e62ac1..51616e4327d3 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -21,6 +21,7 @@
#include <linux/acpi.h>
#include <linux/dma-map-ops.h>
#include <linux/iommu.h>
+#include "liveupdate.h"
#include "pci.h"
#include "pcie/portdrv.h"
@@ -536,6 +537,7 @@ static void pci_device_shutdown(struct device *dev)
struct pci_dev *pci_dev = to_pci_dev(dev);
struct pci_driver *drv = pci_dev->driver;
+ pci_liveupdate_freeze(pci_dev);
pm_runtime_resume(dev);
if (drv && drv->shutdown)
diff --git a/include/linux/pci_liveupdate.h b/include/linux/pci_liveupdate.h
index 04a2b2a3102a..31898685a406 100644
--- a/include/linux/pci_liveupdate.h
+++ b/include/linux/pci_liveupdate.h
@@ -24,6 +24,8 @@
* @was_preserved: True if this struct pci_dev was preserved by the previous
* kernel. Unlike @incoming, this field is not cleared after
* the device is finished participating in Live Update.
+ * @frozen: True if the outgoing preservation status of this device is frozen
+ * and thus cannot be changed.
*/
struct pci_liveupdate {
struct pci_dev_ser *outgoing;
@@ -31,6 +33,7 @@ struct pci_liveupdate {
u16 acs_ctrl;
bool preserve_bus_numbers;
bool was_preserved;
+ bool frozen;
};
struct pci_dev;
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* [PATCH v8 11/12] PCI: liveupdate: Do not disable bus mastering on preserved devices during kexec
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (9 preceding siblings ...)
2026-07-28 22:10 ` [PATCH v8 10/12] PCI: liveupdate: Freeze preservation status during shutdown David Matlack
@ 2026-07-28 22:10 ` David Matlack
2026-07-28 22:18 ` sashiko-bot
2026-07-28 22:10 ` [PATCH v8 12/12] Documentation: PCI: Add documentation for Live Update David Matlack
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:10 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Do not disable bus mastering on outgoing preserved devices during
pci_device_shutdown() for kexec.
Preserved devices must be allowed to perform memory transactions during
a Live Update to ensure continuous operation. Clearing the bus
mastering bit would prevent these devices from issuing any memory
requests while the new kernel boots.
Because bridges upstream of preserved endpoint devices are also
automatically preserved, this change also avoids clearing bus mastering
on them. This is critical because clearing bus mastering on an upstream
bridge prevents the bridge from forwarding memory requests upstream (i.e.
it would prevent the endpoint device from accessing system RAM and doing
peer-to-peer transactions with devices not downstream of the bridge).
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
drivers/pci/liveupdate.c | 11 +++++++++++
drivers/pci/liveupdate.h | 6 ++++++
drivers/pci/pci-driver.c | 7 +++++--
3 files changed, 22 insertions(+), 2 deletions(-)
diff --git a/drivers/pci/liveupdate.c b/drivers/pci/liveupdate.c
index 65bcecb1b64e..32b73ebf71f7 100644
--- a/drivers/pci/liveupdate.c
+++ b/drivers/pci/liveupdate.c
@@ -132,6 +132,10 @@
* * The PCI core adopts ARI Forwarding Enable on all bridges with downstream
* preserved devices to ensure that all preserved devices on the bridge's
* secondary bus are addressable after the Live Update.
+ *
+ * * The PCI core does not disable bus mastering on outgoing preserved devices
+ * during kexec. This allows preserved devices to issue memory transactions
+ * throughout the Live Update.
*/
#define pr_fmt(fmt) "PCI: liveupdate: " fmt
@@ -879,6 +883,13 @@ int pci_liveupdate_adopt_ari(struct pci_dev *dev)
return 0;
}
+bool pci_liveupdate_is_outgoing(struct pci_dev *dev)
+{
+ guard(rwsem_read)(&pci_liveupdate.rwsem);
+ pci_WARN_ONCE(dev, !dev->liveupdate.frozen, "Preservation status is unstable!\n");
+ return dev->liveupdate.outgoing;
+}
+
/**
* pci_liveupdate_is_incoming() - Check if a device is incoming-preserved
* @dev: The PCI device to check
diff --git a/drivers/pci/liveupdate.h b/drivers/pci/liveupdate.h
index 49d07fd02132..9c31fb60207d 100644
--- a/drivers/pci/liveupdate.h
+++ b/drivers/pci/liveupdate.h
@@ -20,6 +20,7 @@ void pci_liveupdate_scan_bridge_end(struct pci_dev *dev);
void pci_liveupdate_cache_adopted_acs_controls(struct pci_dev *dev);
int pci_liveupdate_enable_adopted_acs_controls(struct pci_dev *dev);
int pci_liveupdate_adopt_ari(struct pci_dev *dev);
+bool pci_liveupdate_is_outgoing(struct pci_dev *dev);
#else
static inline void pci_liveupdate_setup_device(struct pci_dev *dev)
{
@@ -55,6 +56,11 @@ static inline int pci_liveupdate_adopt_ari(struct pci_dev *dev)
{
return -EINVAL;
}
+
+static inline bool pci_liveupdate_is_outgoing(struct pci_dev *dev)
+{
+ return false;
+}
#endif
#endif /* DRIVERS_PCI_LIVEUPDATE_H */
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 51616e4327d3..47cb3dcaa927 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -546,11 +546,14 @@ static void pci_device_shutdown(struct device *dev)
/*
* If this is a kexec reboot, turn off Bus Master bit on the
* device to tell it to not continue to do DMA. Don't touch
- * devices in D3cold or unknown states.
+ * devices being preserved for Live Update or in D3cold or
+ * unknown states.
+ *
* If it is not a kexec reboot, firmware will hit the PCI
* devices with big hammer and stop their DMA any way.
*/
- if (kexec_in_progress && (pci_dev->current_state <= PCI_D3hot))
+ if (kexec_in_progress && !pci_liveupdate_is_outgoing(pci_dev) &&
+ pci_dev->current_state <= PCI_D3hot)
pci_clear_master(pci_dev);
}
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v8 11/12] PCI: liveupdate: Do not disable bus mastering on preserved devices during kexec
2026-07-28 22:10 ` [PATCH v8 11/12] PCI: liveupdate: Do not disable bus mastering on preserved devices during kexec David Matlack
@ 2026-07-28 22:18 ` sashiko-bot
0 siblings, 0 replies; 26+ messages in thread
From: sashiko-bot @ 2026-07-28 22:18 UTC (permalink / raw)
To: David Matlack; +Cc: linux-pci
> Do not disable bus mastering on outgoing preserved devices during
> pci_device_shutdown() for kexec.
>
> Preserved devices must be allowed to perform memory transactions during
> a Live Update to ensure continuous operation. Clearing the bus
> mastering bit would prevent these devices from issuing any memory
> requests while the new kernel boots.
>
> Because bridges upstream of preserved endpoint devices are also
> automatically preserved, this change also avoids clearing bus mastering
> on them. This is critical because clearing bus mastering on an upstream
> bridge prevents the bridge from forwarding memory requests upstream (i.e.
> it would prevent the endpoint device from accessing system RAM and doing
> peer-to-peer transactions with devices not downstream of the bridge).
>
> Reviewed-by: Pranjal Shrivastava <praan@google.com>
> Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
> Signed-off-by: David Matlack <dmatlack@google.com>
Sashiko has reviewed this patch and found no issues. It looks great!
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260728221007.2098560-1-dmatlack@google.com?part=11
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v8 12/12] Documentation: PCI: Add documentation for Live Update
2026-07-28 22:09 [PATCH v8 00/12] PCI: liveupdate: PCI core support for Live Update David Matlack
` (10 preceding siblings ...)
2026-07-28 22:10 ` [PATCH v8 11/12] PCI: liveupdate: Do not disable bus mastering on preserved devices during kexec David Matlack
@ 2026-07-28 22:10 ` David Matlack
2026-07-28 22:19 ` sashiko-bot
11 siblings, 1 reply; 26+ messages in thread
From: David Matlack @ 2026-07-28 22:10 UTC (permalink / raw)
To: kexec, linux-doc, linux-kernel, linux-mm, linux-pci
Cc: Adithya Jayachandran, Alexander Graf, Alex Williamson,
Bjorn Helgaas, Chris Li, David Matlack, David Rientjes, Jacob Pan,
Jason Gunthorpe, Jonathan Corbet, Josh Hilke, Leon Romanovsky,
Lukas Wunner, Mike Rapoport, Parav Pandit, Pasha Tatashin,
Pranjal Shrivastava, Pratyush Yadav, Saeed Mahameed,
Samiullah Khawaja, Shuah Khan, Vipin Sharma, William Tu, Yi Liu
Add documentation files for the PCI subsystem's participation in Live
Update.
These documentation files are generated from the kernel-doc comments
in the PCI Live Update source code. They describe the File-Lifecycle
Bound (FLB) API, the device tracking API, and the specific policies
applied to preserved devices (such as bus number inheritance and bus
mastering preservation).
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Signed-off-by: David Matlack <dmatlack@google.com>
---
Documentation/PCI/index.rst | 1 +
Documentation/PCI/liveupdate.rst | 35 +++++++++++++++++++++++++++
Documentation/core-api/liveupdate.rst | 1 +
MAINTAINERS | 1 +
4 files changed, 38 insertions(+)
create mode 100644 Documentation/PCI/liveupdate.rst
diff --git a/Documentation/PCI/index.rst b/Documentation/PCI/index.rst
index 5d720d2a415e..23fb737ac969 100644
--- a/Documentation/PCI/index.rst
+++ b/Documentation/PCI/index.rst
@@ -20,3 +20,4 @@ PCI Bus Subsystem
controller/index
boot-interrupts
tph
+ liveupdate
diff --git a/Documentation/PCI/liveupdate.rst b/Documentation/PCI/liveupdate.rst
new file mode 100644
index 000000000000..96b1d7f5df3a
--- /dev/null
+++ b/Documentation/PCI/liveupdate.rst
@@ -0,0 +1,35 @@
+.. SPDX-License-Identifier: GPL-2.0-or-later
+
+===========================
+PCI Support for Live Update
+===========================
+
+.. kernel-doc:: drivers/pci/liveupdate.c
+ :doc: PCI Live Update
+
+Driver API
+==========
+
+.. kernel-doc:: drivers/pci/liveupdate.c
+ :export:
+
+Internal API
+============
+
+.. kernel-doc:: drivers/pci/liveupdate.c
+ :internal:
+
+Live Update ABI
+===============
+
+.. kernel-doc:: include/linux/kho/abi/pci.h
+ :doc: PCI File-Lifecycle Bound (FLB) Live Update ABI
+
+.. kernel-doc:: include/linux/kho/abi/pci.h
+ :internal:
+
+See Also
+========
+
+ * :doc:`/core-api/liveupdate`
+ * :doc:`/core-api/kho/index`
diff --git a/Documentation/core-api/liveupdate.rst b/Documentation/core-api/liveupdate.rst
index b3c689e633c1..2bce2644eba2 100644
--- a/Documentation/core-api/liveupdate.rst
+++ b/Documentation/core-api/liveupdate.rst
@@ -74,3 +74,4 @@ See Also
- :doc:`Live Update uAPI </userspace-api/liveupdate>`
- :doc:`/core-api/kho/index`
+- :doc:`PCI </PCI/liveupdate>`
diff --git a/MAINTAINERS b/MAINTAINERS
index 08a724b860dc..347c435ca404 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -20833,6 +20833,7 @@ L: kexec@lists.infradead.org
L: linux-pci@vger.kernel.org
S: Maintained
T: git git://git.kernel.org/pub/scm/linux/kernel/git/liveupdate/linux.git
+F: Documentation/PCI/liveupdate.rst
F: drivers/pci/liveupdate.c
F: drivers/pci/liveupdate.h
F: include/linux/kho/abi/pci.h
--
2.55.0.487.gaf234c4eb3-goog
^ permalink raw reply related [flat|nested] 26+ messages in thread