genirq/msi: Use lock guards for MSI descriptor locking

Provide a lock guard for MSI descriptor locking and update the core code
accordingly.

No functional change intended.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Link: https://lore.kernel.org/all/20250319105506.144672678@linutronix.de

diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
index bb7111105296ff4416c0875758a481eb510c9d7c..2f955716cf82fb5e090cd0555fd1482171754c99 100644 (file)
--- a/include/linux/irqdomain.h
+++ b/include/linux/irqdomain.h
@@ -281,6 +281,8 @@ static inline struct fwnode_handle *irq_domain_alloc_fwnode(phys_addr_t *pa)
 
 void irq_domain_free_fwnode(struct fwnode_handle *fwnode);
 
+DEFINE_FREE(irq_domain_free_fwnode, struct fwnode_handle *, if (_T) irq_domain_free_fwnode(_T))
+
 struct irq_domain_chip_generic_info;
 
 /**

diff --git a/include/linux/msi.h b/include/linux/msi.h
index 86e42742fd0fb7f98b109bee74d320e564b8b1f3..4e439916dbcf9bacbe9749a8d0c00d7a82f5f870 100644 (file)
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -232,6 +232,9 @@ int msi_setup_device_data(struct device *dev);
 void msi_lock_descs(struct device *dev);
 void msi_unlock_descs(struct device *dev);
 
+DEFINE_LOCK_GUARD_1(msi_descs_lock, struct device, msi_lock_descs(_T->lock),
+                   msi_unlock_descs(_T->lock));
+
 struct msi_desc *msi_domain_first_desc(struct device *dev, unsigned int domid,
                                       enum msi_desc_filter filter);
 

diff --git a/kernel/irq/msi.c b/kernel/irq/msi.c
index 5c8d43cdb0a318d7daf887ac339979cbec135bc3..5747d207878278f822a85d354f084eb4f0658ae8 100644 (file)
--- a/kernel/irq/msi.c
+++ b/kernel/irq/msi.c
@@ -448,7 +448,6 @@ EXPORT_SYMBOL_GPL(msi_next_desc);
 unsigned int msi_domain_get_virq(struct device *dev, unsigned int domid, unsigned int index)
 {
        struct msi_desc *desc;
-       unsigned int ret = 0;
        bool pcimsi = false;
        struct xarray *xa;
 
@@ -462,7 +461,7 @@ unsigned int msi_domain_get_virq(struct device *dev, unsigned int domid, unsigne
        if (dev_is_pci(dev) && domid == MSI_DEFAULT_DOMAIN)
                pcimsi = to_pci_dev(dev)->msi_enabled;
 
-       msi_lock_descs(dev);
+       guard(msi_descs_lock)(dev);
        xa = &dev->msi.data->__domains[domid].store;
        desc = xa_load(xa, pcimsi ? 0 : index);
        if (desc && desc->irq) {
@@ -471,16 +470,12 @@ unsigned int msi_domain_get_virq(struct device *dev, unsigned int domid, unsigne
                 * PCI-MSIX and platform MSI use a descriptor per
                 * interrupt.
                 */
-               if (pcimsi) {
-                       if (index < desc->nvec_used)
-                               ret = desc->irq + index;
-               } else {
-                       ret = desc->irq;
-               }
+               if (!pcimsi)
+                       return desc->irq;
+               if (index < desc->nvec_used)
+                       return desc->irq + index;
        }
-
-       msi_unlock_descs(dev);
-       return ret;
+       return 0;
 }
 EXPORT_SYMBOL_GPL(msi_domain_get_virq);
 
@@ -998,9 +993,8 @@ bool msi_create_device_irq_domain(struct device *dev, unsigned int domid,
                                  void *chip_data)
 {
        struct irq_domain *domain, *parent = dev->msi.domain;
-       struct fwnode_handle *fwnode, *fwnalloced = NULL;
-       struct msi_domain_template *bundle;
        const struct msi_parent_ops *pops;
+       struct fwnode_handle *fwnode;
 
        if (!irq_domain_is_msi_parent(parent))
                return false;
@@ -1008,7 +1002,8 @@ bool msi_create_device_irq_domain(struct device *dev, unsigned int domid,
        if (domid >= MSI_MAX_DEVICE_IRQDOMAINS)
                return false;
 
-       bundle = kmemdup(template, sizeof(*bundle), GFP_KERNEL);
+       struct msi_domain_template *bundle __free(kfree) =
+               kmemdup(template, sizeof(*bundle), GFP_KERNEL);
        if (!bundle)
                return false;
 
@@ -1031,41 +1026,36 @@ bool msi_create_device_irq_domain(struct device *dev, unsigned int domid,
         * node as they are not guaranteed to have a fwnode. They are never
         * looked up and always handled in the context of the device.
         */
-       if (bundle->info.flags & MSI_FLAG_USE_DEV_FWNODE)
-               fwnode = dev->fwnode;
+       struct fwnode_handle *fwnode_alloced __free(irq_domain_free_fwnode) = NULL;
+
+       if (!(bundle->info.flags & MSI_FLAG_USE_DEV_FWNODE))
+               fwnode = fwnode_alloced = irq_domain_alloc_named_fwnode(bundle->name);
        else
-               fwnode = fwnalloced = irq_domain_alloc_named_fwnode(bundle->name);
+               fwnode = dev->fwnode;
 
        if (!fwnode)
-               goto free_bundle;
+               return false;
 
        if (msi_setup_device_data(dev))
-               goto free_fwnode;
-
-       msi_lock_descs(dev);
+               return false;
 
+       guard(msi_descs_lock)(dev);
        if (WARN_ON_ONCE(msi_get_device_domain(dev, domid)))
-               goto fail;
+               return false;
 
        if (!pops->init_dev_msi_info(dev, parent, parent, &bundle->info))
-               goto fail;
+               return false;
 
        domain = __msi_create_irq_domain(fwnode, &bundle->info, IRQ_DOMAIN_FLAG_MSI_DEVICE, parent);
        if (!domain)
-               goto fail;
+               return false;
 
+       /* @bundle and @fwnode_alloced are now in use. Prevent cleanup */
+       retain_and_null_ptr(bundle);
+       retain_and_null_ptr(fwnode_alloced);
        domain->dev = dev;
        dev->msi.data->__domains[domid].domain = domain;
-       msi_unlock_descs(dev);
        return true;
-
-fail:
-       msi_unlock_descs(dev);
-free_fwnode:
-       irq_domain_free_fwnode(fwnalloced);
-free_bundle:
-       kfree(bundle);
-       return false;
 }
 
 /**
@@ -1079,12 +1069,10 @@ void msi_remove_device_irq_domain(struct device *dev, unsigned int domid)
        struct msi_domain_info *info;
        struct irq_domain *domain;
 
-       msi_lock_descs(dev);
-
+       guard(msi_descs_lock)(dev);
        domain = msi_get_device_domain(dev, domid);
-
        if (!domain || !irq_domain_is_msi_device(domain))
-               goto unlock;
+               return;
 
        dev->msi.data->__domains[domid].domain = NULL;
        info = domain->host_data;
@@ -1093,9 +1081,6 @@ void msi_remove_device_irq_domain(struct device *dev, unsigned int domid)
        irq_domain_remove(domain);
        irq_domain_free_fwnode(fwnode);
        kfree(container_of(info, struct msi_domain_template, info));
-
-unlock:
-       msi_unlock_descs(dev);
 }
 
 /**
@@ -1111,16 +1096,14 @@ bool msi_match_device_irq_domain(struct device *dev, unsigned int domid,
 {
        struct msi_domain_info *info;
        struct irq_domain *domain;
-       bool ret = false;
 
-       msi_lock_descs(dev);
+       guard(msi_descs_lock)(dev);
        domain = msi_get_device_domain(dev, domid);
        if (domain && irq_domain_is_msi_device(domain)) {
                info = domain->host_data;
-               ret = info->bus_token == bus_token;
+               return info->bus_token == bus_token;
        }
-       msi_unlock_descs(dev);
-       return ret;
+       return false;
 }
 
 static int msi_domain_prepare_irqs(struct irq_domain *domain, struct device *dev,
@@ -1391,12 +1374,9 @@ int msi_domain_alloc_irqs_range_locked(struct device *dev, unsigned int domid,
 int msi_domain_alloc_irqs_range(struct device *dev, unsigned int domid,
                                unsigned int first, unsigned int last)
 {
-       int ret;
 
-       msi_lock_descs(dev);
-       ret = msi_domain_alloc_irqs_range_locked(dev, domid, first, last);
-       msi_unlock_descs(dev);
-       return ret;
+       guard(msi_descs_lock)(dev);
+       return msi_domain_alloc_irqs_range_locked(dev, domid, first, last);
 }
 EXPORT_SYMBOL_GPL(msi_domain_alloc_irqs_range);
 
@@ -1500,12 +1480,8 @@ struct msi_map msi_domain_alloc_irq_at(struct device *dev, unsigned int domid, u
                                       const struct irq_affinity_desc *affdesc,
                                       union msi_instance_cookie *icookie)
 {
-       struct msi_map map;
-
-       msi_lock_descs(dev);
-       map = __msi_domain_alloc_irq_at(dev, domid, index, affdesc, icookie);
-       msi_unlock_descs(dev);
-       return map;
+       guard(msi_descs_lock)(dev);
+       return __msi_domain_alloc_irq_at(dev, domid, index, affdesc, icookie);
 }
 
 /**
@@ -1542,13 +1518,11 @@ int msi_device_domain_alloc_wired(struct irq_domain *domain, unsigned int hwirq,
 
        icookie.value = ((u64)type << 32) | hwirq;
 
-       msi_lock_descs(dev);
+       guard(msi_descs_lock)(dev);
        if (WARN_ON_ONCE(msi_get_device_domain(dev, domid) != domain))
                map.index = -EINVAL;
        else
                map = __msi_domain_alloc_irq_at(dev, domid, MSI_ANY_INDEX, NULL, &icookie);
-       msi_unlock_descs(dev);
-
        return map.index >= 0 ? map.virq : map.index;
 }
 
@@ -1641,9 +1615,8 @@ void msi_domain_free_irqs_range_locked(struct device *dev, unsigned int domid,
 void msi_domain_free_irqs_range(struct device *dev, unsigned int domid,
                                unsigned int first, unsigned int last)
 {
-       msi_lock_descs(dev);
+       guard(msi_descs_lock)(dev);
        msi_domain_free_irqs_range_locked(dev, domid, first, last);
-       msi_unlock_descs(dev);
 }
 EXPORT_SYMBOL_GPL(msi_domain_free_irqs_all);
 
@@ -1673,9 +1646,8 @@ void msi_domain_free_irqs_all_locked(struct device *dev, unsigned int domid)
  */
 void msi_domain_free_irqs_all(struct device *dev, unsigned int domid)
 {
-       msi_lock_descs(dev);
+       guard(msi_descs_lock)(dev);
        msi_domain_free_irqs_all_locked(dev, domid);
-       msi_unlock_descs(dev);
 }
 
 /**
@@ -1694,12 +1666,11 @@ void msi_device_domain_free_wired(struct irq_domain *domain, unsigned int virq)
        if (WARN_ON_ONCE(!dev || !desc || domain->bus_token != DOMAIN_BUS_WIRED_TO_MSI))
                return;
 
-       msi_lock_descs(dev);
-       if (!WARN_ON_ONCE(msi_get_device_domain(dev, MSI_DEFAULT_DOMAIN) != domain)) {
-               msi_domain_free_irqs_range_locked(dev, MSI_DEFAULT_DOMAIN, desc->msi_index,
-                                                 desc->msi_index);
-       }
-       msi_unlock_descs(dev);
+       guard(msi_descs_lock)(dev);
+       if (WARN_ON_ONCE(msi_get_device_domain(dev, MSI_DEFAULT_DOMAIN) != domain))
+               return;
+       msi_domain_free_irqs_range_locked(dev, MSI_DEFAULT_DOMAIN, desc->msi_index,
+                                         desc->msi_index);
 }
 
 /**