On 5/23/26 2:43 AM, Anisa Su wrote:
> DC DAX regions are populated with dax_resource children that each carry a
> backing tag uuid and a per-allocation sequence number (seq_num). Add the
> userspace claim semantics that resolve those tagged groups into DAX
> devices.
>
> A DC region's seed dax device is created at 0-size on probe; userspace
> populates it by writing to its 'uuid' attribute:
>
> * A non-null UUID claims every dax_resource on this region whose tag
> matches, in seq_num order via uuid_claim_tagged(). The match set
> must form a dense 1..n sequence (no gap, no duplicate); the CXL
> side maintains this invariant for both sharable allocations (where
> the device stamps shared_extn_seq) and non-sharable allocations
> (where cxl_add_pending assigns arrival-order seq). The resulting
> DAX device's size equals the sum of every member extent's size.
>
> * "0" claims a single untagged dax_resource via
> uuid_claim_untagged(). Untagged extents are independent
> allocations; collapsing several would aggregate unrelated capacity,
> so each uuid="0" write consumes exactly one untagged resource.
>
> * A write that matches no dax_resource returns -ENOENT; the device
> stays at size 0.
>
> uuid_show() reads back the backing tag uuid (or the null UUID for an
> untagged claim). The attribute is read-only (0444) on non-DC dax
> devices; writes to it on non-DC regions return -EOPNOTSUPP.
>
> dev_dax_visible() exposes the uuid attribute only on DC dax devices.
>
> Based on an original patch by Navneet Singh.
>
> Signed-off-by: Ira Weiny <[email protected]>
> Signed-off-by: Anisa Su <[email protected]>
>
> ---
> Changes:
> [anisa: split out from the original "Surface dc_extents" commit;
> userspace tag-claim semantics only.]
> ---
> drivers/dax/bus.c | 260 +++++++++++++++++++++++++++++++++++++++++++++-
> 1 file changed, 256 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/dax/bus.c b/drivers/dax/bus.c
> index c030eb103ad0..1dccb3e5cd0f 100644
> --- a/drivers/dax/bus.c
> +++ b/drivers/dax/bus.c
> @@ -5,6 +5,7 @@
> #include <linux/mutex.h>
> #include <linux/list.h>
> #include <linux/slab.h>
> +#include <linux/sort.h>
> #include <linux/dax.h>
> #include <linux/io.h>
> #include "dax-private.h"
> @@ -1316,6 +1317,89 @@ static ssize_t dev_dax_resize(struct dax_region
> *dax_region,
> return 0;
> }
>
> +/* DC extents are all-or-nothing: an extent is either free or fully claimed.
> */
> +static bool dax_resource_in_use(const struct dax_resource *dax_resource)
> +{
> + return dax_resource->use_cnt > 0;
> +}
> +
> +struct dax_uuid_match {
> + const struct dax_region *dax_region;
> + const uuid_t *uuid;
> +};
> +
> +static int find_uuid_extent(struct device *dev, const void *data)
> +{
> + const struct dax_uuid_match *match = data;
> + struct dax_resource *dax_resource;
> +
> + if (!match->dax_region->dc_ops->is_extent(dev))
> + return 0;
> +
> + dax_resource = dev_get_drvdata(dev);
> + if (!dax_resource || dax_resource_in_use(dax_resource))
> + return 0;
> + return uuid_equal(&dax_resource->uuid, match->uuid);
> +}
> +
> +struct dax_tag_collect {
> + const struct dax_region *dax_region;
> + const uuid_t *uuid;
> + struct dax_resource **arr;
> + unsigned int count;
> + unsigned int cap;
> +};
> +
> +static int collect_uuid_extent(struct device *dev, void *data)
> +{
> + struct dax_tag_collect *c = data;
> + struct dax_resource *dax_resource;
> +
> + if (!c->dax_region->dc_ops->is_extent(dev))
> + return 0;
> +
> + dax_resource = dev_get_drvdata(dev);
> + if (!dax_resource || dax_resource_in_use(dax_resource))
> + return 0;
> + if (!uuid_equal(&dax_resource->uuid, c->uuid))
> + return 0;
> +
> + if (c->count == c->cap)
> + return -ENOSPC;
> + c->arr[c->count++] = dax_resource;
> + return 0;
> +}
> +
> +static int count_uuid_extent(struct device *dev, void *data)
> +{
> + struct dax_tag_collect *c = data;
> + struct dax_resource *dax_resource;
> +
> + if (!c->dax_region->dc_ops->is_extent(dev))
> + return 0;
> +
> + dax_resource = dev_get_drvdata(dev);
> + if (!dax_resource || dax_resource_in_use(dax_resource))
> + return 0;
> + if (!uuid_equal(&dax_resource->uuid, c->uuid))
> + return 0;
> +
> + c->count++;
> + return 0;
> +}
> +
> +static int dax_resource_seq_cmp(const void *a, const void *b)
> +{
> + const struct dax_resource * const *pa = a;
> + const struct dax_resource * const *pb = b;
> +
> + if ((*pa)->seq_num < (*pb)->seq_num)
> + return -1;
> + if ((*pa)->seq_num > (*pb)->seq_num)
> + return 1;
> + return 0;
> +}
> +
> static ssize_t size_store(struct device *dev, struct device_attribute *attr,
> const char *buf, size_t len)
> {
> @@ -1548,13 +1632,177 @@ static DEVICE_ATTR_RO(numa_node);
> static ssize_t uuid_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> - return sysfs_emit(buf, "%d\n", 0);
> + struct dev_dax *dev_dax = to_dev_dax(dev);
> + int rc;
> +
> + rc = down_read_interruptible(&dax_dev_rwsem);
Since we are here, may as well convert these to ACQUIRE() and be rid of the
gotos
ACQUIRE(rwsem_read_intr, rwsem)(&dax_dev_rwsem);
if ((rc = ACQUIRE_ERR(rwsem_read_intr, &rwsem)))
...
> + if (rc)
> + return rc;
> +
> + for (int i = 0; i < dev_dax->nr_range; i++) {
> + struct dax_resource *r = dev_dax->ranges[i].dax_resource;
> +
> + if (r && !uuid_is_null(&r->uuid)) {
> + rc = sysfs_emit(buf, "%pUb\n", &r->uuid);
> + goto out;
> + }
> + }
> + rc = sysfs_emit(buf, "0\n");
As pointed out earlyer, should display null_uuid to be consistent.
> +out:
> + up_read(&dax_dev_rwsem);
> + return rc;
> +}
> +
> +static ssize_t uuid_claim_untagged(struct dax_region *dax_region,
> + struct dev_dax *dev_dax)
> +{
> + struct dax_uuid_match match = {
> + .dax_region = dax_region,
> + .uuid = &uuid_null,
> + };
> + struct dax_resource *dax_resource;
> + resource_size_t to_alloc;
> + struct device *extent_dev;
> + ssize_t alloc;
> +
> + extent_dev = device_find_child(dax_region->dev, &match,
> + find_uuid_extent);
> + if (!extent_dev)
> + return -ENOENT;
> +
> + dax_resource = dev_get_drvdata(extent_dev);
> + to_alloc = resource_size(dax_resource->res);
> + alloc = __dev_dax_resize(dax_resource->res, dev_dax, to_alloc,
> + dax_resource);
> + put_device(extent_dev);
> + if (alloc < 0)
> + return alloc;
> + if (alloc == 0)
> + return -ENOENT;
> + dax_resource->use_cnt++;
> + return 0;
> +}
> +
> +static ssize_t uuid_claim_tagged(struct dax_region *dax_region,
> + struct dev_dax *dev_dax, const uuid_t *uuid)
> +{
> + struct dax_tag_collect c = {
> + .dax_region = dax_region,
> + .uuid = uuid,
> + };
> + unsigned int i;
> + ssize_t rc;
> +
> + /* Two-pass: count, then collect into a sized array. */
> + device_for_each_child(dax_region->dev, &c, count_uuid_extent);
> + if (!c.count)
> + return -ENOENT;
> +
> + c.arr = kmalloc_array(c.count, sizeof(*c.arr), GFP_KERNEL);
> + if (!c.arr)
> + return -ENOMEM;
> + c.cap = c.count;
> + c.count = 0;
> +
> + rc = device_for_each_child(dax_region->dev, &c, collect_uuid_extent);
> + if (rc)
> + goto out;
> +
> + sort(c.arr, c.count, sizeof(*c.arr), dax_resource_seq_cmp, NULL);
> +
> + /*
> + * Tagged groups carry a dense 1..n @seq_num regardless of source
> + * (sharable: device-stamped; non-sharable: host-assigned in
> + * arrival order — see &struct dax_resource). A gap or
> + * out-of-range value here means an extent went missing on the
> + * cxl side (e.g. a per-extent failure in cxl_add_pending) or a
> + * cxl-side validation gap; in either case refuse the whole
> + * group rather than carve a partial allocation.
> + */
> + for (i = 0; i < c.count; i++) {
> + if (c.arr[i]->seq_num != i + 1) {
> + dev_WARN_ONCE(dax_region->dev, 1,
> + "tag %pUb seq invariant violated at slot %u
> (got %u)\n",
> + uuid, i, c.arr[i]->seq_num);
> + rc = -EINVAL;
> + goto out;
> + }
> + }
> +
> + for (i = 0; i < c.count; i++) {
> + resource_size_t to_alloc = resource_size(c.arr[i]->res);
> + ssize_t alloc;
> +
> + alloc = __dev_dax_resize(c.arr[i]->res, dev_dax, to_alloc,
> + c.arr[i]);
> + if (alloc < 0) {
> + rc = alloc;
> + goto rollback;
> + }
> + if (alloc == 0) {
> + rc = -ENOSPC;
> + goto rollback;
> + }
> + c.arr[i]->use_cnt++;
> + }
> + rc = 0;
> + goto out;
> +
> +rollback:
> + /*
> + * Partial failure: trim every range we added in this attempt.
> + * trim_dev_dax_range pops the most-recently-appended range from
> + * dev_dax->ranges[] and decrements its dax_resource->use_cnt, so
> + * looping until we have undone @i additions restores both
> + * dev_dax->ranges[] and the matched dax_resources' use_cnt.
> + */
> + while (i-- > 0)
> + trim_dev_dax_range(dev_dax);
> +out:
> + kfree(c.arr);
> + return rc;
> }
>
> static ssize_t uuid_store(struct device *dev, struct device_attribute *attr,
> const char *buf, size_t len)
> {
> - return -EOPNOTSUPP;
> + struct dev_dax *dev_dax = to_dev_dax(dev);
> + struct dax_region *dax_region = dev_dax->region;
> + uuid_t uuid;
> + ssize_t rc;
> +
> + if (!is_dynamic(dax_region))
> + return -EOPNOTSUPP;
> +
> + if (sysfs_streq(buf, "0"))
> + uuid_copy(&uuid, &uuid_null);
> + else {
> + rc = uuid_parse(buf, &uuid);
> + if (rc)
> + return rc;
> + }
> +
> + rc = down_write_killable(&dax_region_rwsem);
> + if (rc)
> + return rc;
> + if (!dax_region->dev->driver) {
> + rc = -ENXIO;
> + goto err_region;
> + }
> + rc = down_write_killable(&dax_dev_rwsem);
same comments about ACQUIRE()
> + if (rc)
> + goto err_region;
> +
Does it need to check if the device is already claimed before proceeding to
claiming? What happens if the uuid is written twice to this sysfs file?
DJ
> + if (uuid_is_null(&uuid))
> + rc = uuid_claim_untagged(dax_region, dev_dax);
> + else
> + rc = uuid_claim_tagged(dax_region, dev_dax, &uuid);
> +
> + up_write(&dax_dev_rwsem);
> +err_region:
> + up_write(&dax_region_rwsem);
> +
> + return rc < 0 ? rc : len;
> }
> static DEVICE_ATTR_RW(uuid);
>
> @@ -1614,8 +1862,12 @@ static umode_t dev_dax_visible(struct kobject *kobj,
> struct attribute *a, int n)
> return 0;
> if (a == &dev_attr_mapping.attr && is_dynamic(dax_region))
> return 0;
> - if ((a == &dev_attr_align.attr ||
> - a == &dev_attr_size.attr) && is_static(dax_region))
> + if (a == &dev_attr_uuid.attr && !is_dynamic(dax_region))
> + return 0444;
> + if (a == &dev_attr_align.attr &&
> + (is_static(dax_region) || is_dynamic(dax_region)))
> + return 0444;
> + if (a == &dev_attr_size.attr && is_static(dax_region))
> return 0444;
> return a->mode;
> }
