A tag uuid identifies one allocation across all regions and memdevs,
but nothing checks a new group's tag against the allocations already
live on the host: cxlr_add_extent() only compares it with the chain
group being assembled.  The orchestrator owns tag allocation and is
responsible for global uniqueness, but if a firmware bug or other issue
causes a repeated tag, the kernel should also reject it.

Add a host-wide list of live tag groups with non-null uuids.  Null uuids
are skipped because untagged extents are not associated with a single
logical allocation.

Check the list during tag group validation and return -EEXIST if the tag
is already live on the host via cxl_tag_already_committed().  New tags
are inserted to the list via cxl_tag_register(), which inserts atomically
under cxl_tag_lock.

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]>
---
 drivers/cxl/core/core.h   |  6 +++++
 drivers/cxl/core/extent.c | 56 +++++++++++++++++++++++++++++++++++++++
 drivers/cxl/core/mbox.c   | 16 +++++++++++
 drivers/cxl/cxl.h         |  3 +++
 4 files changed, 81 insertions(+)

diff --git a/drivers/cxl/core/core.h b/drivers/cxl/core/core.h
index 528eec2a1cc3..b7f8886db498 100644
--- a/drivers/cxl/core/core.h
+++ b/drivers/cxl/core/core.h
@@ -79,6 +79,7 @@ void kill_regions(struct cxl_root_decoder *cxlrd);
 
 int cxl_add_extent(struct cxl_memdev_state *mds, struct cxl_extent *extent,
                   u16 seq_num);
+bool cxl_tag_already_committed(const uuid_t *tag);
 int online_tag_group(struct cxl_dc_tag_group *group);
 bool rm_tag_group(struct cxl_dc_tag_group *group);
 void discard_tag_group(struct cxl_dc_tag_group *group);
@@ -117,6 +118,11 @@ static inline int cxl_dax_untagged_add(struct 
cxl_dax_region *cxlr_dax)
        return 0;
 }
 
+static inline bool cxl_tag_already_committed(const uuid_t *tag)
+{
+       return false;
+}
+
 static inline
 struct cxl_region *cxl_dpa_to_region(const struct cxl_memdev *cxlmd, u64 dpa,
                                     struct cxl_endpoint_decoder **cxled)
diff --git a/drivers/cxl/core/extent.c b/drivers/cxl/core/extent.c
index 334a97ab583d..4a59db823af4 100644
--- a/drivers/cxl/core/extent.c
+++ b/drivers/cxl/core/extent.c
@@ -6,6 +6,54 @@
 
 #include "core.h"
 
+/*
+ * Host-wide list of live tag groups with non-null uuids: a tag uuid
+ * identifies exactly one allocation across all regions and memdevs.
+ * The orchestrator owns tag allocation; this rejects a repeated tag
+ * from a firmware bug or other issue.  Untagged (null uuid) extents are
+ * not tracked: they are not associated with a single allocation.
+ */
+static DEFINE_MUTEX(cxl_tag_lock);
+static LIST_HEAD(cxl_tag_groups);
+
+static int cxl_tag_register(struct cxl_dc_tag_group *grp)
+{
+       struct cxl_dc_tag_group *g;
+
+       if (uuid_is_null(&grp->uuid))
+               return 0;
+
+       guard(mutex)(&cxl_tag_lock);
+       list_for_each_entry(g, &cxl_tag_groups, registry_node)
+               if (uuid_equal(&g->uuid, &grp->uuid))
+                       return -EBUSY;
+       list_add_tail(&grp->registry_node, &cxl_tag_groups);
+       return 0;
+}
+
+static void cxl_tag_unregister(struct cxl_dc_tag_group *grp)
+{
+       if (uuid_is_null(&grp->uuid))
+               return;
+
+       guard(mutex)(&cxl_tag_lock);
+       list_del(&grp->registry_node);
+}
+
+bool cxl_tag_already_committed(const uuid_t *tag)
+{
+       struct cxl_dc_tag_group *g;
+
+       if (uuid_is_null(tag))
+               return false;
+
+       guard(mutex)(&cxl_tag_lock);
+       list_for_each_entry(g, &cxl_tag_groups, registry_node)
+               if (uuid_equal(&g->uuid, tag))
+                       return true;
+       return false;
+}
+
 static struct cxl_dc_tag_group *to_dc_tag_group(struct device *dev)
 {
        return container_of(dev, struct cxl_dc_tag_group, dev);
@@ -15,6 +63,7 @@ static void dc_tag_group_release(struct device *dev)
 {
        struct cxl_dc_tag_group *group = to_dc_tag_group(dev);
 
+       cxl_tag_unregister(group);
        xa_destroy(&group->dc_extents);
        /* Drop the pin taken in alloc_tag_group(). */
        put_device(&group->cxlr_dax->dev);
@@ -93,12 +142,19 @@ static struct cxl_dc_tag_group *
 alloc_tag_group(struct cxl_dax_region *cxlr_dax, uuid_t *uuid)
 {
        struct cxl_dc_tag_group *group __free(kfree) = kzalloc_obj(*group);
+       int rc;
+
        if (!group)
                return ERR_PTR(-ENOMEM);
 
        group->cxlr_dax = cxlr_dax;
        uuid_copy(&group->uuid, uuid);
        xa_init(&group->dc_extents);
+       INIT_LIST_HEAD(&group->registry_node);
+
+       rc = cxl_tag_register(group);
+       if (rc)
+               return ERR_PTR(rc);
 
        /*
         * Pin cxlr_dax: it is used after cxl_rwsem.region is dropped, so a
diff --git a/drivers/cxl/core/mbox.c b/drivers/cxl/core/mbox.c
index a1d3e04a1e1b..0fa501f5800c 100644
--- a/drivers/cxl/core/mbox.c
+++ b/drivers/cxl/core/mbox.c
@@ -1640,6 +1640,22 @@ static int cxl_validate_group(struct cxl_memdev_state 
*mds, const uuid_t *tag,
        struct device *dev = mds->cxlds.dev;
        struct cxl_extent_list_node *pos;
 
+       /*
+        * Cross-More-chain uniqueness.  A non-null tag seen in this group must
+        * not already correspond to a committed tag group anywhere on this
+        * host.  More=0 was supposed to close that allocation, and tag uuids
+        * must be unique across all regions and memdevs (the orchestrator owns
+        * assignment per spec).  Either constraint failing — same chain
+        * redelivered, or two distinct allocations colliding on the same uuid —
+        * is a firmware/orchestrator bug; reject the whole group.
+        */
+       if (cxl_tag_already_committed(tag)) {
+               dev_warn_ratelimited(dev,
+                                    "Tag %pUb: dropping group, tag already 
committed (firmware/orchestrator bug)\n",
+                                    tag);
+               return -EEXIST;
+       }
+
        /* Sequence-number integrity */
        if (cxl_check_group_seq(dev, tag, group, shareable))
                return -EINVAL;
diff --git a/drivers/cxl/cxl.h b/drivers/cxl/cxl.h
index f7d7749d704c..79f5773f8f81 100644
--- a/drivers/cxl/cxl.h
+++ b/drivers/cxl/cxl.h
@@ -642,6 +642,8 @@ struct cxl_dax_region {
  *             allocations.
  * @nr_extents: live count of dc_extents in the group; the group is freed
  *             when the last dc_extent device is released.
+ * @registry_node: anchor in the host-wide non-null-tag registry that
+ *             enforces tag uuid uniqueness across all regions and memdevs.
  */
 struct cxl_dc_tag_group {
        struct device dev;
@@ -649,6 +651,7 @@ struct cxl_dc_tag_group {
        uuid_t uuid;
        struct xarray dc_extents;
        unsigned int nr_extents;
+       struct list_head registry_node;
 };
 
 bool is_dc_extent(struct device *dev);
-- 
2.43.0


Reply via email to