Re: [PATCH v10 18/31] cxl/extent: Handle DC Release Capacity events

[Dave Jiang <dave.jiang@intel.com>]

On 5/23/26 2:43 AM, Anisa Su wrote:
> Replace the no-op ack stub for cxl_rm_extent() with the real teardown:
> resolve the released DPA range to its region and endpoint decoder,
> locate the matching dc_extent in cxlr_dax->dc_extents (filtering by
> cxled, range containment, and tag), and tear down the entire containing
> tag group atomically through rm_tag_group().  Partial release is not
> supported.
> 
> rm_tag_group() invalidates caches once for the whole group (no mappings
> exist at this point — partial release is not supported, so all members
> are leaving together), then walks the group's dc_extents and releases
> each via its devm action installed at online_tag_group() time.
> 
> cxl_region_invalidate_memregion() becomes non-static and is declared
> in core.h so rm_tag_group() can flush caches before tearing the group down.
> 
> When the released range maps to no region (host crashed before
> persisting acceptance, region destruction raced device release, or the
> device is confused) the host has nothing to drop, so reply via
> memdev_release_extent() to keep the device's view consistent.
> 
> Based on an original patch by Navneet Singh.
> 
> Signed-off-by: Ira Weiny <ira.weiny@intel.com>
> Signed-off-by: Anisa Su <anisa.su@samsung.com>
> 
> ---
> Changes:
> [anisa: restructured from the original "Process dynamic partition
>  events" monolith; this commit replaces the stubbed release with the
>  real walk-and-tear-down of the matching tag group.]
> ---
>  drivers/cxl/core/core.h   |   8 +++
>  drivers/cxl/core/extent.c | 101 ++++++++++++++++++++++++++++++++++++++
>  drivers/cxl/core/mbox.c   |  19 -------
>  drivers/cxl/core/region.c |   2 +-
>  4 files changed, 110 insertions(+), 20 deletions(-)
> 
> diff --git a/drivers/cxl/core/core.h b/drivers/cxl/core/core.h
> index 30b6b05b155b..65daaaadf68e 100644
> --- a/drivers/cxl/core/core.h
> +++ b/drivers/cxl/core/core.h
> @@ -28,6 +28,8 @@ cxled_to_mds(struct cxl_endpoint_decoder *cxled)
>  	return container_of(cxlds, struct cxl_memdev_state, cxlds);
>  }
>  
> +int cxl_region_invalidate_memregion(struct cxl_region *cxlr);

Doesn't this need to go within CONFIG_CXL_REGION?

> +
>  #ifdef CONFIG_CXL_REGION
>  
>  struct cxl_region_context {
> @@ -67,6 +69,7 @@ int devm_cxl_add_pmem_region(struct cxl_region *cxlr);
>  
>  int cxl_add_extent(struct cxl_memdev_state *mds, struct cxl_extent *extent,
>  		   u16 seq_num);
> +int cxl_rm_extent(struct cxl_memdev_state *mds, struct cxl_extent *extent);
>  int online_tag_group(struct cxl_dc_tag_group *group);
>  #else
>  static inline u64 cxl_dpa_to_hpa(struct cxl_region *cxlr,
> @@ -79,6 +82,11 @@ static inline int cxl_add_extent(struct cxl_memdev_state *mds,
>  {
>  	return 0;
>  }
> +static inline int cxl_rm_extent(struct cxl_memdev_state *mds,
> +				struct cxl_extent *extent)
> +{
> +	return 0;
> +}
>  static inline int online_tag_group(struct cxl_dc_tag_group *group)
>  {
>  	return 0;
> diff --git a/drivers/cxl/core/extent.c b/drivers/cxl/core/extent.c
> index b01507022cff..51116c8139ed 100644
> --- a/drivers/cxl/core/extent.c
> +++ b/drivers/cxl/core/extent.c
> @@ -344,6 +344,107 @@ static void dc_extent_unregister(void *ext)
>  	device_unregister(&dc_extent->dev);
>  }
>  
> +static void rm_tag_group(struct cxl_dc_tag_group *group)
> +{
> +	struct device *region_dev = &group->cxlr_dax->dev;
> +	struct dc_extent *dc_extent;
> +	unsigned long index;
> +
> +	/*
> +	 * Tagged allocations release atomically.  Invalidate caches once
> +	 * for the whole group (no mappings exist at this point — partial
> +	 * release is not supported, so all members are leaving use
> +	 * together) before tearing down each dc_extent device.
> +	 *
> +	 * Pin @group across the walk: each devm_release_action runs the
> +	 * dc_extent_unregister action synchronously, which drops the last
> +	 * reference on the dc_extent device and fires dc_extent_release.
> +	 * The release decrements group->nr_extents and, on the final
> +	 * decrement, frees @group.  Without the pin the next iteration's
> +	 * xa_find_after() dereferences a freed xarray.
> +	 */
> +	cxl_region_invalidate_memregion(group->cxlr_dax->cxlr);

check return value?

> +
> +	group->nr_extents++;
> +	xa_for_each(&group->dc_extents, index, dc_extent)
> +		devm_release_action(region_dev, dc_extent_unregister, dc_extent);
> +	group->nr_extents--;
> +	if (!group->nr_extents)
> +		free_tag_group(group);
> +}
> +
> +int cxl_rm_extent(struct cxl_memdev_state *mds, struct cxl_extent *extent)
> +{
> +	u64 start_dpa = le64_to_cpu(extent->start_dpa);
> +	struct cxl_memdev *cxlmd = mds->cxlds.cxlmd;
> +	struct cxl_endpoint_decoder *cxled;
> +	struct cxl_dax_region *cxlr_dax;
> +	struct cxl_dc_tag_group *group;
> +	struct dc_extent *dc_extent;
> +	struct cxl_region *cxlr;
> +	struct range dpa_range;
> +	unsigned long idx;
> +	uuid_t tag;
> +
> +	dpa_range = (struct range) {
> +		.start = start_dpa,
> +		.end = start_dpa + le64_to_cpu(extent->length) - 1,
> +	};
> +
> +	guard(rwsem_read)(&cxl_rwsem.region);
> +	cxlr = cxl_dpa_to_region(cxlmd, start_dpa, &cxled);
> +	if (!cxlr) {
> +		/*
> +		 * No region can happen here for a few reasons:
> +		 *
> +		 * 1) Extents were accepted and the host crashed/rebooted
> +		 *    leaving them in an accepted state.  On reboot the host
> +		 *    has not yet created a region to own them.
> +		 *
> +		 * 2) Region destruction won the race with the device releasing
> +		 *    all the extents.  Here the release will be a duplicate of
> +		 *    the one sent via region destruction.
> +		 *
> +		 * 3) The device is confused and releasing extents for which no
> +		 *    region ever existed.
> +		 *
> +		 * In all these cases make sure the device knows we are not
> +		 * using this extent.
> +		 */
> +		memdev_release_extent(mds, &dpa_range);
> +		return -ENXIO;
> +	}
> +
> +	cxlr_dax = cxlr->cxlr_dax;

Does it need to check if cxlr_dax is NULL?

DJ

> +	import_uuid(&tag, extent->uuid);
> +
> +	/*
> +	 * Find the dc_extent whose DPA range covers the released range and
> +	 * whose tag matches.  The release targets the entire containing
> +	 * tag group atomically; partial release is not supported.
> +	 */
> +	group = NULL;
> +	xa_for_each(&cxlr_dax->dc_extents, idx, dc_extent) {
> +		if (dc_extent->cxled != cxled)
> +			continue;
> +		if (!range_contains(&dc_extent->dpa_range, &dpa_range))
> +			continue;
> +		if (!uuid_equal(&dc_extent->group->uuid, &tag))
> +			continue;
> +		group = dc_extent->group;
> +		break;
> +	}
> +	if (!group) {
> +		dev_err(&cxlr_dax->dev,
> +			"release DPA %pra (%pU) matches no dc_extent\n",
> +			&dpa_range, &tag);
> +		return -EINVAL;
> +	}
> +
> +	rm_tag_group(group);
> +	return 0;
> +}
> +
>  static void cleanup_pending_dc_extent(struct dc_extent *dc_extent)
>  {
>  	struct cxl_dc_tag_group *group = dc_extent->group;
> diff --git a/drivers/cxl/core/mbox.c b/drivers/cxl/core/mbox.c
> index 545c48c9c373..70e6c4c9743c 100644
> --- a/drivers/cxl/core/mbox.c
> +++ b/drivers/cxl/core/mbox.c
> @@ -1587,25 +1587,6 @@ static int handle_add_event(struct cxl_memdev_state *mds,
>  	return rc;
>  }
>  
> -/*
> - * Stub: ack the release back to the device so it knows we are not
> - * using the range.  A later commit replaces this with the real
> - * teardown that walks the region's tag group and tears down the
> - * member dc_extent devices.
> - */
> -static int cxl_rm_extent(struct cxl_memdev_state *mds,
> -			 struct cxl_extent *extent)
> -{
> -	u64 start_dpa = le64_to_cpu(extent->start_dpa);
> -	struct range dpa_range = {
> -		.start = start_dpa,
> -		.end = start_dpa + le64_to_cpu(extent->length) - 1,
> -	};
> -
> -	memdev_release_extent(mds, &dpa_range);
> -	return 0;
> -}
> -
>  static char *cxl_dcd_evt_type_str(u8 type)
>  {
>  	switch (type) {
> diff --git a/drivers/cxl/core/region.c b/drivers/cxl/core/region.c
> index 733d77c07493..317630d8bf2e 100644
> --- a/drivers/cxl/core/region.c
> +++ b/drivers/cxl/core/region.c
> @@ -222,7 +222,7 @@ static struct cxl_region_ref *cxl_rr_load(struct cxl_port *port,
>  	return xa_load(&port->regions, (unsigned long)cxlr);
>  }
>  
> -static int cxl_region_invalidate_memregion(struct cxl_region *cxlr)
> +int cxl_region_invalidate_memregion(struct cxl_region *cxlr)
>  {
>  	if (!cpu_cache_has_invalidate_memregion()) {
>  		if (IS_ENABLED(CONFIG_CXL_REGION_INVALIDATION_TEST)) {