cxl: Handle background commands
Davidlohr Bueso
maintainerv3 cover cxl: Handle background commands
Hi,
This is the latest iteration of the synchronous background command handling work. Currently there are no users, but it is expected that firmware update and scan media be the first two to use it.
Patches 1-3 are requirements for the actual patch 4.
Changes from v1/v2 (https://lore.kernel.org/linux-cxl/[email protected]):
o Picked up tags for patches 1 and 2.
o Added more context to the changelog in the rcuwait patch 1. (Dan)
o Added new patch 3 for common request irq functionality. (Dan)
o Misc cleanups in patch 4. (Jonathan)
o Don't clobber the ctrl settings. (Dan)
o Removed bogus warning in irq handler. (Jonathan, Dan)
o Make sleep uninterruptible and clarify in the changelog that
timeouts are in fact unexpected.
Applies against 'fixes' from cxl.git.
Thanks!
Davidlohr Bueso (4):
rcuwait: Support timeouts
cxl/pci: Allocate irq vectors earlier during probe cxl/pci: Introduce cxl_request_irq() cxl/mbox: Add background cmd handling machinery
drivers/cxl/core/mbox.c | 3 +- drivers/cxl/cxl.h | 8 +++ drivers/cxl/cxlmem.h | 7 +++ drivers/cxl/pci.c | 136 ++++++++++++++++++++++++++++++++++------ include/linux/rcuwait.h | 23 ++++++- 5 files changed, 153 insertions(+), 24 deletions(-)
--
2.40.1
Davidlohr Bueso
maintainerPATCH v3 1/4 rcuwait: Support timeouts
The rcuwait utility provides an efficient and safe single wait/wake mechanism. It is used in situations where queued wait is the wrong semantics, and often too bulky. For example, cases where the wait is already done under a lock.
In the past, rcuwait has been extended to support beyond only uninterruptible sleep, and similarly, there are users that can benefit for the addition of timeouts.
As such, tntroduce rcuwait_wait_event_timeout(), with semantics equivalent to calls for queued wait counterparts.
--- include/linux/rcuwait.h | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-)
include/linux/rcuwait.h +20 -3
@@ -49,9 +49,9 @@ static inline void prepare_to_rcuwait(struct rcuwait *w)extern void finish_rcuwait (struct rcuwait *w); -#define rcuwait_wait_event (w, condition, state) \ +#define ___rcuwait_wait_event (w, condition, state, ret, cmd) \ ({ \ - int __ret = 0; \ + long __ret = ret; \ prepare_to_rcuwait(w); \ for (;;) { \/* \
@@ -67,10 +67,27 @@ extern void finish_rcuwait(struct rcuwait *w); break; \ } \ \ -schedule (); \ + cmd; \ } \finish_rcuwait (w); \ __ret; \ }) +#define rcuwait_wait_event (w, condition, state) \ + ___rcuwait_wait_event(w, condition, state, 0, schedule()) + +#define __rcuwait_wait_event_timeout (w, condition, state, timeout) \ + ___rcuwait_wait_event(w, ___wait_cond_timeout(condition), \ + state, timeout, \ + __ret = schedule_timeout(__ret)) + +#define rcuwait_wait_event_timeout (w, condition, state, timeout) \ +({ \ + long __ret = timeout; \ + if (!___wait_cond_timeout(condition)) \ + __ret = __rcuwait_wait_event_timeout(w, condition, \ + state, timeout); \ + __ret; \ +}) +#endif /* _LINUX_RCUWAIT_H_ */
Signature · 1 line
2.40.1
Davidlohr Bueso
maintainerPATCH v3 2/4 cxl/pci: Allocate irq vectors earlier during probe
In reply to Davidlohr BuesoMove the cxl_alloc_irq_vectors() call further up in the probing in order to allow for mailbox interrupt usage. No change in semantics.
--- drivers/cxl/pci.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/cxl/pci.c +4 -4
@@ -714,6 +714,10 @@ static int cxl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)else dev_warn (&pdev->dev,"Media not active (%d)\n" , rc); + rc =cxl_alloc_irq_vectors (pdev); +if (rc) +return rc; + rc =cxl_pci_setup_mailbox (cxlds);if (rc)return rc;
@@ -738,10 +742,6 @@ static int cxl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)if (rc)return rc; - rc =cxl_alloc_irq_vectors (pdev); -if (rc) -return rc; - cxlmd =devm_cxl_add_memdev (cxlds);if (IS_ERR (cxlmd))return PTR_ERR (cxlmd);
Signature · 1 line
2.40.1
Davidlohr Bueso
maintainerPATCH v3 3/4 cxl/pci: Introduce cxl_request_irq()
In reply to Davidlohr BuesoFactor out common functionality/semantics for cxl shared interrupts into a new helper on top of devm_request_irq().
--- drivers/cxl/pci.c | 39 +++++++++++++++++++++++---------------- 1 file changed, 23 insertions(+), 16 deletions(-)
drivers/cxl/pci.c +23 -16
@@ -84,6 +84,27 @@ static int cxl_pci_mbox_wait_for_doorbell(struct cxl_dev_state *cxlds) status & CXLMDEV_DEV_FATAL ? " fatal" : "", \ status & CXLMDEV_FW_HALT ? " firmware-halt" : "") +struct cxl_dev_id { +struct cxl_dev_state *cxlds; +}; + +static int cxl_request_irq (struct cxl_dev_state *cxlds,int irq, +irq_handler_t handler,irq_handler_t thread_fn) +{ +struct device *dev = cxlds->dev; +struct cxl_dev_id *dev_id; + +/* dev_id must be globally unique and must contain the cxlds */ + dev_id =devm_kzalloc (dev,sizeof (*dev_id),GFP_KERNEL ); +if (!dev_id) +return -ENOMEM ; + dev_id->cxlds = cxlds; + +return devm_request_threaded_irq (dev, irq, handler, thread_fn, +IRQF_SHARED |IRQF_ONESHOT , +NULL , dev_id); +} +/** * __cxl_pci_mbox_send_cmd() - Execute a mailbox command * @cxlds: The device state to communicate with.
@@ -469,10 +490,6 @@ static int cxl_alloc_irq_vectors(struct pci_dev *pdev)return 0 ; } -struct cxl_dev_id { -struct cxl_dev_state *cxlds; -}; -static irqreturn_t cxl_event_thread (int irq,void *id) {struct cxl_dev_id *dev_id = id;
@@ -498,28 +515,18 @@ static irqreturn_t cxl_event_thread(int irq, void *id)static int cxl_event_req_irq (struct cxl_dev_state *cxlds,u8 setting) { -struct device *dev = cxlds->dev; -struct pci_dev *pdev =to_pci_dev (dev); -struct cxl_dev_id *dev_id; +struct pci_dev *pdev =to_pci_dev (cxlds->dev);int irq;if (FIELD_GET (CXLDEV_EVENT_INT_MODE_MASK , setting) !=CXL_INT_MSI_MSIX )return -ENXIO ; -/* dev_id must be globally unique and must contain the cxlds */ - dev_id =devm_kzalloc (dev,sizeof (*dev_id),GFP_KERNEL ); -if (!dev_id) -return -ENOMEM ; - dev_id->cxlds = cxlds; - irq =pci_irq_vector (pdev,FIELD_GET (CXLDEV_EVENT_INT_MSGNUM_MASK , setting));if (irq <0 )return irq; -return devm_request_threaded_irq (dev, irq,NULL , cxl_event_thread, -IRQF_SHARED |IRQF_ONESHOT ,NULL , - dev_id); +return cxl_request_irq (cxlds, irq,NULL , cxl_event_thread); } static int cxl_event_get_int_policy(struct cxl_dev_state *cxlds,
Signature · 1 line
2.40.1
RE: [PATCH 3/4] cxl/pci: Introduce cxl_request_irq()
Quoted 26 lines · Davidlohr Bueso
Factor out common functionality/semantics for cxl shared interrupts into a new helper on top of
devm_request_irq().Suggested-by Dan Williams <[email protected]>Signed-off-by Davidlohr Bueso <[email protected]>--- drivers/cxl/pci.c | 39 +++++++++++++++++++++++---------------- 1 file changed, 23 insertions(+), 16 deletions(-)drivers/cxl/pci.c +9
-0@@ -84,6 +84,27 @@ static int cxl_pci_mbox_wait_for_doorbell(struct cxl_dev_state *cxlds) status & CXLMDEV_DEV_FATAL ? " fatal" : "", \ status & CXLMDEV_FW_HALT ? " firmware-halt" : "") +struct cxl_dev_id { +struct cxl_dev_state *cxlds; +}; + +static int cxl_request_irq (struct cxl_dev_state *cxlds,int irq, +irq_handler_t handler,irq_handler_t thread_fn) +{ +struct device *dev = cxlds->dev; +struct cxl_dev_id *dev_id;
drivers/cxl/pci.c static int cxl_pci_mbox_wait_for_doorbell(struct cxl_dev_state *cxlds) · line 105
Quoted 10 lines
drivers/cxl/pci.c +10
-0+ +/* dev_id must be globally unique and must contain the cxlds */ + dev_id =devm_kzalloc (dev,sizeof (*dev_id),GFP_KERNEL ); +if (!dev_id) +return -ENOMEM ; + dev_id->cxlds = cxlds; + +return devm_request_threaded_irq (dev, irq, handler, thread_fn, +IRQF_SHARED |IRQF_ONESHOT , +NULL , dev_id);
I was going to say drop the IRQF_ONESHOT in the case where @thread_fn is NULL, but I could not convince myself that was safe. I assume that pci_request_irq() gets away with that because most drivers are not mixing combinations of @handler and @thread_fn being set to NULL.
So, with that, this looks good to me.
Davidlohr Bueso
maintainerPATCH v3 4/4 cxl/mbox: Add background cmd handling machinery
In reply to Davidlohr BuesoThis adds support for handling background operations, as defined in the CXL 3.0 spec. Commands that can take too long (over ~2 seconds) can run in the background asynchronously (to the hardware).
The driver will deal with such commands synchronously, blocking all other incoming commands for a specified period of time, allowing time-slicing the command such that the caller can send incremental requests to avoid monopolizing the driver/device. Any out of sync (timeout) between the driver and hardware is just disregarded as an invalid state until the next successful submission. Such timeouts are considered a rare occurrence, either a real device problem or a driver issue that needs to reduce the size of the background operation to fit the timeout.
On devices where mbox interrupts are supported, this will still use a poller that will wakeup in the specified wait intervals. The irq handler will simply awake the blocked cmd, which is also safe vs a task that is either waking (timing out) or already awoken. Similarly any irq setup error during the probing falls back to polling, thus avoids unnecessarily erroring out.
--- drivers/cxl/core/mbox.c | 3 +- drivers/cxl/cxl.h | 8 ++++ drivers/cxl/cxlmem.h | 7 ++++ drivers/cxl/pci.c | 89 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 106 insertions(+), 1 deletion(-)
drivers/cxl/core/mbox.c +2 -1
@@ -220,7 +220,8 @@ int cxl_internal_send_cmd(struct cxl_dev_state *cxlds,if (rc)return rc; -if (mbox_cmd->return_code !=CXL_MBOX_CMD_RC_SUCCESS ) +if (mbox_cmd->return_code !=CXL_MBOX_CMD_RC_SUCCESS && + mbox_cmd->return_code !=CXL_MBOX_CMD_RC_BACKGROUND )return cxl_mbox_cmd_rc2errno (mbox_cmd);if (!out_size)
drivers/cxl/cxl.h +8 -0
@@ -176,14 +176,22 @@ static inline int ways_to_eiw(unsigned int ways, u8 *eiw)/* CXL 2.0 8.2.8.4 Mailbox Registers */ #define CXLDEV_MBOX_CAPS_OFFSET 0x00#define CXLDEV_MBOX_CAP_PAYLOAD_SIZE_MASK GENMASK(4, 0) +#define CXLDEV_MBOX_CAP_BG_CMD_IRQ BIT(6) +#define CXLDEV_MBOX_CAP_IRQ_MSGNUM_MASK GENMASK(10, 7)#define CXLDEV_MBOX_CTRL_OFFSET 0x04#define CXLDEV_MBOX_CTRL_DOORBELL BIT(0) +#define CXLDEV_MBOX_CTRL_BG_CMD_IRQ BIT(2)#define CXLDEV_MBOX_CMD_OFFSET 0x08#define CXLDEV_MBOX_CMD_COMMAND_OPCODE_MASK GENMASK_ULL(15, 0)#define CXLDEV_MBOX_CMD_PAYLOAD_LENGTH_MASK GENMASK_ULL(36, 16)#define CXLDEV_MBOX_STATUS_OFFSET 0x10 +#define CXLDEV_MBOX_STATUS_BG_CMD BIT(0)#define CXLDEV_MBOX_STATUS_RET_CODE_MASK GENMASK_ULL(47, 32)#define CXLDEV_MBOX_BG_CMD_STATUS_OFFSET 0x18 +#define CXLDEV_MBOX_BG_CMD_COMMAND_OPCODE_MASK GENMASK_ULL(15, 0) +#define CXLDEV_MBOX_BG_CMD_COMMAND_PCT_MASK GENMASK_ULL(22, 16) +#define CXLDEV_MBOX_BG_CMD_COMMAND_RC_MASK GENMASK_ULL(47, 32) +#define CXLDEV_MBOX_BG_CMD_COMMAND_VENDOR_MASK GENMASK_ULL(63, 48)#define CXLDEV_MBOX_PAYLOAD_OFFSET 0x20/*
drivers/cxl/cxlmem.h +7 -0
@@ -5,6 +5,7 @@#include <uapi/linux/cxl_mem.h> #include <linux/cdev.h> #include <linux/uuid.h> +#include <linux/rcuwait.h> #include "cxl.h" /* CXL 2.0 8.2.8.5.1.1 Memory Device Status Register */
@@ -108,6 +109,9 @@ static inline struct cxl_ep *cxl_ep_load(struct cxl_port *port,* variable sized output commands, it tells the exact number of bytes * written. * @min_out: (input) internal command output payload size validation +* @poll_count: (input) Number of timeouts to attempt. +* @poll_interval_ms: (input) Time between mailbox background command polling +* interval timeouts. * @return_code: (output) Error code returned from hardware. * * This is the primary mechanism used to send commands to the hardware.
@@ -123,6 +127,8 @@ struct cxl_mbox_cmd {size_t size_in;size_t size_out;size_t min_out; +int poll_count; +int poll_interval_ms;u16 return_code; };
@@ -331,6 +337,7 @@ struct cxl_dev_state {struct cxl_event_state event;struct cxl_poison_state poison; +struct rcuwait mbox_wait;int (*mbox_send)(struct cxl_dev_state *cxlds,struct cxl_mbox_cmd *cmd); };
drivers/cxl/pci.c +89 -0
107 lines not on this page · raw message
Signature · 1 line
2.40.1
Quoted 18 lines · Davidlohr Bueso
Hi,
This is the latest iteration of the synchronous background command handling work. Currently there are no users, but it is expected that firmware update and scan media be the first two to use it.
Patches 1-3 are requirements for the actual patch 4.
Changes from v1/v2 (https://lore.kernel.org/linux-cxl/[email protected]):
o Picked up tags for patches 1 and 2.
o Added more context to the changelog in the rcuwait patch 1. (Dan)
o Added new patch 3 for common request irq functionality. (Dan)
o Misc cleanups in patch 4. (Jonathan)
o Don't clobber the ctrl settings. (Dan)
o Removed bogus warning in irq handler. (Jonathan, Dan)
o Make sleep uninterruptible and clarify in the changelog that
timeouts are in fact unexpected.
Quoted 1 line
Applies against 'fixes' from cxl.git.
Like Linus I want to see the conflicts. Whenever possible base on latest Linus tag like v6.4-rc3. In this case I will add this to a for-6.5/cxl-background topic branch based on 'fixes' for now, but once 'fixes' hits v6.4-rc4 I will move the topic baseline just to have it not be based on a random point in the history.
This also encourages me to be more proactive about getting fixes upstream so that the next Linus tag can be used for development.
Davidlohr Bueso
maintainerQuoted 2 lines · Dan Williams
Like Linus I want to see the conflicts. Whenever possible base on latest Linus tag like v6.4-rc3.
So I'm clear, do you want me to resend this series based on -rc3?
Frankly I'm always confused as to what is the correct/preferred branch to do development on.
Quoted 4 lines
In this case I will add this to a
for-6.5/cxl-background topic branch based on 'fixes' for now, but once 'fixes' hits v6.4-rc4 I will move the topic baseline just to have it not be based on a random point in the history.
Ok, thanks for picking this up.
Quoted 6 lines · Davidlohr Bueso
Quoted 2 lines · Dan Williams
Like Linus I want to see the conflicts. Whenever possible base on latest Linus tag like v6.4-rc3.
So I'm clear, do you want me to resend this series based on -rc3?
No, not this time but for next time my preference is "when in doubt, pick a mainline tag".
Quoted 2 lines
Frankly I'm always confused as to what is the correct/preferred branch to do development on.
My plan is to do better about publishing topic branches for work-in-progress items like this. So now we have for-6.5/cxl-background for this common baseline for sanitization and firmware update. At least one of those will need to be queued before this topic moves forward since the new infrastructure needs a user.
The problem with picking 'next' or to a lesser extent 'fixes' as a development baseline is that it ties unrelated topics together. If something happens and we decided a topic neeeds to drop out of 'next' or be rebased, that's much easier to do if random topics have not grown implicit silent depenendencies over time.
Like in this case these patches do not apply to v6.4-rc3 because they collide with the movement of cxl_await_media_ready() to cxl_pci. However, nothing about that media-ready fix is needed for background command support so the patches can just depend on a mainline tag.