On Thu, 5 Nov 2026 08:02:28 +0900 Anisa Su <[email protected]> wrote:
> From: Ira Weiny <[email protected]> > > Add the handling skeleton for DC Add and DC Release events. Per CXL > r4.0 Section 8.2.10.9.9.3, the host is expected to respond to one or > more Add Capacity Event Record(s) with an Add Dynamic Capacity Response > (Opcode 4802h) to acknowledge which extents the host accepts for use. > Similarly, per CXL r4.0 Section 8.2.10.9.9.4, the host is expected to > respond to Release Capacity Event Record(s) with a Release Dynamic > Capacity command (Opcode 4803h), or to issue one that is not > associated with any event to release capacity on its own. > > The records of one operation can be chained by the More flag. Chained > records are contiguous in the event log and share one event type (CXL > r4.0 Table 8-229), so a single staging context, mds->dc_chain, holds > the records of the open chain until the closing record (More=0) > arrives and the chain is processed and responded to as a whole. A > record that fails to stage, or one of the other type arriving inside an > open chain, drops the chain: an add is refused with an empty response, > a release is left for the device to retry. > > This commit refuses all extents from Add Capacity chains and acks all > Release Capacity chains. Subsequent commits implement accepting and > releasing extents. > > Forced Capacity Release and Region Configuration Updated events are > logged and ignored. > > Based on an original patch by Navneet Singh. > > Signed-off-by: Ira Weiny <[email protected]> > Co-developed-by: Anisa Su <[email protected]> > Signed-off-by: Anisa Su <[email protected]> > Tested-by: Wonjae Lee <[email protected]> > Tested-by: Junhee Park <[email protected]> > Tested-by: Heesoo Kim <[email protected]> Sashiko does raise an interesting question about trailing events in a chain after an error. If it's shared capacity we aren't allowed a partial accept. Otherwise it is fine (I think) but perhaps not complexity we want. So probably need some flag to say problem occured on a record with more flag set. Keep dropping until we have had a closing record. For force release, I'm not sure if we should just panic() (maybe with a sanity check that the range was mapped) or ignore it and die in a storm of poison (hopefully rather than zeros). > --- > drivers/cxl/core/mbox.c | 246 ++++++++++++++++++++++++++++++++++++++- > drivers/cxl/core/trace.h | 3 +- > drivers/cxl/cxl.h | 9 ++ > drivers/cxl/cxlmem.h | 46 ++++++++ > drivers/cxl/pci.c | 20 +++- > include/cxl/event.h | 37 ++++++ > 6 files changed, 353 insertions(+), 8 deletions(-) > > diff --git a/drivers/cxl/core/mbox.c b/drivers/cxl/core/mbox.c > index 13a68f5cef69..3acf5ace48db 100644 > --- a/drivers/cxl/core/mbox.c > +++ b/drivers/cxl/core/mbox.c > +static int cxl_send_dc_response(struct cxl_memdev_state *mds, int opcode, > + struct list_head *extent_list, int cnt) > +{ > + struct cxl_mailbox *cxl_mbox = &mds->cxlds.cxl_mbox; > + struct cxl_mbox_dc_response *p; > + struct cxl_extent_list_node *pos, *tmp; > + struct cxl_extent *extent; > + u32 pl_index; > + > + size_t pl_size = struct_size(p, extent_list, cnt); > + u32 max_extents = cnt; > + > + /* May have to use more bit on response. */ > + if (pl_size > cxl_mbox->payload_size) { > + max_extents = (cxl_mbox->payload_size - sizeof(*p)) / > + sizeof(struct updated_extent_list); > + pl_size = struct_size(p, extent_list, max_extents); > + } > + > + struct cxl_mbox_dc_response *response __free(kfree) = > + kzalloc(pl_size, GFP_KERNEL); > + if (!response) { > + struct cxl_mbox_dc_response empty = { }; > + > + /* An empty Release DC is invalid (CXL r4.0 Table 8-352) */ > + if (opcode == CXL_MBOX_OP_RELEASE_DC) > + return -ENOMEM; > + /* Refuse all extents rather than stall the device. */ > + return send_one_response(cxl_mbox, &empty, opcode, 0, 0); > + } > + > + /* Set __counted_by to capacity before populating; reset per response. > */ > + response->extent_list_size = cpu_to_le32(max_extents); > + > + if (cnt == 0) > + return send_one_response(cxl_mbox, response, opcode, 0, 0); > + > + pl_index = 0; > + list_for_each_entry_safe(pos, tmp, extent_list, list) { > + extent = pos->extent; > + response->extent_list[pl_index].dpa_start = extent->start_dpa; > + response->extent_list[pl_index].length = extent->length; > + pl_index++; > + > + if (pl_index == max_extents) { Maybe flip? if (pl_index != max_extents) continue; flags = 0; ... > + u8 flags = 0; > + int rc; > + > + if (pl_index < cnt) > + flags |= CXL_DCD_EVENT_MORE; > + rc = send_one_response(cxl_mbox, response, opcode, > + pl_index, flags); > + if (rc) > + return rc; > + cnt -= pl_index; > + if (cnt < max_extents) > + max_extents = cnt; > + pl_index = 0; > + } > + } > + > + if (!pl_index) /* nothing more to do */ > + return 0; > + return send_one_response(cxl_mbox, response, opcode, pl_index, 0); > +} > + > +static int stage_pending_extent(struct list_head *pending, > + struct cxl_extent *to_add) > +{ > + struct cxl_extent_list_node *node = kzalloc(sizeof(*node), GFP_KERNEL); > + struct cxl_extent *extent; > + > + if (!node) > + return -ENOMEM; > + extent = kmemdup(to_add, sizeof(*extent), GFP_KERNEL); Maybe scatter some __free() magic in here and no_free_ptr() where they get handed off.. > + if (!extent) { > + kfree(node); > + return -ENOMEM; > + } > + > + node->extent = extent; e.g. node->extent = no_free_ptr(extent); > + list_add_tail(&node->list, pending); list_add_tail(&no_free_ptr(node)->list, pending); > + return 0; > +} > + > +static void cxl_handle_dcd_event_records(struct cxl_memdev_state *mds, > + struct cxl_event_record_raw *raw_rec) > +{ > + struct cxl_event_dcd *event = &raw_rec->event.dcd; > + struct cxl_extent *extent = &event->extent; > + struct device *dev = mds->cxlds.dev; > + uuid_t *id = &raw_rec->id; > + int rc; > + > + if (!uuid_equal(id, &CXL_EVENT_DC_EVENT_UUID)) > + return; > + > + dev_dbg(dev, "DCD event %s : DPA:%#llx LEN:%#llx\n", > + cxl_dcd_evt_type_str(event->event_type), > + le64_to_cpu(extent->start_dpa), le64_to_cpu(extent->length)); > + > + switch (event->event_type) { > + case DCD_ADD_CAPACITY: > + case DCD_RELEASE_CAPACITY: > + rc = handle_dcd_chain_event(mds, event); > + break; > + case DCD_FORCED_CAPACITY_RELEASE: > + dev_err_ratelimited(dev, "Forced release event ignored.\n"); If that actually happens to us, maybe we should panic? All bets are off if we get one of these for capacity that was actually in use. > + rc = 0; > + break; > + case DCD_REGION_CONFIGURATION_UPDATED: > + dev_dbg(dev, "Region configuration updated event ignored.\n"); > + rc = 0; > + break; > + default: > + rc = -EINVAL; > + break; > + } > + > + if (rc) > + dev_err_ratelimited(dev, "dcd event failed: %d\n", rc); > +} > + > static void cxl_mem_get_records_log(struct cxl_memdev_state *mds, > enum cxl_event_log_type type) > { > @@ -1136,9 +1368,13 @@ static void cxl_mem_get_records_log(struct > cxl_memdev_state *mds, > if (!nr_rec) > break; > > - for (i = 0; i < nr_rec; i++) > + for (i = 0; i < nr_rec; i++) { > __cxl_event_trace_record(cxlmd, type, > &payload->records[i]); > + if (type == CXL_EVENT_TYPE_DCD) > + cxl_handle_dcd_event_records(mds, > + > &payload->records[i]); Just go long on that one. I wouldn't do the normal thing of flipping the condition because this being out of line makes sense as its an oddity in this function. > + } > > if (payload->flags & CXL_GET_EVENT_FLAG_OVERFLOW) > trace_cxl_overflow(cxlmd, type, payload); > diff --git a/drivers/cxl/cxl.h b/drivers/cxl/cxl.h > index d098f7f50bef..64138e1768a1 100644 > --- a/drivers/cxl/cxl.h > +++ b/drivers/cxl/cxl.h > @@ -12,6 +12,7 @@ > #include <linux/node.h> > #include <linux/io.h> > #include <linux/range.h> > +#include <linux/xarray.h> This looks misplaces as nothing in the header changed that has anything to do with xarrays. > #include <cxl/cxl.h> > > extern const struct nvdimm_security_ops *cxl_security_ops; > @@ -557,6 +558,14 @@ struct cxl_pmem_region { > struct cxl_pmem_region_mapping mapping[]; > }; > > +/* See CXL r4.0 8.2.10.2.1.6 */ > +enum dc_event { > + DCD_ADD_CAPACITY, > + DCD_RELEASE_CAPACITY, > + DCD_FORCED_CAPACITY_RELEASE, > + DCD_REGION_CONFIGURATION_UPDATED, > +}; > + > struct cxl_dax_region { > struct device dev; > struct cxl_region *cxlr;
