genirq/msi, PCI/MSI: Spring cleaning - Part 3
v2 cover genirq/msi, PCI/MSI: Spring cleaning - Part 3
This is the third part of [PCI]MSI refactoring which aims to provide the ability of expanding MSI-X vectors after enabling MSI-X.
The first two parts of this work can be found here:
https://lore.kernel.org/r/[email protected] https://lore.kernel.org/r/[email protected]
This third part has the following important changes:
1) Add locking to protect the MSI descriptor storage
Right now the MSI descriptor storage (linked list) is not protected by anything under the assumption that the list is installed before use and destroyed after use. As this is about to change there has to be protection
2) A new set of iterators which allow filtering on the state of the descriptors namely whether a descriptor is associated to a Linux interrupt or not.
This cleans up a lot of use cases which have to do this filtering manually.
3) A new set of MSI descriptor allocation functions which make the usage sites simpler and confine the storage handling to the core code.
Trivial MSI descriptors (non PCI) are now allocated by the core code automatically when the underlying irq domain requests that.
4) Rework of sysfs handling to prepare for dynamic extension of MSI-X
The current mechanism which creates the directory and the attributes for all MSI descriptors in one go is obviously not suitable for dynamic extension. The rework splits the directory creation out and lets the MSI interrupt allocation create the per descriptor attributes.
5) Conversion of the MSI descriptor storage to xarray
The linked list based storage is suboptimal even without dynamic expansion as it requires full list walks to get to a specific descriptor. With dynamic expansion this gets even more convoluted. Xarray is way more suitable and simplifies the final goal of dynamic expansion of the MSI-X space.
This third series is based on:
git://git.kernel.org/pub/scm/linux/kernel/git/tglx/devel.git msi-v2-part-2
and also available from git:
git://git.kernel.org/pub/scm/linux/kernel/git/tglx/devel.git msi-v2-part-3
V1 of this series can be found here:
https://lore.kernel.org/r/[email protected]
Changes versus V1:
- Remove the allocation counter patch as it is not required
- Fix the powerpc fallout - Cedric
- Fix the CONFIG typo - Niklas
- Picked up Reviewed/Tested/Acked-by tags as appropriate
As a consequence of the discussion vs. the general direction of these patches, part 4 is not going to be updated in it's current form.
The assumption that MSI[X] and IMS are mutually exclusive and that IMS is basically an extension for finer grained splitup of the PCI device does not hold.
There is a plan to refactor the code further in order to provide the desired functionality of MSI[X]/IMS which will also gain the dynamic extension of MSI-X vectors:
https://lore.kernel.org/r/87o85v3znb.ffs@tglx
Thanks,
tglx
--- .clang-format | 1 arch/powerpc/platforms/4xx/hsta_msi.c | 7 arch/powerpc/platforms/cell/axon_msi.c | 7 arch/powerpc/platforms/pasemi/msi.c | 9 arch/powerpc/sysdev/fsl_msi.c | 8 arch/powerpc/sysdev/mpic_u3msi.c | 9 arch/s390/pci/pci_irq.c | 6 arch/x86/pci/xen.c | 14 drivers/base/core.c | 3 drivers/base/platform-msi.c | 110 ----- drivers/bus/fsl-mc/fsl-mc-msi.c | 61 -- drivers/ntb/msi.c | 19 drivers/pci/controller/pci-hyperv.c | 15 drivers/pci/msi/irqdomain.c | 11 drivers/pci/msi/legacy.c | 20 drivers/pci/msi/msi.c | 258 ++++++------ drivers/pci/xen-pcifront.c | 2 drivers/soc/ti/ti_sci_inta_msi.c | 77 +-- include/linux/device.h | 4 include/linux/msi.h | 107 +++-- include/linux/soc/ti/ti_sci_inta_msi.h | 1 kernel/irq/msi.c | 700 ++++++++++++++++++++++----------- 22 files changed, 794 insertions(+), 655 deletions(-)
PATCH v2 1/31 genirq/msi: Move descriptor list to struct msi_device_data
It's only required when MSI is in use.
--- drivers/base/core.c | 3 --- include/linux/device.h | 4 ---- include/linux/msi.h | 4 +++- kernel/irq/msi.c | 5 ++++- 4 files changed, 7 insertions(+), 9 deletions(-)
drivers/base/core.c +0 -3
@@ -2874,9 +2874,6 @@ void device_initialize(struct device *deINIT_LIST_HEAD (&dev->devres_head);device_pm_init (dev);set_dev_node (dev,NUMA_NO_NODE ); -#ifdef CONFIG_GENERIC_MSI_IRQ -INIT_LIST_HEAD (&dev->msi_list); -#endif INIT_LIST_HEAD (&dev->links.consumers);INIT_LIST_HEAD (&dev->links.suppliers);INIT_LIST_HEAD (&dev->links.defer_sync);
include/linux/device.h +0 -4
@@ -423,7 +423,6 @@ struct dev_msi_info {* @pins: For device pin management. * See Documentation/driver-api/pin-control.rst for details. * @msi: MSI related data -* @msi_list: Hosts MSI descriptors * @numa_node: NUMA node this device is close to. * @dma_ops: DMA mapping operations for this device. * @dma_mask: Dma mask (if dma'ble device).
@@ -519,9 +518,6 @@ struct device {struct dev_pin_info *pins;#endif struct dev_msi_info msi; -#ifdef CONFIG_GENERIC_MSI_IRQ -struct list_head msi_list; -#endif #ifdef CONFIG_DMA_OPS const struct dma_map_ops *dma_ops;#endif
include/linux/msi.h +3 -1
@@ -145,11 +145,13 @@ struct msi_desc {* @properties: MSI properties which are interesting to drivers * @attrs: Pointer to the sysfs attribute group * @platform_data: Platform-MSI specific data +* @list: List of MSI descriptors associated to the device */ struct msi_device_data {unsigned long properties;const struct attribute_group **attrs;struct platform_msi_priv_data *platform_data; +struct list_head list; };int msi_setup_device_data (struct device *dev);
@@ -174,7 +176,7 @@ unsigned int msi_get_virq(struct device/* Helpers to hide struct msi_desc implementation details */ #define msi_desc_to_dev (desc) ((desc)->dev) -#define dev_to_msi_list (dev) (&(dev)->msi_list) +#define dev_to_msi_list (dev) (&(dev)->msi.data->list)#define first_msi_entry (dev) \ list_first_entry(dev_to_msi_list((dev)), struct msi_desc, list)#define for_each_msi_entry (desc, dev) \
kernel/irq/msi.c +4 -1
@@ -99,7 +99,9 @@ EXPORT_SYMBOL_GPL(get_cached_msi_msg);static void msi_device_data_release (struct device *dev,void *res) { -WARN_ON_ONCE (!list_empty (&dev->msi_list)); +struct msi_device_data *md = res; + +WARN_ON_ONCE (!list_empty (&md->list)); dev->msi.data =NULL ; }
@@ -124,6 +126,7 @@ int msi_setup_device_data(struct deviceif (!md)return -ENOMEM ; +INIT_LIST_HEAD (&md->list); dev->msi.data = md;devres_add (dev, md);return 0 ;
[tip: irq/msi] genirq/msi: Move descriptor list to struct msi_device_data
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 125282cd4f33ecd53a24ae4807409da0e5e90fd4 Gitweb: https://git.kernel.org/tip/125282cd4f33ecd53a24ae4807409da0e5e90fd4 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:04 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:16 +01:00
genirq/msi: Move descriptor list to struct msi_device_data
It's only required when MSI is in use.
--- drivers/base/core.c | 3 --- include/linux/device.h | 4 ---- include/linux/msi.h | 4 +++- kernel/irq/msi.c | 5 ++++- 4 files changed, 7 insertions(+), 9 deletions(-)
drivers/base/core.c +0 -3
@@ -2874,9 +2874,6 @@ void device_initialize(struct device *dev)INIT_LIST_HEAD (&dev->devres_head);device_pm_init (dev);set_dev_node (dev,NUMA_NO_NODE ); -#ifdef CONFIG_GENERIC_MSI_IRQ -INIT_LIST_HEAD (&dev->msi_list); -#endif INIT_LIST_HEAD (&dev->links.consumers);INIT_LIST_HEAD (&dev->links.suppliers);INIT_LIST_HEAD (&dev->links.defer_sync);
include/linux/device.h +0 -4
@@ -423,7 +423,6 @@ struct dev_msi_info {* @pins: For device pin management. * See Documentation/driver-api/pin-control.rst for details. * @msi: MSI related data -* @msi_list: Hosts MSI descriptors * @numa_node: NUMA node this device is close to. * @dma_ops: DMA mapping operations for this device. * @dma_mask: Dma mask (if dma'ble device).
@@ -519,9 +518,6 @@ struct device {struct dev_pin_info *pins;#endif struct dev_msi_info msi; -#ifdef CONFIG_GENERIC_MSI_IRQ -struct list_head msi_list; -#endif #ifdef CONFIG_DMA_OPS const struct dma_map_ops *dma_ops;#endif
include/linux/msi.h +3 -1
@@ -144,11 +144,13 @@ struct msi_desc {* @properties: MSI properties which are interesting to drivers * @attrs: Pointer to the sysfs attribute group * @platform_data: Platform-MSI specific data +* @list: List of MSI descriptors associated to the device */ struct msi_device_data {unsigned long properties;const struct attribute_group **attrs;struct platform_msi_priv_data *platform_data; +struct list_head list; };int msi_setup_device_data (struct device *dev);
@@ -157,7 +159,7 @@ unsigned int msi_get_virq(struct device *dev, unsigned int index);/* Helpers to hide struct msi_desc implementation details */ #define msi_desc_to_dev (desc) ((desc)->dev) -#define dev_to_msi_list (dev) (&(dev)->msi_list) +#define dev_to_msi_list (dev) (&(dev)->msi.data->list)#define first_msi_entry (dev) \ list_first_entry(dev_to_msi_list((dev)), struct msi_desc, list)#define for_each_msi_entry (desc, dev) \
kernel/irq/msi.c +4 -1
@@ -75,7 +75,9 @@ EXPORT_SYMBOL_GPL(get_cached_msi_msg);static void msi_device_data_release (struct device *dev,void *res) { -WARN_ON_ONCE (!list_empty (&dev->msi_list)); +struct msi_device_data *md = res; + +WARN_ON_ONCE (!list_empty (&md->list)); dev->msi.data =NULL ; }
@@ -100,6 +102,7 @@ int msi_setup_device_data(struct device *dev)if (!md)return -ENOMEM ; +INIT_LIST_HEAD (&md->list); dev->msi.data = md;devres_add (dev, md);return 0 ;
PATCH v2 2/31 genirq/msi: Add mutex for MSI list protection
In reply to Thomas GleixnerFor upcoming runtime extensions of MSI-X interrupts it's required to protect the MSI descriptor list. Add a mutex to struct msi_device_data and provide lock/unlock functions.
--- include/linux/msi.h | 5 +++++ kernel/irq/msi.c | 25 +++++++++++++++++++++++++ 2 files changed, 30 insertions(+)
include/linux/msi.h +5 -0
@@ -3,6 +3,7 @@#define LINUX_MSI_H #include <linux/cpumask.h> +#include <linux/mutex.h> #include <linux/list.h> #include <linux/bits.h> #include <asm/msi.h>
@@ -146,12 +147,14 @@ struct msi_desc {* @attrs: Pointer to the sysfs attribute group * @platform_data: Platform-MSI specific data * @list: List of MSI descriptors associated to the device +* @mutex: Mutex protecting the MSI list */ struct msi_device_data {unsigned long properties;const struct attribute_group **attrs;struct platform_msi_priv_data *platform_data;struct list_head list; +struct mutex mutex; };int msi_setup_device_data (struct device *dev);
@@ -173,6 +176,8 @@ static inline void msi_device_set_proper#endif unsigned int msi_get_virq (struct device *dev,unsigned int index); +void msi_lock_descs (struct device *dev); +void msi_unlock_descs (struct device *dev);/* Helpers to hide struct msi_desc implementation details */ #define msi_desc_to_dev (desc) ((desc)->dev)
kernel/irq/msi.c +25 -0
@@ -127,12 +127,37 @@ int msi_setup_device_data(struct devicereturn -ENOMEM ;INIT_LIST_HEAD (&md->list); +mutex_init (&md->mutex); dev->msi.data = md;devres_add (dev, md);return 0 ; }/** +* msi_lock_descs - Lock the MSI descriptor storage of a device +* @dev: Device to operate on +*/ +void msi_lock_descs (struct device *dev) +{ +if (WARN_ON_ONCE (!dev->msi.data)) +return ; +mutex_lock (&dev->msi.data->mutex); +} +EXPORT_SYMBOL_GPL (msi_lock_descs); + +/** +* msi_unlock_descs - Unlock the MSI descriptor storage of a device +* @dev: Device to operate on +*/ +void msi_unlock_descs (struct device *dev) +{ +if (WARN_ON_ONCE (!dev->msi.data)) +return ; +mutex_unlock (&dev->msi.data->mutex); +} +EXPORT_SYMBOL_GPL (msi_unlock_descs); + +/** * msi_get_virq - Return Linux interrupt number of a MSI interrupt * @dev: Device to operate on * @index: MSI interrupt index to look for (0-based)
Re: [patch V2 02/31] genirq/msi: Add mutex for MSI list protection
Quoted 9 lines · Thomas Gleixner
+++
b/kernel/irq/msi.ckernel/irq/msi.c +1
-0@@ -127,12 +127,37 @@ int msi_setup_device_data(struct devicereturn -ENOMEM ;INIT_LIST_HEAD (&md->list); +mutex_init (&md->mutex); dev->msi.data = md;devres_add (dev, md);return 0 ;
kernel/irq/msi.c int msi_setup_device_data(struct device · line 143
Quoted 10 lines
kernel/irq/msi.c +7
-0}/** +* msi_lock_descs - Lock the MSI descriptor storage of a device +* @dev: Device to operate on +*/ +void msi_lock_descs (struct device *dev) +{ +if (WARN_ON_ONCE (!dev->msi.data)) +return ;
Is this useful? Other places that call msi_lock_descs will continue on and deref null dev->msi anyhow - is the dump from the WARN_ON that much better than the oops from the null deref here:
kernel/irq/msi.c int msi_setup_device_data(struct device · line 144
Quoted 1 line
kernel/irq/msi.c +1
-0+mutex_lock (&dev->msi.data->mutex);
?
Honestly, still a bit unclear on what the community consensus is for using WARN_ON.
Jason
Re: [patch V2 02/31] genirq/msi: Add mutex for MSI list protection
Quoted 25 lines · Jason Gunthorpe
Quoted 9 lines · Thomas Gleixner
+++
b/kernel/irq/msi.ckernel/irq/msi.c +1
-0@@ -127,12 +127,37 @@ int msi_setup_device_data(struct devicereturn -ENOMEM ;INIT_LIST_HEAD (&md->list); +mutex_init (&md->mutex); dev->msi.data = md;devres_add (dev, md);return 0 ;kernel/irq/msi.c int msi_setup_device_data(struct device · line 143
Quoted 10 lines
kernel/irq/msi.c +7
-0}/** +* msi_lock_descs - Lock the MSI descriptor storage of a device +* @dev: Device to operate on +*/ +void msi_lock_descs (struct device *dev) +{ +if (WARN_ON_ONCE (!dev->msi.data)) +return ;Is this useful? Other places that call
msi_lock_descswill continue on and deref nulldev->msianyhow - is the dump from theWARN_ONthat much better than the oops from the null deref here:
Quoted 1 line
kernel/irq/msi.c int msi_setup_device_data(struct device · line 144
Quoted 1 line
kernel/irq/msi.c +1
-0+mutex_lock (&dev->msi.data->mutex);
I put it there for paranoia reasons and forgot to revist it later. In that case yes, it's of questionable value.
Thanks,
tglx
[tip: irq/msi] genirq/msi: Add mutex for MSI list protection
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: b5f687f97d1e112493fe0447a1fb09fbd93c334b Gitweb: https://git.kernel.org/tip/b5f687f97d1e112493fe0447a1fb09fbd93c334b Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:05 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:17 +01:00
genirq/msi: Add mutex for MSI list protection
For upcoming runtime extensions of MSI-X interrupts it's required to protect the MSI descriptor list. Add a mutex to struct msi_device_data and provide lock/unlock functions.
--- include/linux/msi.h | 5 +++++ kernel/irq/msi.c | 21 +++++++++++++++++++++ 2 files changed, 26 insertions(+)
include/linux/msi.h +5 -0
@@ -3,6 +3,7 @@#define LINUX_MSI_H #include <linux/cpumask.h> +#include <linux/mutex.h> #include <linux/list.h> #include <asm/msi.h>
@@ -145,17 +146,21 @@ struct msi_desc {* @attrs: Pointer to the sysfs attribute group * @platform_data: Platform-MSI specific data * @list: List of MSI descriptors associated to the device +* @mutex: Mutex protecting the MSI list */ struct msi_device_data {unsigned long properties;const struct attribute_group **attrs;struct platform_msi_priv_data *platform_data;struct list_head list; +struct mutex mutex; };int msi_setup_device_data (struct device *dev);unsigned int msi_get_virq (struct device *dev,unsigned int index); +void msi_lock_descs (struct device *dev); +void msi_unlock_descs (struct device *dev);/* Helpers to hide struct msi_desc implementation details */ #define msi_desc_to_dev (desc) ((desc)->dev)
kernel/irq/msi.c +21 -0
@@ -103,12 +103,33 @@ int msi_setup_device_data(struct device *dev)return -ENOMEM ;INIT_LIST_HEAD (&md->list); +mutex_init (&md->mutex); dev->msi.data = md;devres_add (dev, md);return 0 ; }/** +* msi_lock_descs - Lock the MSI descriptor storage of a device +* @dev: Device to operate on +*/ +void msi_lock_descs (struct device *dev) +{ +mutex_lock (&dev->msi.data->mutex); +} +EXPORT_SYMBOL_GPL (msi_lock_descs); + +/** +* msi_unlock_descs - Unlock the MSI descriptor storage of a device +* @dev: Device to operate on +*/ +void msi_unlock_descs (struct device *dev) +{ +mutex_unlock (&dev->msi.data->mutex); +} +EXPORT_SYMBOL_GPL (msi_unlock_descs); + +/** * msi_get_virq - Return Linux interrupt number of a MSI interrupt * @dev: Device to operate on * @index: MSI interrupt index to look for (0-based)
PATCH v2 3/31 genirq/msi: Provide msi_domain_alloc/free_irqs_descs_locked()
In reply to Thomas GleixnerUsage sites which do allocations of the MSI descriptors before invoking msi_domain_alloc_irqs() require to lock the MSI decriptors accross the operation.
Provide entry points which can be called with the MSI mutex held and lock the mutex in the existing entry points.
--- include/linux/msi.h | 3 ++ kernel/irq/msi.c | 74 ++++++++++++++++++++++++++++++++++++++++------------ 2 files changed, 61 insertions(+), 16 deletions(-)
include/linux/msi.h +3 -0
@@ -399,9 +399,12 @@ struct irq_domain *msi_create_irq_domain struct irq_domain *parent);int __msi_domain_alloc_irqs (struct irq_domain *domain,struct device *dev,int nvec); +int msi_domain_alloc_irqs_descs_locked (struct irq_domain *domain,struct device *dev, +int nvec);int msi_domain_alloc_irqs (struct irq_domain *domain,struct device *dev,int nvec);void __msi_domain_free_irqs (struct irq_domain *domain,struct device *dev); +void msi_domain_free_irqs_descs_locked (struct irq_domain *domain,struct device *dev);void msi_domain_free_irqs (struct irq_domain *domain,struct device *dev);struct msi_domain_info *msi_get_domain_info (struct irq_domain *domain);
kernel/irq/msi.c +58 -16
135 lines not on this page · raw message
[tip: irq/msi] genirq/msi: Provide msi_domain_alloc/free_irqs_descs_locked()
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 0f62d941acf9ac3b6025692ce649b1f282b89e7f Gitweb: https://git.kernel.org/tip/0f62d941acf9ac3b6025692ce649b1f282b89e7f Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:07 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:17 +01:00
genirq/msi: Provide msi_domain_alloc/free_irqs_descs_locked()
Usage sites which do allocations of the MSI descriptors before invoking msi_domain_alloc_irqs() require to lock the MSI decriptors accross the operation.
Provide entry points which can be called with the MSI mutex held and lock the mutex in the existing entry points.
--- include/linux/msi.h | 3 ++- kernel/irq/msi.c | 74 ++++++++++++++++++++++++++++++++++---------- 2 files changed, 61 insertions(+), 16 deletions(-)
include/linux/msi.h +3 -0
@@ -383,9 +383,12 @@ struct irq_domain *msi_create_irq_domain(struct fwnode_handle *fwnode, struct irq_domain *parent);int __msi_domain_alloc_irqs (struct irq_domain *domain,struct device *dev,int nvec); +int msi_domain_alloc_irqs_descs_locked (struct irq_domain *domain,struct device *dev, +int nvec);int msi_domain_alloc_irqs (struct irq_domain *domain,struct device *dev,int nvec);void __msi_domain_free_irqs (struct irq_domain *domain,struct device *dev); +void msi_domain_free_irqs_descs_locked (struct irq_domain *domain,struct device *dev);void msi_domain_free_irqs (struct irq_domain *domain,struct device *dev);struct msi_domain_info *msi_get_domain_info (struct irq_domain *domain);
kernel/irq/msi.c +58 -16
135 lines not on this page · raw message
PATCH v2 4/31 genirq/msi: Provide a set of advanced MSI accessors and iterators
In reply to Thomas GleixnerIn preparation for dynamic handling of MSI-X interrupts provide a new set of MSI descriptor accessor functions and iterators. They are benefitial per se as they allow to cleanup quite some code in various MSI domain implementations.
--- include/linux/msi.h | 33 +++++++++++++++++ kernel/irq/msi.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 129 insertions(+)
include/linux/msi.h +33 -0
@@ -141,6 +141,18 @@ struct msi_desc {struct pci_msi_desc pci; }; +/* +* Filter values for the MSI descriptor iterators and accessor functions. +*/ +enum msi_desc_filter { +/* All descriptors */ +MSI_DESC_ALL , +/* Descriptors which have no interrupt associated */ +MSI_DESC_NOTASSOCIATED , +/* Descriptors which have an interrupt associated */ +MSI_DESC_ASSOCIATED , +}; +/** * msi_device_data - MSI per device data * @properties: MSI properties which are interesting to drivers
@@ -148,6 +160,7 @@ struct msi_desc {* @platform_data: Platform-MSI specific data * @list: List of MSI descriptors associated to the device * @mutex: Mutex protecting the MSI list +* @__next: Cached pointer to the next entry for iterators */ struct msi_device_data {unsigned long properties;
@@ -155,6 +168,7 @@ struct msi_device_data {struct platform_msi_priv_data *platform_data;struct list_head list;struct mutex mutex; +struct msi_desc *__next; };int msi_setup_device_data (struct device *dev);
@@ -177,6 +191,25 @@ unsigned int msi_get_virq(struct devicevoid msi_lock_descs (struct device *dev);void msi_unlock_descs (struct device *dev); +struct msi_desc *msi_first_desc (struct device *dev,enum msi_desc_filter filter); +struct msi_desc *msi_next_desc (struct device *dev,enum msi_desc_filter filter); + +/** +* msi_for_each_desc - Iterate the MSI descriptors +* +* @desc: struct msi_desc pointer used as iterator +* @dev: struct device pointer - device to iterate +* @filter: Filter for descriptor selection +* +* Notes: +* - The loop must be protected with a msi_lock_descs()/msi_unlock_descs() +* pair. +* - It is safe to remove a retrieved MSI descriptor in the loop. +*/ +#define msi_for_each_desc (desc, dev, filter) \ + for ((desc) = msi_first_desc((dev), (filter)); (desc); \ + (desc) = msi_next_desc((dev), (filter))) +/* Helpers to hide struct msi_desc implementation details */ #define msi_desc_to_dev (desc) ((desc)->dev)#define dev_to_msi_list (dev) (&(dev)->msi.data->list)
kernel/irq/msi.c +96 -0
106 lines not on this page · raw message
[tip: irq/msi] genirq/msi: Provide a set of advanced MSI accessors and iterators
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 1046f71d7268b1680d7b044dea83c664403f6302 Gitweb: https://git.kernel.org/tip/1046f71d7268b1680d7b044dea83c664403f6302 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:08 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:17 +01:00
genirq/msi: Provide a set of advanced MSI accessors and iterators
In preparation for dynamic handling of MSI-X interrupts provide a new set of MSI descriptor accessor functions and iterators. They are benefitial per se as they allow to cleanup quite some code in various MSI domain implementations.
--- include/linux/msi.h | 33 +++++++++++++++- kernel/irq/msi.c | 96 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 129 insertions(+)
include/linux/msi.h +33 -0
@@ -140,6 +140,18 @@ struct msi_desc {struct pci_msi_desc pci; }; +/* +* Filter values for the MSI descriptor iterators and accessor functions. +*/ +enum msi_desc_filter { +/* All descriptors */ +MSI_DESC_ALL , +/* Descriptors which have no interrupt associated */ +MSI_DESC_NOTASSOCIATED , +/* Descriptors which have an interrupt associated */ +MSI_DESC_ASSOCIATED , +}; +/** * msi_device_data - MSI per device data * @properties: MSI properties which are interesting to drivers
@@ -147,6 +159,7 @@ struct msi_desc {* @platform_data: Platform-MSI specific data * @list: List of MSI descriptors associated to the device * @mutex: Mutex protecting the MSI list +* @__next: Cached pointer to the next entry for iterators */ struct msi_device_data {unsigned long properties;
@@ -154,6 +167,7 @@ struct msi_device_data {struct platform_msi_priv_data *platform_data;struct list_head list;struct mutex mutex; +struct msi_desc *__next; };int msi_setup_device_data (struct device *dev);
@@ -162,6 +176,25 @@ unsigned int msi_get_virq(struct device *dev, unsigned int index);void msi_lock_descs (struct device *dev);void msi_unlock_descs (struct device *dev); +struct msi_desc *msi_first_desc (struct device *dev,enum msi_desc_filter filter); +struct msi_desc *msi_next_desc (struct device *dev,enum msi_desc_filter filter); + +/** +* msi_for_each_desc - Iterate the MSI descriptors +* +* @desc: struct msi_desc pointer used as iterator +* @dev: struct device pointer - device to iterate +* @filter: Filter for descriptor selection +* +* Notes: +* - The loop must be protected with a msi_lock_descs()/msi_unlock_descs() +* pair. +* - It is safe to remove a retrieved MSI descriptor in the loop. +*/ +#define msi_for_each_desc (desc, dev, filter) \ + for ((desc) = msi_first_desc((dev), (filter)); (desc); \ + (desc) = msi_next_desc((dev), (filter))) +/* Helpers to hide struct msi_desc implementation details */ #define msi_desc_to_dev (desc) ((desc)->dev)#define dev_to_msi_list (dev) (&(dev)->msi.data->list)
kernel/irq/msi.c +96 -0
106 lines not on this page · raw message
PATCH v2 5/31 genirq/msi: Provide msi_alloc_msi_desc() and a simple allocator
In reply to Thomas GleixnerProvide msi_alloc_msi_desc() which takes a template MSI descriptor for initializing a newly allocated descriptor. This allows to simplify various usage sites of alloc_msi_entry() and moves the storage handling into the core code.
For simple cases where only a linear vector space is required provide msi_add_simple_msi_descs() which just allocates a linear range of MSI descriptors and fills msi_desc::msi_index accordingly.
--- include/linux/msi.h | 2 + kernel/irq/msi.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+)
include/linux/msi.h +2 -0
@@ -264,6 +264,8 @@ static inline void pci_write_msi_msg(uns }#endif /* CONFIG_PCI_MSI */ +int msi_add_msi_desc (struct device *dev,struct msi_desc *init_desc); +struct msi_desc *alloc_msi_entry (struct device *dev,int nvec,const struct irq_affinity_desc *affinity);void free_msi_entry (struct msi_desc *entry);
kernel/irq/msi.c +59 -0
65 lines not on this page · raw message
[tip: irq/msi] genirq/msi: Provide msi_alloc_msi_desc() and a simple allocator
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 602905253607ba892336f7bba8bb45b5be819d87 Gitweb: https://git.kernel.org/tip/602905253607ba892336f7bba8bb45b5be819d87 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:10 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:17 +01:00
genirq/msi: Provide msi_alloc_msi_desc() and a simple allocator
Provide msi_alloc_msi_desc() which takes a template MSI descriptor for initializing a newly allocated descriptor. This allows to simplify various usage sites of alloc_msi_entry() and moves the storage handling into the core code.
For simple cases where only a linear vector space is required provide msi_add_simple_msi_descs() which just allocates a linear range of MSI descriptors and fills msi_desc::msi_index accordingly.
--- include/linux/msi.h | 2 +- kernel/irq/msi.c | 59 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 61 insertions(+)
include/linux/msi.h +2 -0
@@ -247,6 +247,8 @@ static inline void pci_write_msi_msg(unsigned int irq, struct msi_msg *msg) }#endif /* CONFIG_PCI_MSI */ +int msi_add_msi_desc (struct device *dev,struct msi_desc *init_desc); +struct msi_desc *alloc_msi_entry (struct device *dev,int nvec,const struct irq_affinity_desc *affinity);void free_msi_entry (struct msi_desc *entry);
kernel/irq/msi.c +59 -0
65 lines not on this page · raw message
PATCH v2 6/31 genirq/msi: Provide domain flags to allocate/free MSI descriptors automatically
In reply to Thomas GleixnerProvide domain info flags which tell the core to allocate simple descriptors or to free descriptors when the interrupts are freed and implement the required functionality.
--- include/linux/msi.h | 17 +++++++++++++++++ kernel/irq/msi.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+)
include/linux/msi.h +17 -0
@@ -106,6 +106,8 @@ struct pci_msi_desc { }; }; +#define MSI_MAX_INDEX ((unsigned int)USHRT_MAX) +/** * struct msi_desc - Descriptor structure for MSI based interrupts * @list: List head for management
@@ -264,6 +266,17 @@ static inline void pci_write_msi_msg(uns#endif /* CONFIG_PCI_MSI */ int msi_add_msi_desc (struct device *dev,struct msi_desc *init_desc); +void msi_free_msi_descs_range (struct device *dev,enum msi_desc_filter filter, +unsigned int first_index,unsigned int last_index); + +/** +* msi_free_msi_descs - Free MSI descriptors of a device +* @dev: Device to free the descriptors +*/ +static inline void msi_free_msi_descs (struct device *dev) +{ +msi_free_msi_descs_range (dev,MSI_DESC_ALL ,0 ,MSI_MAX_INDEX ); +}struct msi_desc *alloc_msi_entry (struct device *dev,int nvec,const struct irq_affinity_desc *affinity);
@@ -424,6 +437,10 @@ enum {MSI_FLAG_DEV_SYSFS = (1 <<7 ),/* MSI-X entries must be contiguous */ MSI_FLAG_MSIX_CONTIGUOUS = (1 <<8 ), +/* Allocate simple MSI descriptors */ +MSI_FLAG_ALLOC_SIMPLE_MSI_DESCS = (1 <<9 ), +/* Free MSI descriptors */ + MSI_FLAG_FREE_MSI_DESCS = (1 << 10), }; int msi_domain_set_affinity(struct irq_data *data, const struct cpumask *mask,
kernel/irq/msi.c +48 -0
78 lines not on this page · raw message
[tip: irq/msi] genirq/msi: Provide domain flags to allocate/free MSI descriptors automatically
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 645474e2cee450131e8b8d8a69a5d9bbabd43f3f Gitweb: https://git.kernel.org/tip/645474e2cee450131e8b8d8a69a5d9bbabd43f3f Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:12 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:17 +01:00
genirq/msi: Provide domain flags to allocate/free MSI descriptors automatically
Provide domain info flags which tell the core to allocate simple descriptors or to free descriptors when the interrupts are freed and implement the required functionality.
--- include/linux/msi.h | 17 ++++++++++++++++- kernel/irq/msi.c | 48 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 65 insertions(+)
include/linux/msi.h +17 -0
@@ -105,6 +105,8 @@ struct pci_msi_desc { }; }; +#define MSI_MAX_INDEX ((unsigned int)USHRT_MAX) +/** * struct msi_desc - Descriptor structure for MSI based interrupts * @list: List head for management
@@ -248,6 +250,17 @@ static inline void pci_write_msi_msg(unsigned int irq, struct msi_msg *msg)#endif /* CONFIG_PCI_MSI */ int msi_add_msi_desc (struct device *dev,struct msi_desc *init_desc); +void msi_free_msi_descs_range (struct device *dev,enum msi_desc_filter filter, +unsigned int first_index,unsigned int last_index); + +/** +* msi_free_msi_descs - Free MSI descriptors of a device +* @dev: Device to free the descriptors +*/ +static inline void msi_free_msi_descs (struct device *dev) +{ +msi_free_msi_descs_range (dev,MSI_DESC_ALL ,0 ,MSI_MAX_INDEX ); +}struct msi_desc *alloc_msi_entry (struct device *dev,int nvec,const struct irq_affinity_desc *affinity);
@@ -408,6 +421,10 @@ enum {MSI_FLAG_DEV_SYSFS = (1 <<7 ),/* MSI-X entries must be contiguous */ MSI_FLAG_MSIX_CONTIGUOUS = (1 <<8 ), +/* Allocate simple MSI descriptors */ +MSI_FLAG_ALLOC_SIMPLE_MSI_DESCS = (1 <<9 ), +/* Free MSI descriptors */ + MSI_FLAG_FREE_MSI_DESCS = (1 << 10), }; int msi_domain_set_affinity(struct irq_data *data, const struct cpumask *mask,
kernel/irq/msi.c +48 -0
78 lines not on this page · raw message
PATCH v2 7/31 PCI/MSI: Protect MSI operations
In reply to Thomas GleixnerTo prepare for dynamic extension of MSI-X vectors, protect the MSI operations for MSI and MSI-X. This requires to move the invocation of irq_create_affinity_masks() out of the descriptor lock section to avoid reverse lock ordering vs. CPU hotplug lock as some callers of the PCI/MSI allocation interfaces already hold it.
--- drivers/pci/msi/irqdomain.c | 4 - drivers/pci/msi/msi.c | 120 ++++++++++++++++++++++++++------------------ 2 files changed, 73 insertions(+), 51 deletions(-)
drivers/pci/msi/irqdomain.c +2 -2
@@ -14,7 +14,7 @@ int pci_msi_setup_msi_irqs(struct pci_de domain =dev_get_msi_domain (&dev->dev);if (domain &&irq_domain_is_hierarchy (domain)) -return msi_domain_alloc_irqs (domain, &dev->dev, nvec); +return msi_domain_alloc_irqs_descs_locked (domain, &dev->dev, nvec);return pci_msi_legacy_setup_msi_irqs (dev, nvec, type); }
@@ -25,7 +25,7 @@ void pci_msi_teardown_msi_irqs(struct pc domain =dev_get_msi_domain (&dev->dev);if (domain &&irq_domain_is_hierarchy (domain)) -msi_domain_free_irqs (domain, &dev->dev); +msi_domain_free_irqs_descs_locked (domain, &dev->dev);else pci_msi_legacy_teardown_msi_irqs (dev); }
drivers/pci/msi/msi.c +71 -49
253 lines not on this page · raw message
Re: [patch V2 07/31] PCI/MSI: Protect MSI operations
Quoted 7 lines · Thomas Gleixner
To prepare for dynamic extension of MSI-X vectors, protect the MSI operations for MSI and MSI-X. This requires to move the invocation of
irq_create_affinity_masks()out of the descriptor lock section to avoid reverse lock ordering vs. CPU hotplug lock as some callers of the PCI/MSI allocation interfaces already hold it.Signed-off-by Thomas Gleixner <[email protected]>
Quoted 297 lines
--- drivers/pci/msi/irqdomain.c | 4 - drivers/pci/msi/msi.c | 120 ++++++++++++++++++++++++++------------------ 2 files changed, 73 insertions(+), 51 deletions(-)drivers/pci/msi/irqdomain.c +2
-2@@ -14,7 +14,7 @@ int pci_msi_setup_msi_irqs(struct pci_de domain =dev_get_msi_domain (&dev->dev);if (domain &&irq_domain_is_hierarchy (domain)) -return msi_domain_alloc_irqs (domain, &dev->dev, nvec); +return msi_domain_alloc_irqs_descs_locked (domain, &dev->dev, nvec);return pci_msi_legacy_setup_msi_irqs (dev, nvec, type); }@@ -25,7 +25,7 @@ void pci_msi_teardown_msi_irqs(struct pc domain =dev_get_msi_domain (&dev->dev);if (domain &&irq_domain_is_hierarchy (domain)) -msi_domain_free_irqs (domain, &dev->dev); +msi_domain_free_irqs_descs_locked (domain, &dev->dev);else pci_msi_legacy_teardown_msi_irqs (dev); }drivers/pci/msi/msi.c +71
-49@@ -322,11 +322,13 @@ static void __pci_restore_msix_state(str write_msg =arch_restore_msi_irqs (dev); +msi_lock_descs (&dev->dev);for_each_pci_msi_entry (entry, dev) {if (write_msg)__pci_write_msi_msg (entry, &entry->msg);pci_msix_write_vector_ctrl (entry, entry->pci.msix_ctrl); } +msi_unlock_descs (&dev->dev);pci_msix_clear_and_set_ctrl (dev,PCI_MSIX_FLAGS_MASKALL ,0 ); }@@ -339,20 +341,16 @@ void pci_restore_msi_state(struct pci_deEXPORT_SYMBOL_GPL (pci_restore_msi_state);static struct msi_desc * -msi_setup_entry (struct pci_dev *dev,int nvec,struct irq_affinity *affd) +msi_setup_entry (struct pci_dev *dev,int nvec,struct irq_affinity_desc *masks) { -struct irq_affinity_desc *masks =NULL ;struct msi_desc *entry;unsigned long prop;u16 control; -if (affd) - masks =irq_create_affinity_masks (nvec, affd); -/* MSI Entry Initialization */ entry =alloc_msi_entry (&dev->dev, nvec, masks);if (!entry) - goto out; +return NULL ;pci_read_config_word (dev, dev->msi_cap +PCI_MSI_FLAGS , &control);/* Lies, damned lies, and MSIs */ @@ -379,8 +377,7 @@ msi_setup_entry(struct pci_dev *dev, intif (entry->pci.msi_attrib.is_64) prop |=MSI_PROP_64BIT ;msi_device_set_properties (&dev->dev, prop); -out: -kfree (masks); +return entry; }@@ -416,14 +413,21 @@ static int msi_verify_entries(struct pcistatic int msi_capability_init (struct pci_dev *dev,int nvec,struct irq_affinity *affd) { +struct irq_affinity_desc *masks =NULL ;struct msi_desc *entry;int ret;pci_msi_set_enable (dev,0 );/* Disable MSI during set up */ - entry =msi_setup_entry (dev, nvec, affd); -if (!entry) -return -ENOMEM ; +if (affd) + masks =irq_create_affinity_masks (nvec, affd); + +msi_lock_descs (&dev->dev); + entry =msi_setup_entry (dev, nvec, masks); +if (!entry) { + ret = -ENOMEM ; + goto unlock; + }/* All MSIs are unmasked by default; mask them all */ pci_msi_mask (entry,msi_multi_mask (entry));@@ -446,11 +450,14 @@ static int msi_capability_init(struct pcpcibios_free_irq (dev); dev->irq = entry->irq; -return 0 ; + goto unlock; err:pci_msi_unmask (entry,msi_multi_mask (entry));free_msi_irqs (dev); +unlock: +msi_unlock_descs (&dev->dev); +kfree (masks);return ret; }@@ -477,23 +484,18 @@ static void __iomem *msix_map_region(strstatic int msix_setup_entries (struct pci_dev *dev,void __iomem *base,struct msix_entry *entries,int nvec, -struct irq_affinity *affd) +struct irq_affinity_desc *masks) { -struct irq_affinity_desc *curmsk, *masks =NULL ; +int i, vec_count =pci_msix_vec_count (dev); +struct irq_affinity_desc *curmsk;struct msi_desc *entry;void __iomem *addr; -int ret, i; -int vec_count =pci_msix_vec_count (dev); - -if (affd) - masks =irq_create_affinity_masks (nvec, affd);for (i =0 , curmsk = masks; i < nvec; i++) { entry =alloc_msi_entry (&dev->dev,1 , curmsk);if (!entry) {/* No enough memory. Don't try again */ - ret = -ENOMEM ; - goto out; +return -ENOMEM ; } entry->pci.msi_attrib.is_msix =1 ;@@ -522,10 +524,7 @@ static int msix_setup_entries(struct pci curmsk++; }msi_device_set_properties (&dev->dev,MSI_PROP_PCI_MSIX |MSI_PROP_64BIT ); - ret =0 ; -out: -kfree (masks); -return ret; +return 0 ; }static void msix_update_entries (struct pci_dev *dev,struct msix_entry *entries)@@ -552,6 +551,41 @@ static void msix_mask_all(void __iomem *writel (ctrl, base +PCI_MSIX_ENTRY_VECTOR_CTRL ); } +static int msix_setup_interrupts (struct pci_dev *dev,void __iomem *base, +struct msix_entry *entries,int nvec, +struct irq_affinity *affd) +{ +struct irq_affinity_desc *masks =NULL ; +int ret; + +if (affd) + masks =irq_create_affinity_masks (nvec, affd); + +msi_lock_descs (&dev->dev); + ret =msix_setup_entries (dev, base, entries, nvec, masks); +if (ret) + goto out_free; + + ret =pci_msi_setup_msi_irqs (dev, nvec,PCI_CAP_ID_MSIX ); +if (ret) + goto out_free; + +/* Check if all MSI entries honor device restrictions */ + ret =msi_verify_entries (dev); +if (ret) + goto out_free; + +msix_update_entries (dev, entries); + goto out_unlock; + +out_free: +free_msi_irqs (dev); +out_unlock: +msi_unlock_descs (&dev->dev); +kfree (masks); +return ret; +} +/** * msix_capability_init - configure device's MSI-X capability * @dev: pointer to the pci_dev data structure of MSI-X device function @@ -592,20 +626,9 @@ static int msix_capability_init(struct p/* Ensure that all table entries are masked. */ msix_mask_all (base, tsize); - ret =msix_setup_entries (dev, base, entries, nvec, affd); + ret =msix_setup_interrupts (dev, base, entries, nvec, affd);if (ret) - goto out_free; - - ret =pci_msi_setup_msi_irqs (dev, nvec,PCI_CAP_ID_MSIX ); -if (ret) - goto out_free; - -/* Check if all MSI entries honor device restrictions */ - ret =msi_verify_entries (dev); -if (ret) - goto out_free; - -msix_update_entries (dev, entries); + goto out_disable;/* Set MSI-X enabled bits and unmask the function */ pci_intx_for_msi (dev,0 );@@ -615,12 +638,8 @@ static int msix_capability_init(struct ppcibios_free_irq (dev);return 0 ; -out_free: -free_msi_irqs (dev); - out_disable:pci_msix_clear_and_set_ctrl (dev,PCI_MSIX_FLAGS_ENABLE ,0 ); -return ret; }@@ -725,8 +744,10 @@ void pci_disable_msi(struct pci_dev *devif (!pci_msi_enable || !dev || !dev->msi_enabled)return ; +msi_lock_descs (&dev->dev);pci_msi_shutdown (dev);free_msi_irqs (dev); +msi_unlock_descs (&dev->dev); }EXPORT_SYMBOL (pci_disable_msi);@@ -812,8 +833,10 @@ void pci_disable_msix(struct pci_dev *deif (!pci_msi_enable || !dev || !dev->msix_enabled)return ; +msi_lock_descs (&dev->dev);pci_msix_shutdown (dev);free_msi_irqs (dev); +msi_unlock_descs (&dev->dev); }EXPORT_SYMBOL (pci_disable_msix);@@ -874,7 +897,6 @@ int pci_enable_msi(struct pci_dev *dev)if (!rc) rc =__pci_enable_msi_range (dev,1 ,1 ,NULL ); -return rc <0 ? rc :0 ; }EXPORT_SYMBOL (pci_enable_msi);@@ -961,11 +983,7 @@ int pci_alloc_irq_vectors_affinity(struc struct irq_affinity *affd) {struct irq_affinity msi_default_affd = {0 }; -int ret =msi_setup_device_data (&dev->dev); -int nvecs = -ENOSPC ; - -if (ret) -return ret; +int ret, nvecs;if (flags &PCI_IRQ_AFFINITY ) {if (!affd)@@ -975,6 +993,10 @@ int pci_alloc_irq_vectors_affinity(struc affd =NULL ; } + ret =msi_setup_device_data (&dev->dev); +if (ret) +return ret; +if (flags &PCI_IRQ_MSIX ) { nvecs =__pci_enable_msix_range (dev,NULL , min_vecs, max_vecs, affd, flags);@@ -1003,7 +1025,7 @@ int pci_alloc_irq_vectors_affinity(struc } } -return nvecs; +return -ENOSPC ; }EXPORT_SYMBOL (pci_alloc_irq_vectors_affinity);
[tip: irq/msi] PCI/MSI: Protect MSI operations
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 5512c5eaf533a98d33a8dc0dcf415e72773184c8 Gitweb: https://git.kernel.org/tip/5512c5eaf533a98d33a8dc0dcf415e72773184c8 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:13 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:17 +01:00
PCI/MSI: Protect MSI operations
To prepare for dynamic extension of MSI-X vectors, protect the MSI operations for MSI and MSI-X. This requires to move the invocation of irq_create_affinity_masks() out of the descriptor lock section to avoid reverse lock ordering vs. CPU hotplug lock as some callers of the PCI/MSI allocation interfaces already hold it.
--- drivers/pci/msi/irqdomain.c | 4 +- drivers/pci/msi/msi.c | 100 +++++++++++++++++++++-------------- 2 files changed, 63 insertions(+), 41 deletions(-)
drivers/pci/msi/irqdomain.c +2 -2
@@ -14,7 +14,7 @@ int pci_msi_setup_msi_irqs(struct pci_dev *dev, int nvec, int type) domain =dev_get_msi_domain (&dev->dev);if (domain &&irq_domain_is_hierarchy (domain)) -return msi_domain_alloc_irqs (domain, &dev->dev, nvec); +return msi_domain_alloc_irqs_descs_locked (domain, &dev->dev, nvec);return pci_msi_legacy_setup_msi_irqs (dev, nvec, type); }
@@ -25,7 +25,7 @@ void pci_msi_teardown_msi_irqs(struct pci_dev *dev) domain =dev_get_msi_domain (&dev->dev);if (domain &&irq_domain_is_hierarchy (domain)) -msi_domain_free_irqs (domain, &dev->dev); +msi_domain_free_irqs_descs_locked (domain, &dev->dev);else pci_msi_legacy_teardown_msi_irqs (dev); }
drivers/pci/msi/msi.c +61 -39
209 lines not on this page · raw message
PATCH v2 8/31 PCI/MSI: Use msi_add_msi_desc()
In reply to Thomas GleixnerSimplify the allocation of MSI descriptors by using msi_add_msi_desc() which moves the storage handling to core code and prepares for dynamic extension of the MSI-X vector space.
--- drivers/pci/msi/msi.c | 122 ++++++++++++++++++++++++-------------------------- 1 file changed, 59 insertions(+), 63 deletions(-)
drivers/pci/msi/msi.c +59 -63
@@ -340,45 +340,51 @@ void pci_restore_msi_state(struct pci_de }EXPORT_SYMBOL_GPL (pci_restore_msi_state); -static struct msi_desc * -msi_setup_entry (struct pci_dev *dev,int nvec,struct irq_affinity_desc *masks) +static int msi_setup_msi_desc (struct pci_dev *dev,int nvec, +struct irq_affinity_desc *masks) { -struct msi_desc *entry; +struct msi_desc desc;unsigned long prop;u16 control; +int ret;/* MSI Entry Initialization */ - entry =alloc_msi_entry (&dev->dev, nvec, masks); -if (!entry) -return NULL ; +memset (&desc,0 ,sizeof (desc));pci_read_config_word (dev, dev->msi_cap +PCI_MSI_FLAGS , &control);/* Lies, damned lies, and MSIs */ if (dev->dev_flags &PCI_DEV_FLAGS_HAS_MSI_MASKING ) control |=PCI_MSI_FLAGS_MASKBIT ; +/* Respect XEN's mask disabling */ +if (pci_msi_ignore_mask) + control &= ~PCI_MSI_FLAGS_MASKBIT ; - entry->pci.msi_attrib.is_64 = !!(control &PCI_MSI_FLAGS_64BIT ); - entry->pci.msi_attrib.can_mask = !pci_msi_ignore_mask && - !!(control &PCI_MSI_FLAGS_MASKBIT ); - entry->pci.msi_attrib.default_irq = dev->irq; - entry->pci.msi_attrib.multi_cap = (control &PCI_MSI_FLAGS_QMASK ) >>1 ; - entry->pci.msi_attrib.multiple =ilog2 (__roundup_pow_of_two (nvec)); + desc.nvec_used = nvec; + desc.pci.msi_attrib.is_64 = !!(control &PCI_MSI_FLAGS_64BIT ); + desc.pci.msi_attrib.can_mask = !!(control &PCI_MSI_FLAGS_MASKBIT ); + desc.pci.msi_attrib.default_irq = dev->irq; + desc.pci.msi_attrib.multi_cap = (control &PCI_MSI_FLAGS_QMASK ) >>1 ; + desc.pci.msi_attrib.multiple =ilog2 (__roundup_pow_of_two (nvec)); + desc.affinity = masks;if (control &PCI_MSI_FLAGS_64BIT ) - entry->pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_64 ; + desc.pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_64 ;else - entry->pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_32 ; + desc.pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_32 ;/* Save the initial mask status */ -if (entry->pci.msi_attrib.can_mask) -pci_read_config_dword (dev, entry->pci.mask_pos, &entry->pci.msi_mask); +if (desc.pci.msi_attrib.can_mask) +pci_read_config_dword (dev, desc.pci.mask_pos, &desc.pci.msi_mask); - prop =MSI_PROP_PCI_MSI ; -if (entry->pci.msi_attrib.is_64) - prop |=MSI_PROP_64BIT ; -msi_device_set_properties (&dev->dev, prop); + ret =msi_add_msi_desc (&dev->dev, &desc); +if (!ret) { + prop =MSI_PROP_PCI_MSI ; +if (desc.pci.msi_attrib.is_64) + prop |=MSI_PROP_64BIT ; +msi_device_set_properties (&dev->dev, prop); + } -return entry; +return ret; }static int msi_verify_entries (struct pci_dev *dev)
@@ -423,17 +429,14 @@ static int msi_capability_init(struct pc masks =irq_create_affinity_masks (nvec, affd);msi_lock_descs (&dev->dev); - entry =msi_setup_entry (dev, nvec, masks); -if (!entry) { - ret = -ENOMEM ; + ret =msi_setup_msi_desc (dev, nvec, masks); +if (ret) goto unlock; - }/* All MSIs are unmasked by default; mask them all */ + entry =first_pci_msi_entry (dev);pci_msi_mask (entry,msi_multi_mask (entry)); -list_add_tail (&entry->list,dev_to_msi_list (&dev->dev)); -/* Configure MSI capability structure */ ret =pci_msi_setup_msi_irqs (dev, nvec,PCI_CAP_ID_MSI );if (ret)
@@ -482,49 +485,40 @@ static void __iomem *msix_map_region(strreturn ioremap (phys_addr, nr_entries *PCI_MSIX_ENTRY_SIZE ); } -static int msix_setup_entries (struct pci_dev *dev,void __iomem *base, -struct msix_entry *entries,int nvec, -struct irq_affinity_desc *masks) +static int msix_setup_msi_descs (struct pci_dev *dev,void __iomem *base, +struct msix_entry *entries,int nvec, +struct irq_affinity_desc *masks) { -int i, vec_count =pci_msix_vec_count (dev); +int ret =0 , i, vec_count =pci_msix_vec_count (dev);struct irq_affinity_desc *curmsk; -struct msi_desc *entry; +struct msi_desc desc;void __iomem *addr; -for (i =0 , curmsk = masks; i < nvec; i++) { - entry =alloc_msi_entry (&dev->dev,1 , curmsk); -if (!entry) { -/* No enough memory. Don't try again */ -return -ENOMEM ; - } - - entry->pci.msi_attrib.is_msix =1 ; - entry->pci.msi_attrib.is_64 =1 ; - -if (entries) - entry->msi_index = entries[i].entry; -else - entry->msi_index = i; - - entry->pci.msi_attrib.is_virtual = entry->msi_index >= vec_count; - - entry->pci.msi_attrib.can_mask = !pci_msi_ignore_mask && - !entry->pci.msi_attrib.is_virtual; - - entry->pci.msi_attrib.default_irq = dev->irq; - entry->pci.mask_base = base; +memset (&desc,0 ,sizeof (desc)); -if (entry->pci.msi_attrib.can_mask) { - addr =pci_msix_desc_addr (entry); - entry->pci.msix_ctrl =readl (addr +PCI_MSIX_ENTRY_VECTOR_CTRL ); + desc.nvec_used =1 ; + desc.pci.msi_attrib.is_msix =1 ; + desc.pci.msi_attrib.is_64 =1 ; + desc.pci.msi_attrib.default_irq = dev->irq; + desc.pci.mask_base = base; + +for (i =0 , curmsk = masks; i < nvec; i++, curmsk++) { + desc.msi_index = entries ? entries[i].entry : i; + desc.affinity = masks ? curmsk :NULL ; + desc.pci.msi_attrib.is_virtual = desc.msi_index >= vec_count; + desc.pci.msi_attrib.can_mask = !pci_msi_ignore_mask && + !desc.pci.msi_attrib.is_virtual; + +if (!desc.pci.msi_attrib.can_mask) { + addr =pci_msix_desc_addr (&desc); + desc.pci.msix_ctrl =readl (addr +PCI_MSIX_ENTRY_VECTOR_CTRL ); } -list_add_tail (&entry->list,dev_to_msi_list (&dev->dev)); -if (masks) - curmsk++; + ret =msi_add_msi_desc (&dev->dev, &desc); +if (ret) +break ; } -msi_device_set_properties (&dev->dev,MSI_PROP_PCI_MSIX |MSI_PROP_64BIT ); -return 0 ; +return ret; }static void msix_update_entries (struct pci_dev *dev,struct msix_entry *entries)
@@ -562,10 +556,12 @@ static int msix_setup_interrupts(struct masks =irq_create_affinity_masks (nvec, affd);msi_lock_descs (&dev->dev); - ret =msix_setup_entries (dev, base, entries, nvec, masks); + ret =msix_setup_msi_descs (dev, base, entries, nvec, masks);if (ret) goto out_free; +msi_device_set_properties (&dev->dev,MSI_PROP_PCI_MSIX |MSI_PROP_64BIT ); + ret =pci_msi_setup_msi_irqs (dev, nvec,PCI_CAP_ID_MSIX );if (ret) goto out_free;
Re: [patch V2 08/31] PCI/MSI: Use msi_add_msi_desc()
Quoted 5 lines · Thomas Gleixner
Simplify the allocation of MSI descriptors by using
msi_add_msi_desc()which moves the storage handling to core code and prepares for dynamic extension of the MSI-X vector space.Signed-off-by Thomas Gleixner <[email protected]>
Quoted 191 lines
--- drivers/pci/msi/msi.c | 122 ++++++++++++++++++++++++-------------------------- 1 file changed, 59 insertions(+), 63 deletions(-)drivers/pci/msi/msi.c +59
-63@@ -340,45 +340,51 @@ void pci_restore_msi_state(struct pci_de }EXPORT_SYMBOL_GPL (pci_restore_msi_state); -static struct msi_desc * -msi_setup_entry (struct pci_dev *dev,int nvec,struct irq_affinity_desc *masks) +static int msi_setup_msi_desc (struct pci_dev *dev,int nvec, +struct irq_affinity_desc *masks) { -struct msi_desc *entry; +struct msi_desc desc;unsigned long prop;u16 control; +int ret;/* MSI Entry Initialization */ - entry =alloc_msi_entry (&dev->dev, nvec, masks); -if (!entry) -return NULL ; +memset (&desc,0 ,sizeof (desc));pci_read_config_word (dev, dev->msi_cap +PCI_MSI_FLAGS , &control);/* Lies, damned lies, and MSIs */ if (dev->dev_flags &PCI_DEV_FLAGS_HAS_MSI_MASKING ) control |=PCI_MSI_FLAGS_MASKBIT ; +/* Respect XEN's mask disabling */ +if (pci_msi_ignore_mask) + control &= ~PCI_MSI_FLAGS_MASKBIT ; - entry->pci.msi_attrib.is_64 = !!(control &PCI_MSI_FLAGS_64BIT ); - entry->pci.msi_attrib.can_mask = !pci_msi_ignore_mask && - !!(control &PCI_MSI_FLAGS_MASKBIT ); - entry->pci.msi_attrib.default_irq = dev->irq; - entry->pci.msi_attrib.multi_cap = (control &PCI_MSI_FLAGS_QMASK ) >>1 ; - entry->pci.msi_attrib.multiple =ilog2 (__roundup_pow_of_two (nvec)); + desc.nvec_used = nvec; + desc.pci.msi_attrib.is_64 = !!(control &PCI_MSI_FLAGS_64BIT ); + desc.pci.msi_attrib.can_mask = !!(control &PCI_MSI_FLAGS_MASKBIT ); + desc.pci.msi_attrib.default_irq = dev->irq; + desc.pci.msi_attrib.multi_cap = (control &PCI_MSI_FLAGS_QMASK ) >>1 ; + desc.pci.msi_attrib.multiple =ilog2 (__roundup_pow_of_two (nvec)); + desc.affinity = masks;if (control &PCI_MSI_FLAGS_64BIT ) - entry->pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_64 ; + desc.pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_64 ;else - entry->pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_32 ; + desc.pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_32 ;/* Save the initial mask status */ -if (entry->pci.msi_attrib.can_mask) -pci_read_config_dword (dev, entry->pci.mask_pos, &entry->pci.msi_mask); +if (desc.pci.msi_attrib.can_mask) +pci_read_config_dword (dev, desc.pci.mask_pos, &desc.pci.msi_mask); - prop =MSI_PROP_PCI_MSI ; -if (entry->pci.msi_attrib.is_64) - prop |=MSI_PROP_64BIT ; -msi_device_set_properties (&dev->dev, prop); + ret =msi_add_msi_desc (&dev->dev, &desc); +if (!ret) { + prop =MSI_PROP_PCI_MSI ; +if (desc.pci.msi_attrib.is_64) + prop |=MSI_PROP_64BIT ; +msi_device_set_properties (&dev->dev, prop); + } -return entry; +return ret; }static int msi_verify_entries (struct pci_dev *dev)@@ -423,17 +429,14 @@ static int msi_capability_init(struct pc masks =irq_create_affinity_masks (nvec, affd);msi_lock_descs (&dev->dev); - entry =msi_setup_entry (dev, nvec, masks); -if (!entry) { - ret = -ENOMEM ; + ret =msi_setup_msi_desc (dev, nvec, masks); +if (ret) goto unlock; - }/* All MSIs are unmasked by default; mask them all */ + entry =first_pci_msi_entry (dev);pci_msi_mask (entry,msi_multi_mask (entry)); -list_add_tail (&entry->list,dev_to_msi_list (&dev->dev)); -/* Configure MSI capability structure */ ret =pci_msi_setup_msi_irqs (dev, nvec,PCI_CAP_ID_MSI );if (ret)@@ -482,49 +485,40 @@ static void __iomem *msix_map_region(strreturn ioremap (phys_addr, nr_entries *PCI_MSIX_ENTRY_SIZE ); } -static int msix_setup_entries (struct pci_dev *dev,void __iomem *base, -struct msix_entry *entries,int nvec, -struct irq_affinity_desc *masks) +static int msix_setup_msi_descs (struct pci_dev *dev,void __iomem *base, +struct msix_entry *entries,int nvec, +struct irq_affinity_desc *masks) { -int i, vec_count =pci_msix_vec_count (dev); +int ret =0 , i, vec_count =pci_msix_vec_count (dev);struct irq_affinity_desc *curmsk; -struct msi_desc *entry; +struct msi_desc desc;void __iomem *addr; -for (i =0 , curmsk = masks; i < nvec; i++) { - entry =alloc_msi_entry (&dev->dev,1 , curmsk); -if (!entry) { -/* No enough memory. Don't try again */ -return -ENOMEM ; - } - - entry->pci.msi_attrib.is_msix =1 ; - entry->pci.msi_attrib.is_64 =1 ; - -if (entries) - entry->msi_index = entries[i].entry; -else - entry->msi_index = i; - - entry->pci.msi_attrib.is_virtual = entry->msi_index >= vec_count; - - entry->pci.msi_attrib.can_mask = !pci_msi_ignore_mask && - !entry->pci.msi_attrib.is_virtual; - - entry->pci.msi_attrib.default_irq = dev->irq; - entry->pci.mask_base = base; +memset (&desc,0 ,sizeof (desc)); -if (entry->pci.msi_attrib.can_mask) { - addr =pci_msix_desc_addr (entry); - entry->pci.msix_ctrl =readl (addr +PCI_MSIX_ENTRY_VECTOR_CTRL ); + desc.nvec_used =1 ; + desc.pci.msi_attrib.is_msix =1 ; + desc.pci.msi_attrib.is_64 =1 ; + desc.pci.msi_attrib.default_irq = dev->irq; + desc.pci.mask_base = base; + +for (i =0 , curmsk = masks; i < nvec; i++, curmsk++) { + desc.msi_index = entries ? entries[i].entry : i; + desc.affinity = masks ? curmsk :NULL ; + desc.pci.msi_attrib.is_virtual = desc.msi_index >= vec_count; + desc.pci.msi_attrib.can_mask = !pci_msi_ignore_mask && + !desc.pci.msi_attrib.is_virtual; + +if (!desc.pci.msi_attrib.can_mask) { + addr =pci_msix_desc_addr (&desc); + desc.pci.msix_ctrl =readl (addr +PCI_MSIX_ENTRY_VECTOR_CTRL ); } -list_add_tail (&entry->list,dev_to_msi_list (&dev->dev)); -if (masks) - curmsk++; + ret =msi_add_msi_desc (&dev->dev, &desc); +if (ret) +break ; } -msi_device_set_properties (&dev->dev,MSI_PROP_PCI_MSIX |MSI_PROP_64BIT ); -return 0 ; +return ret; }static void msix_update_entries (struct pci_dev *dev,struct msix_entry *entries)@@ -562,10 +556,12 @@ static int msix_setup_interrupts(struct masks =irq_create_affinity_masks (nvec, affd);msi_lock_descs (&dev->dev); - ret =msix_setup_entries (dev, base, entries, nvec, masks); + ret =msix_setup_msi_descs (dev, base, entries, nvec, masks);if (ret) goto out_free; +msi_device_set_properties (&dev->dev,MSI_PROP_PCI_MSIX |MSI_PROP_64BIT ); + ret =pci_msi_setup_msi_irqs (dev, nvec,PCI_CAP_ID_MSIX );if (ret) goto out_free;
[tip: irq/msi] PCI/MSI: Use msi_add_msi_desc()
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 71020a3c0dff4a00d96922a4a95a067f524a7dcb Gitweb: https://git.kernel.org/tip/71020a3c0dff4a00d96922a4a95a067f524a7dcb Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:15 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:17 +01:00
PCI/MSI: Use msi_add_msi_desc()
Simplify the allocation of MSI descriptors by using msi_add_msi_desc() which moves the storage handling to core code and prepares for dynamic extension of the MSI-X vector space.
--- drivers/pci/msi/msi.c | 104 ++++++++++++++++++----------------------- 1 file changed, 47 insertions(+), 57 deletions(-)
drivers/pci/msi/msi.c +47 -57
@@ -376,40 +376,41 @@ static int pci_setup_msi_context(struct pci_dev *dev)return ret; } -static struct msi_desc * -msi_setup_entry (struct pci_dev *dev,int nvec,struct irq_affinity_desc *masks) +static int msi_setup_msi_desc (struct pci_dev *dev,int nvec, +struct irq_affinity_desc *masks) { -struct msi_desc *entry; +struct msi_desc desc;u16 control;/* MSI Entry Initialization */ - entry =alloc_msi_entry (&dev->dev, nvec, masks); -if (!entry) -return NULL ; +memset (&desc,0 ,sizeof (desc));pci_read_config_word (dev, dev->msi_cap +PCI_MSI_FLAGS , &control);/* Lies, damned lies, and MSIs */ if (dev->dev_flags &PCI_DEV_FLAGS_HAS_MSI_MASKING ) control |=PCI_MSI_FLAGS_MASKBIT ; +/* Respect XEN's mask disabling */ +if (pci_msi_ignore_mask) + control &= ~PCI_MSI_FLAGS_MASKBIT ; - entry->pci.msi_attrib.is_64 = !!(control &PCI_MSI_FLAGS_64BIT ); - entry->pci.msi_attrib.can_mask = !pci_msi_ignore_mask && - !!(control &PCI_MSI_FLAGS_MASKBIT ); - entry->pci.msi_attrib.default_irq = dev->irq; - entry->pci.msi_attrib.multi_cap = (control &PCI_MSI_FLAGS_QMASK ) >>1 ; - entry->pci.msi_attrib.multiple =ilog2 (__roundup_pow_of_two (nvec)); + desc.nvec_used = nvec; + desc.pci.msi_attrib.is_64 = !!(control &PCI_MSI_FLAGS_64BIT ); + desc.pci.msi_attrib.can_mask = !!(control &PCI_MSI_FLAGS_MASKBIT ); + desc.pci.msi_attrib.default_irq = dev->irq; + desc.pci.msi_attrib.multi_cap = (control &PCI_MSI_FLAGS_QMASK ) >>1 ; + desc.pci.msi_attrib.multiple =ilog2 (__roundup_pow_of_two (nvec)); + desc.affinity = masks;if (control &PCI_MSI_FLAGS_64BIT ) - entry->pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_64 ; + desc.pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_64 ;else - entry->pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_32 ; + desc.pci.mask_pos = dev->msi_cap +PCI_MSI_MASK_32 ;/* Save the initial mask status */ -if (entry->pci.msi_attrib.can_mask) -pci_read_config_dword (dev, entry->pci.mask_pos, &entry->pci.msi_mask); - +if (desc.pci.msi_attrib.can_mask) +pci_read_config_dword (dev, desc.pci.mask_pos, &desc.pci.msi_mask); -return entry; +return msi_add_msi_desc (&dev->dev, &desc); }static int msi_verify_entries (struct pci_dev *dev)
@@ -459,17 +460,14 @@ static int msi_capability_init(struct pci_dev *dev, int nvec, masks =irq_create_affinity_masks (nvec, affd);msi_lock_descs (&dev->dev); - entry =msi_setup_entry (dev, nvec, masks); -if (!entry) { - ret = -ENOMEM ; + ret =msi_setup_msi_desc (dev, nvec, masks); +if (ret) goto fail; - }/* All MSIs are unmasked by default; mask them all */ + entry =first_pci_msi_entry (dev);pci_msi_mask (entry,msi_multi_mask (entry)); -list_add_tail (&entry->list,dev_to_msi_list (&dev->dev)); -/* Configure MSI capability structure */ ret =pci_msi_setup_msi_irqs (dev, nvec,PCI_CAP_ID_MSI );if (ret)
@@ -519,48 +517,40 @@ static void __iomem *msix_map_region(struct pci_dev *dev,return ioremap (phys_addr, nr_entries *PCI_MSIX_ENTRY_SIZE ); } -static int msix_setup_entries (struct pci_dev *dev,void __iomem *base, -struct msix_entry *entries,int nvec, -struct irq_affinity_desc *masks) +static int msix_setup_msi_descs (struct pci_dev *dev,void __iomem *base, +struct msix_entry *entries,int nvec, +struct irq_affinity_desc *masks) { -int i, vec_count =pci_msix_vec_count (dev); +int ret =0 , i, vec_count =pci_msix_vec_count (dev);struct irq_affinity_desc *curmsk; -struct msi_desc *entry; +struct msi_desc desc;void __iomem *addr; -for (i =0 , curmsk = masks; i < nvec; i++) { - entry =alloc_msi_entry (&dev->dev,1 , curmsk); -if (!entry) { -/* No enough memory. Don't try again */ -return -ENOMEM ; - } - - entry->pci.msi_attrib.is_msix =1 ; - entry->pci.msi_attrib.is_64 =1 ; +memset (&desc,0 ,sizeof (desc)); -if (entries) - entry->msi_index = entries[i].entry; -else - entry->msi_index = i; + desc.nvec_used =1 ; + desc.pci.msi_attrib.is_msix =1 ; + desc.pci.msi_attrib.is_64 =1 ; + desc.pci.msi_attrib.default_irq = dev->irq; + desc.pci.mask_base = base; - entry->pci.msi_attrib.is_virtual = entry->msi_index >= vec_count; +for (i =0 , curmsk = masks; i < nvec; i++, curmsk++) { + desc.msi_index = entries ? entries[i].entry : i; + desc.affinity = masks ? curmsk :NULL ; + desc.pci.msi_attrib.is_virtual = desc.msi_index >= vec_count; + desc.pci.msi_attrib.can_mask = !pci_msi_ignore_mask && + !desc.pci.msi_attrib.is_virtual; - entry->pci.msi_attrib.can_mask = !pci_msi_ignore_mask && - !entry->pci.msi_attrib.is_virtual; - - entry->pci.msi_attrib.default_irq = dev->irq; - entry->pci.mask_base = base; - -if (entry->pci.msi_attrib.can_mask) { - addr =pci_msix_desc_addr (entry); - entry->pci.msix_ctrl =readl (addr +PCI_MSIX_ENTRY_VECTOR_CTRL ); +if (!desc.pci.msi_attrib.can_mask) { + addr =pci_msix_desc_addr (&desc); + desc.pci.msix_ctrl =readl (addr +PCI_MSIX_ENTRY_VECTOR_CTRL ); } -list_add_tail (&entry->list,dev_to_msi_list (&dev->dev)); -if (masks) - curmsk++; + ret =msi_add_msi_desc (&dev->dev, &desc); +if (ret) +break ; } -return 0 ; +return ret; }static void msix_update_entries (struct pci_dev *dev,struct msix_entry *entries)
@@ -598,7 +588,7 @@ static int msix_setup_interrupts(struct pci_dev *dev, void __iomem *base, masks =irq_create_affinity_masks (nvec, affd);msi_lock_descs (&dev->dev); - ret =msix_setup_entries (dev, base, entries, nvec, masks); + ret =msix_setup_msi_descs (dev, base, entries, nvec, masks);if (ret) goto out_free;
PATCH v2 9/31 PCI/MSI: Let core code free MSI descriptors
In reply to Thomas GleixnerSet the domain info flag which tells the core code to free the MSI descriptors from msi_domain_free_irqs() and add an explicit call to the core function into the legacy code.
--- drivers/pci/msi/irqdomain.c | 3 ++- drivers/pci/msi/legacy.c | 1 + drivers/pci/msi/msi.c | 14 -------------- 3 files changed, 3 insertions(+), 15 deletions(-)
drivers/pci/msi/irqdomain.c +2 -1
@@ -171,7 +171,8 @@ struct irq_domain *pci_msi_create_irq_doif (info->flags &MSI_FLAG_USE_DEF_CHIP_OPS )pci_msi_domain_update_chip_ops (info); - info->flags |=MSI_FLAG_ACTIVATE_EARLY |MSI_FLAG_DEV_SYSFS ; + info->flags |=MSI_FLAG_ACTIVATE_EARLY |MSI_FLAG_DEV_SYSFS | +MSI_FLAG_FREE_MSI_DESCS ;if (IS_ENABLED (CONFIG_GENERIC_IRQ_RESERVATION_MODE )) info->flags |=MSI_FLAG_MUST_REACTIVATE ;
drivers/pci/msi/legacy.c +1 -0
@@ -80,4 +80,5 @@ void pci_msi_legacy_teardown_msi_irqs(st {msi_device_destroy_sysfs (&dev->dev);arch_teardown_msi_irqs (dev); +msi_free_msi_descs (&dev->dev); }
drivers/pci/msi/msi.c +0 -14
@@ -224,22 +224,8 @@ EXPORT_SYMBOL_GPL(pci_write_msi_msg);static void free_msi_irqs (struct pci_dev *dev) { -struct list_head *msi_list =dev_to_msi_list (&dev->dev); -struct msi_desc *entry, *tmp; -int i; - -for_each_pci_msi_entry (entry, dev) -if (entry->irq) -for (i =0 ; i < entry->nvec_used; i++) -BUG_ON (irq_has_action (entry->irq + i)); -pci_msi_teardown_msi_irqs (dev); -list_for_each_entry_safe (entry, tmp, msi_list, list) { -list_del (&entry->list); -free_msi_entry (entry); - } -if (dev->msix_base) {iounmap (dev->msix_base); dev->msix_base =NULL ;
Re: [patch V2 09/31] PCI/MSI: Let core code free MSI descriptors
Quoted 5 lines · Thomas Gleixner
Set the domain info flag which tells the core code to free the MSI descriptors from
msi_domain_free_irqs()and add an explicit call to the core function into the legacy code.Signed-off-by Thomas Gleixner <[email protected]>
Quoted 52 lines
--- drivers/pci/msi/irqdomain.c | 3 ++- drivers/pci/msi/legacy.c | 1 + drivers/pci/msi/msi.c | 14 -------------- 3 files changed, 3 insertions(+), 15 deletions(-)drivers/pci/msi/irqdomain.c +2
-1@@ -171,7 +171,8 @@ struct irq_domain *pci_msi_create_irq_doif (info->flags &MSI_FLAG_USE_DEF_CHIP_OPS )pci_msi_domain_update_chip_ops (info); - info->flags |=MSI_FLAG_ACTIVATE_EARLY |MSI_FLAG_DEV_SYSFS ; + info->flags |=MSI_FLAG_ACTIVATE_EARLY |MSI_FLAG_DEV_SYSFS | +MSI_FLAG_FREE_MSI_DESCS ;if (IS_ENABLED (CONFIG_GENERIC_IRQ_RESERVATION_MODE )) info->flags |=MSI_FLAG_MUST_REACTIVATE ;drivers/pci/msi/legacy.c +1
-0@@ -80,4 +80,5 @@ void pci_msi_legacy_teardown_msi_irqs(st {msi_device_destroy_sysfs (&dev->dev);arch_teardown_msi_irqs (dev); +msi_free_msi_descs (&dev->dev); }drivers/pci/msi/msi.c +0
-14@@ -224,22 +224,8 @@ EXPORT_SYMBOL_GPL(pci_write_msi_msg);static void free_msi_irqs (struct pci_dev *dev) { -struct list_head *msi_list =dev_to_msi_list (&dev->dev); -struct msi_desc *entry, *tmp; -int i; - -for_each_pci_msi_entry (entry, dev) -if (entry->irq) -for (i =0 ; i < entry->nvec_used; i++) -BUG_ON (irq_has_action (entry->irq + i)); -pci_msi_teardown_msi_irqs (dev); -list_for_each_entry_safe (entry, tmp, msi_list, list) { -list_del (&entry->list); -free_msi_entry (entry); - } -if (dev->msix_base) {iounmap (dev->msix_base); dev->msix_base =NULL ;
[tip: irq/msi] PCI/MSI: Let core code free MSI descriptors
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 9fb9eb4b59acc607e978288c96ac7efa917153d4 Gitweb: https://git.kernel.org/tip/9fb9eb4b59acc607e978288c96ac7efa917153d4 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:16 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:17 +01:00
PCI/MSI: Let core code free MSI descriptors
Set the domain info flag which tells the core code to free the MSI descriptors from msi_domain_free_irqs() and add an explicit call to the core function into the legacy code.
--- drivers/pci/msi/irqdomain.c | 3 ++- drivers/pci/msi/legacy.c | 1 + drivers/pci/msi/msi.c | 14 -------------- 3 files changed, 3 insertions(+), 15 deletions(-)
drivers/pci/msi/irqdomain.c +2 -1
@@ -171,7 +171,8 @@ struct irq_domain *pci_msi_create_irq_domain(struct fwnode_handle *fwnode,if (info->flags &MSI_FLAG_USE_DEF_CHIP_OPS )pci_msi_domain_update_chip_ops (info); - info->flags |=MSI_FLAG_ACTIVATE_EARLY |MSI_FLAG_DEV_SYSFS ; + info->flags |=MSI_FLAG_ACTIVATE_EARLY |MSI_FLAG_DEV_SYSFS | +MSI_FLAG_FREE_MSI_DESCS ;if (IS_ENABLED (CONFIG_GENERIC_IRQ_RESERVATION_MODE )) info->flags |=MSI_FLAG_MUST_REACTIVATE ;
drivers/pci/msi/legacy.c +1 -0
@@ -80,4 +80,5 @@ void pci_msi_legacy_teardown_msi_irqs(struct pci_dev *dev) {msi_device_destroy_sysfs (&dev->dev);arch_teardown_msi_irqs (dev); +msi_free_msi_descs (&dev->dev); }
drivers/pci/msi/msi.c +0 -14
@@ -224,22 +224,8 @@ EXPORT_SYMBOL_GPL(pci_write_msi_msg);static void free_msi_irqs (struct pci_dev *dev) { -struct list_head *msi_list =dev_to_msi_list (&dev->dev); -struct msi_desc *entry, *tmp; -int i; - -for_each_pci_msi_entry (entry, dev) -if (entry->irq) -for (i =0 ; i < entry->nvec_used; i++) -BUG_ON (irq_has_action (entry->irq + i)); -pci_msi_teardown_msi_irqs (dev); -list_for_each_entry_safe (entry, tmp, msi_list, list) { -list_del (&entry->list); -free_msi_entry (entry); - } -if (dev->msix_base) {iounmap (dev->msix_base); dev->msix_base =NULL ;
PATCH v2 10/31 PCI/MSI: Use msi_on_each_desc()
In reply to Thomas GleixnerUse the new iterator functions which pave the way for dynamically extending MSI-X vectors.
--- drivers/pci/msi/irqdomain.c | 4 ++-- drivers/pci/msi/legacy.c | 19 ++++++++----------- drivers/pci/msi/msi.c | 30 ++++++++++++++---------------- 3 files changed, 24 insertions(+), 29 deletions(-)
drivers/pci/msi/irqdomain.c +2 -2
@@ -83,7 +83,7 @@ static int pci_msi_domain_check_cap(strustruct msi_domain_info *info, struct device *dev) { - struct msi_desc *desc = first_pci_msi_entry(to_pci_dev(dev)); + struct msi_desc *desc = msi_first_desc(dev, MSI_DESC_ALL);/* Special handling to support __pci_enable_msi_range() */ if (pci_msi_desc_is_multi_msi(desc) &&
@@ -98,7 +98,7 @@ static int pci_msi_domain_check_cap(struunsigned int idx =0 ;/* Check for gaps in the entry indices */ -for_each_msi_entry (desc, dev) { +msi_for_each_desc (desc, dev,MSI_DESC_ALL ) {if (desc->msi_index != idx++)return -ENOTSUPP ; }
drivers/pci/msi/legacy.c +8 -11
@@ -28,7 +28,7 @@ int __weak arch_setup_msi_irqs(struct pcif (type ==PCI_CAP_ID_MSI && nvec >1 )return 1 ; -for_each_pci_msi_entry (desc, dev) { +msi_for_each_desc (desc, &dev->dev,MSI_DESC_NOTASSOCIATED ) { ret =arch_setup_msi_irq (dev, desc);if (ret)return ret <0 ? ret : -ENOSPC ;
@@ -42,27 +42,24 @@ void __weak arch_teardown_msi_irqs(strucstruct msi_desc *desc;int i; -for_each_pci_msi_entry (desc, dev) { -if (desc->irq) { -for (i =0 ; i < desc->nvec_used; i++) -arch_teardown_msi_irq (desc->irq + i); - } +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ASSOCIATED ) { +for (i =0 ; i < desc->nvec_used; i++) +arch_teardown_msi_irq (desc->irq + i); } }static int pci_msi_setup_check_result (struct pci_dev *dev,int type,int ret) { -struct msi_desc *entry; +struct msi_desc *desc;int avail =0 ;if (type !=PCI_CAP_ID_MSIX || ret >=0 )return ret;/* Scan the MSI descriptors for successfully allocated ones. */ -for_each_pci_msi_entry (entry, dev) { -if (entry->irq !=0 ) - avail++; - } +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ASSOCIATED ) + avail++; +return avail ? avail : ret; }
drivers/pci/msi/msi.c +14 -16
@@ -299,7 +299,6 @@ static void __pci_restore_msix_state(strif (!dev->msix_enabled)return ; -BUG_ON (list_empty (dev_to_msi_list (&dev->dev)));/* route the table */ pci_intx_for_msi (dev,0 );
@@ -309,7 +308,7 @@ static void __pci_restore_msix_state(str write_msg =arch_restore_msi_irqs (dev);msi_lock_descs (&dev->dev); -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ALL ) {if (write_msg)__pci_write_msi_msg (entry, &entry->msg);pci_msix_write_vector_ctrl (entry, entry->pci.msix_ctrl);
@@ -378,14 +377,14 @@ static int msi_verify_entries(struct pciif (!dev->no_64bit_msi)return 0 ; -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ALL ) {if (entry->msg.address_hi) {pci_err (dev,"arch assigned 64-bit MSI address %#x%08x but device only supports 32 bits\n" , entry->msg.address_hi, entry->msg.address_lo); -return -EIO ; +break ; } } -return 0 ; +return !entry ?0 : -EIO ; }/**
@@ -418,7 +417,7 @@ static int msi_capability_init(struct pc goto unlock;/* All MSIs are unmasked by default; mask them all */ - entry =first_pci_msi_entry (dev); + entry =msi_first_desc (&dev->dev,MSI_DESC_ALL );pci_msi_mask (entry,msi_multi_mask (entry));/* Configure MSI capability structure */
@@ -508,11 +507,11 @@ static int msix_setup_msi_descs(struct pstatic void msix_update_entries (struct pci_dev *dev,struct msix_entry *entries) { -struct msi_desc *entry; +struct msi_desc *desc;if (entries) { -for_each_pci_msi_entry (entry, dev) { - entries->vector = entry->irq; +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ALL ) { + entries->vector = desc->irq; entries++; } }
@@ -705,15 +704,14 @@ static void pci_msi_shutdown(struct pci_if (!pci_msi_enable || !dev || !dev->msi_enabled)return ; -BUG_ON (list_empty (dev_to_msi_list (&dev->dev))); - desc =first_pci_msi_entry (dev); -pci_msi_set_enable (dev,0 );pci_intx_for_msi (dev,1 ); dev->msi_enabled =0 ;/* Return the device with MSI unmasked as initial states */ -pci_msi_unmask (desc,msi_multi_mask (desc)); + desc =msi_first_desc (&dev->dev,MSI_DESC_ALL ); +if (!WARN_ON_ONCE (!desc)) +pci_msi_unmask (desc,msi_multi_mask (desc));/* Restore dev->irq to its default pin-assertion IRQ */ dev->irq = desc->pci.msi_attrib.default_irq;
@@ -789,7 +787,7 @@ static int __pci_enable_msix(struct pci_static void pci_msix_shutdown (struct pci_dev *dev) { -struct msi_desc *entry; +struct msi_desc *desc;if (!pci_msi_enable || !dev || !dev->msix_enabled)return ;
@@ -800,8 +798,8 @@ static void pci_msix_shutdown(struct pci }/* Return the device with MSI-X masked as initial states */ -for_each_pci_msi_entry (entry, dev) -pci_msix_mask (entry); +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ALL ) +pci_msix_mask (desc);pci_msix_clear_and_set_ctrl (dev,PCI_MSIX_FLAGS_ENABLE ,0 );pci_intx_for_msi (dev,1 );
Re: [patch V2 10/31] PCI/MSI: Use msi_on_each_desc()
Quoted 4 lines · Thomas Gleixner
Use the new iterator functions which pave the way for dynamically extending MSI-X vectors.
Signed-off-by Thomas Gleixner <[email protected]>
Quoted 173 lines
--- drivers/pci/msi/irqdomain.c | 4 ++-- drivers/pci/msi/legacy.c | 19 ++++++++----------- drivers/pci/msi/msi.c | 30 ++++++++++++++---------------- 3 files changed, 24 insertions(+), 29 deletions(-)drivers/pci/msi/irqdomain.c +2
-2@@ -83,7 +83,7 @@ static int pci_msi_domain_check_cap(strustruct msi_domain_info *info, struct device *dev) { - struct msi_desc *desc = first_pci_msi_entry(to_pci_dev(dev)); + struct msi_desc *desc = msi_first_desc(dev, MSI_DESC_ALL);/* Special handling to support __pci_enable_msi_range() */ if (pci_msi_desc_is_multi_msi(desc) &&@@ -98,7 +98,7 @@ static int pci_msi_domain_check_cap(struunsigned int idx =0 ;/* Check for gaps in the entry indices */ -for_each_msi_entry (desc, dev) { +msi_for_each_desc (desc, dev,MSI_DESC_ALL ) {if (desc->msi_index != idx++)return -ENOTSUPP ; }drivers/pci/msi/legacy.c +8
-11@@ -28,7 +28,7 @@ int __weak arch_setup_msi_irqs(struct pcif (type ==PCI_CAP_ID_MSI && nvec >1 )return 1 ; -for_each_pci_msi_entry (desc, dev) { +msi_for_each_desc (desc, &dev->dev,MSI_DESC_NOTASSOCIATED ) { ret =arch_setup_msi_irq (dev, desc);if (ret)return ret <0 ? ret : -ENOSPC ;@@ -42,27 +42,24 @@ void __weak arch_teardown_msi_irqs(strucstruct msi_desc *desc;int i; -for_each_pci_msi_entry (desc, dev) { -if (desc->irq) { -for (i =0 ; i < desc->nvec_used; i++) -arch_teardown_msi_irq (desc->irq + i); - } +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ASSOCIATED ) { +for (i =0 ; i < desc->nvec_used; i++) +arch_teardown_msi_irq (desc->irq + i); } }static int pci_msi_setup_check_result (struct pci_dev *dev,int type,int ret) { -struct msi_desc *entry; +struct msi_desc *desc;int avail =0 ;if (type !=PCI_CAP_ID_MSIX || ret >=0 )return ret;/* Scan the MSI descriptors for successfully allocated ones. */ -for_each_pci_msi_entry (entry, dev) { -if (entry->irq !=0 ) - avail++; - } +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ASSOCIATED ) + avail++; +return avail ? avail : ret; }drivers/pci/msi/msi.c +14
-16@@ -299,7 +299,6 @@ static void __pci_restore_msix_state(strif (!dev->msix_enabled)return ; -BUG_ON (list_empty (dev_to_msi_list (&dev->dev)));/* route the table */ pci_intx_for_msi (dev,0 );@@ -309,7 +308,7 @@ static void __pci_restore_msix_state(str write_msg =arch_restore_msi_irqs (dev);msi_lock_descs (&dev->dev); -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ALL ) {if (write_msg)__pci_write_msi_msg (entry, &entry->msg);pci_msix_write_vector_ctrl (entry, entry->pci.msix_ctrl);@@ -378,14 +377,14 @@ static int msi_verify_entries(struct pciif (!dev->no_64bit_msi)return 0 ; -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ALL ) {if (entry->msg.address_hi) {pci_err (dev,"arch assigned 64-bit MSI address %#x%08x but device only supports 32 bits\n" , entry->msg.address_hi, entry->msg.address_lo); -return -EIO ; +break ; } } -return 0 ; +return !entry ?0 : -EIO ; }/** @@ -418,7 +417,7 @@ static int msi_capability_init(struct pc goto unlock;/* All MSIs are unmasked by default; mask them all */ - entry =first_pci_msi_entry (dev); + entry =msi_first_desc (&dev->dev,MSI_DESC_ALL );pci_msi_mask (entry,msi_multi_mask (entry));/* Configure MSI capability structure */ @@ -508,11 +507,11 @@ static int msix_setup_msi_descs(struct pstatic void msix_update_entries (struct pci_dev *dev,struct msix_entry *entries) { -struct msi_desc *entry; +struct msi_desc *desc;if (entries) { -for_each_pci_msi_entry (entry, dev) { - entries->vector = entry->irq; +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ALL ) { + entries->vector = desc->irq; entries++; } }@@ -705,15 +704,14 @@ static void pci_msi_shutdown(struct pci_if (!pci_msi_enable || !dev || !dev->msi_enabled)return ; -BUG_ON (list_empty (dev_to_msi_list (&dev->dev))); - desc =first_pci_msi_entry (dev); -pci_msi_set_enable (dev,0 );pci_intx_for_msi (dev,1 ); dev->msi_enabled =0 ;/* Return the device with MSI unmasked as initial states */ -pci_msi_unmask (desc,msi_multi_mask (desc)); + desc =msi_first_desc (&dev->dev,MSI_DESC_ALL ); +if (!WARN_ON_ONCE (!desc)) +pci_msi_unmask (desc,msi_multi_mask (desc));/* Restore dev->irq to its default pin-assertion IRQ */ dev->irq = desc->pci.msi_attrib.default_irq;@@ -789,7 +787,7 @@ static int __pci_enable_msix(struct pci_static void pci_msix_shutdown (struct pci_dev *dev) { -struct msi_desc *entry; +struct msi_desc *desc;if (!pci_msi_enable || !dev || !dev->msix_enabled)return ;@@ -800,8 +798,8 @@ static void pci_msix_shutdown(struct pci }/* Return the device with MSI-X masked as initial states */ -for_each_pci_msi_entry (entry, dev) -pci_msix_mask (entry); +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ALL ) +pci_msix_mask (desc);pci_msix_clear_and_set_ctrl (dev,PCI_MSIX_FLAGS_ENABLE ,0 );pci_intx_for_msi (dev,1 );
[tip: irq/msi] PCI/MSI: Use msi_on_each_desc()
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: ae24e28fef14687a26f98050e64153b8e4fee7c7 Gitweb: https://git.kernel.org/tip/ae24e28fef14687a26f98050e64153b8e4fee7c7 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:18 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:18 +01:00
PCI/MSI: Use msi_on_each_desc()
Use the new iterator functions which pave the way for dynamically extending MSI-X vectors.
--- drivers/pci/msi/irqdomain.c | 4 ++-- drivers/pci/msi/legacy.c | 19 ++++++++----------- drivers/pci/msi/msi.c | 30 ++++++++++++++---------------- 3 files changed, 24 insertions(+), 29 deletions(-)
drivers/pci/msi/irqdomain.c +2 -2
@@ -83,7 +83,7 @@ static int pci_msi_domain_check_cap(struct irq_domain *domain,struct msi_domain_info *info, struct device *dev) { - struct msi_desc *desc = first_pci_msi_entry(to_pci_dev(dev)); + struct msi_desc *desc = msi_first_desc(dev, MSI_DESC_ALL);/* Special handling to support __pci_enable_msi_range() */ if (pci_msi_desc_is_multi_msi(desc) &&
@@ -98,7 +98,7 @@ static int pci_msi_domain_check_cap(struct irq_domain *domain,unsigned int idx =0 ;/* Check for gaps in the entry indices */ -for_each_msi_entry (desc, dev) { +msi_for_each_desc (desc, dev,MSI_DESC_ALL ) {if (desc->msi_index != idx++)return -ENOTSUPP ; }
drivers/pci/msi/legacy.c +8 -11
@@ -28,7 +28,7 @@ int __weak arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)if (type ==PCI_CAP_ID_MSI && nvec >1 )return 1 ; -for_each_pci_msi_entry (desc, dev) { +msi_for_each_desc (desc, &dev->dev,MSI_DESC_NOTASSOCIATED ) { ret =arch_setup_msi_irq (dev, desc);if (ret)return ret <0 ? ret : -ENOSPC ;
@@ -42,27 +42,24 @@ void __weak arch_teardown_msi_irqs(struct pci_dev *dev)struct msi_desc *desc;int i; -for_each_pci_msi_entry (desc, dev) { -if (desc->irq) { -for (i =0 ; i < desc->nvec_used; i++) -arch_teardown_msi_irq (desc->irq + i); - } +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ASSOCIATED ) { +for (i =0 ; i < desc->nvec_used; i++) +arch_teardown_msi_irq (desc->irq + i); } }static int pci_msi_setup_check_result (struct pci_dev *dev,int type,int ret) { -struct msi_desc *entry; +struct msi_desc *desc;int avail =0 ;if (type !=PCI_CAP_ID_MSIX || ret >=0 )return ret;/* Scan the MSI descriptors for successfully allocated ones. */ -for_each_pci_msi_entry (entry, dev) { -if (entry->irq !=0 ) - avail++; - } +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ASSOCIATED ) + avail++; +return avail ? avail : ret; }
drivers/pci/msi/msi.c +14 -16
@@ -297,7 +297,6 @@ static void __pci_restore_msix_state(struct pci_dev *dev)if (!dev->msix_enabled)return ; -BUG_ON (list_empty (dev_to_msi_list (&dev->dev)));/* route the table */ pci_intx_for_msi (dev,0 );
@@ -307,7 +306,7 @@ static void __pci_restore_msix_state(struct pci_dev *dev) write_msg =arch_restore_msi_irqs (dev);msi_lock_descs (&dev->dev); -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ALL ) {if (write_msg)__pci_write_msi_msg (entry, &entry->msg);pci_msix_write_vector_ctrl (entry, entry->pci.msix_ctrl);
@@ -406,14 +405,14 @@ static int msi_verify_entries(struct pci_dev *dev)if (!dev->no_64bit_msi)return 0 ; -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ALL ) {if (entry->msg.address_hi) {pci_err (dev,"arch assigned 64-bit MSI address %#x%08x but device only supports 32 bits\n" , entry->msg.address_hi, entry->msg.address_lo); -return -EIO ; +break ; } } -return 0 ; +return !entry ?0 : -EIO ; }/**
@@ -451,7 +450,7 @@ static int msi_capability_init(struct pci_dev *dev, int nvec, goto fail;/* All MSIs are unmasked by default; mask them all */ - entry =first_pci_msi_entry (dev); + entry =msi_first_desc (&dev->dev,MSI_DESC_ALL );pci_msi_mask (entry,msi_multi_mask (entry));/* Configure MSI capability structure */
@@ -541,11 +540,11 @@ static int msix_setup_msi_descs(struct pci_dev *dev, void __iomem *base,static void msix_update_entries (struct pci_dev *dev,struct msix_entry *entries) { -struct msi_desc *entry; +struct msi_desc *desc;if (entries) { -for_each_pci_msi_entry (entry, dev) { - entries->vector = entry->irq; +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ALL ) { + entries->vector = desc->irq; entries++; } }
@@ -747,15 +746,14 @@ static void pci_msi_shutdown(struct pci_dev *dev)if (!pci_msi_enable || !dev || !dev->msi_enabled)return ; -BUG_ON (list_empty (dev_to_msi_list (&dev->dev))); - desc =first_pci_msi_entry (dev); -pci_msi_set_enable (dev,0 );pci_intx_for_msi (dev,1 ); dev->msi_enabled =0 ;/* Return the device with MSI unmasked as initial states */ -pci_msi_unmask (desc,msi_multi_mask (desc)); + desc =msi_first_desc (&dev->dev,MSI_DESC_ALL ); +if (!WARN_ON_ONCE (!desc)) +pci_msi_unmask (desc,msi_multi_mask (desc));/* Restore dev->irq to its default pin-assertion IRQ */ dev->irq = desc->pci.msi_attrib.default_irq;
@@ -831,7 +829,7 @@ static int __pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries,static void pci_msix_shutdown (struct pci_dev *dev) { -struct msi_desc *entry; +struct msi_desc *desc;if (!pci_msi_enable || !dev || !dev->msix_enabled)return ;
@@ -842,8 +840,8 @@ static void pci_msix_shutdown(struct pci_dev *dev) }/* Return the device with MSI-X masked as initial states */ -for_each_pci_msi_entry (entry, dev) -pci_msix_mask (entry); +msi_for_each_desc (desc, &dev->dev,MSI_DESC_ALL ) +pci_msix_mask (desc);pci_msix_clear_and_set_ctrl (dev,PCI_MSIX_FLAGS_ENABLE ,0 );pci_intx_for_msi (dev,1 );
PATCH v2 11/31 x86/pci/xen: Use msi_for_each_desc()
In reply to Thomas GleixnerReplace the about to vanish iterators.
--- arch/x86/pci/xen.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
arch/x86/pci/xen.c +6 -8
@@ -184,7 +184,7 @@ static int xen_setup_msi_irqs(struct pciif (ret) goto error; i =0 ; -for_each_pci_msi_entry (msidesc, dev) { +msi_for_each_desc (msidesc, &dev->dev,MSI_DESC_NOTASSOCIATED ) { irq = xen_bind_pirq_msi_to_irq(dev, msidesc, v[i], (type == PCI_CAP_ID_MSI) ? nvec : 1, (type == PCI_CAP_ID_MSIX) ?
@@ -235,7 +235,7 @@ static int xen_hvm_setup_msi_irqs(structif (type ==PCI_CAP_ID_MSI && nvec >1 )return 1 ; -for_each_pci_msi_entry (msidesc, dev) { +msi_for_each_desc (msidesc, &dev->dev,MSI_DESC_NOTASSOCIATED ) { pirq =xen_allocate_pirq_msi (dev, msidesc);if (pirq <0 ) { irq = -ENODEV ;
@@ -270,7 +270,7 @@ static int xen_initdom_setup_msi_irqs(stint ret =0 ;struct msi_desc *msidesc; -for_each_pci_msi_entry (msidesc, dev) { +msi_for_each_desc (msidesc, &dev->dev,MSI_DESC_NOTASSOCIATED ) {struct physdev_map_pirq map_irq;domid_t domid;
@@ -389,11 +389,9 @@ static void xen_teardown_msi_irqs(structstruct msi_desc *msidesc;int i; -for_each_pci_msi_entry (msidesc, dev) { -if (msidesc->irq) { -for (i =0 ; i < msidesc->nvec_used; i++) -xen_destroy_irq (msidesc->irq + i); - } +msi_for_each_desc (msidesc, &dev->dev,MSI_DESC_ASSOCIATED ) { +for (i =0 ; i < msidesc->nvec_used; i++) +xen_destroy_irq (msidesc->irq + i); } }
[tip: irq/msi] x86/pci/xen: Use msi_for_each_desc()
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: f2948df5f87a722591499da60ab91c611422f755 Gitweb: https://git.kernel.org/tip/f2948df5f87a722591499da60ab91c611422f755 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:20 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:18 +01:00
x86/pci/xen: Use msi_for_each_desc()
Replace the about to vanish iterators.
--- arch/x86/pci/xen.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
arch/x86/pci/xen.c +6 -8
@@ -184,7 +184,7 @@ static int xen_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)if (ret) goto error; i =0 ; -for_each_pci_msi_entry (msidesc, dev) { +msi_for_each_desc (msidesc, &dev->dev,MSI_DESC_NOTASSOCIATED ) { irq = xen_bind_pirq_msi_to_irq(dev, msidesc, v[i], (type == PCI_CAP_ID_MSI) ? nvec : 1, (type == PCI_CAP_ID_MSIX) ?
@@ -235,7 +235,7 @@ static int xen_hvm_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)if (type ==PCI_CAP_ID_MSI && nvec >1 )return 1 ; -for_each_pci_msi_entry (msidesc, dev) { +msi_for_each_desc (msidesc, &dev->dev,MSI_DESC_NOTASSOCIATED ) { pirq =xen_allocate_pirq_msi (dev, msidesc);if (pirq <0 ) { irq = -ENODEV ;
@@ -270,7 +270,7 @@ static int xen_initdom_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)int ret =0 ;struct msi_desc *msidesc; -for_each_pci_msi_entry (msidesc, dev) { +msi_for_each_desc (msidesc, &dev->dev,MSI_DESC_NOTASSOCIATED ) {struct physdev_map_pirq map_irq;domid_t domid;
@@ -389,11 +389,9 @@ static void xen_teardown_msi_irqs(struct pci_dev *dev)struct msi_desc *msidesc;int i; -for_each_pci_msi_entry (msidesc, dev) { -if (msidesc->irq) { -for (i =0 ; i < msidesc->nvec_used; i++) -xen_destroy_irq (msidesc->irq + i); - } +msi_for_each_desc (msidesc, &dev->dev,MSI_DESC_ASSOCIATED ) { +for (i =0 ; i < msidesc->nvec_used; i++) +xen_destroy_irq (msidesc->irq + i); } }
PATCH v2 12/31 xen/pcifront: Rework MSI handling
In reply to Thomas GleixnerReplace the about to vanish iterators.
--- drivers/pci/xen-pcifront.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/pci/xen-pcifront.c +1 -1
@@ -262,7 +262,7 @@ static int pci_frontend_enable_msix(stru } i =0 ; -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_NOTASSOCIATED ) { op.msix_entries[i].entry = entry->msi_index;/* Vector is useless at this point. */ op.msix_entries[i].vector =-1 ;
[tip: irq/msi] xen/pcifront: Rework MSI handling
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 3d31bbd39aa5c7467a34e8202a983e81b696a883 Gitweb: https://git.kernel.org/tip/3d31bbd39aa5c7467a34e8202a983e81b696a883 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:21 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:18 +01:00
xen/pcifront: Rework MSI handling
Replace the about to vanish iterators.
--- drivers/pci/xen-pcifront.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/pci/xen-pcifront.c +1 -1
@@ -262,7 +262,7 @@ static int pci_frontend_enable_msix(struct pci_dev *dev, } i =0 ; -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_NOTASSOCIATED ) { op.msix_entries[i].entry = entry->msi_index;/* Vector is useless at this point. */ op.msix_entries[i].vector =-1 ;
PATCH v2 13/31 s390/pci: Rework MSI descriptor walk
In reply to Thomas GleixnerReplace the about to vanish iterators and make use of the filtering.
--- arch/s390/pci/pci_irq.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
arch/s390/pci/pci_irq.c +2 -4
@@ -303,7 +303,7 @@ int arch_setup_msi_irqs(struct pci_dev */* Request MSI interrupts */ hwirq = bit; -for_each_pci_msi_entry (msi, pdev) { +msi_for_each_desc (msi, &pdev->dev,MSI_DESC_NOTASSOCIATED ) { rc = -EIO ;if (hwirq - bit >= msi_vecs)break ;
@@ -362,9 +362,7 @@ void arch_teardown_msi_irqs(struct pci_dreturn ;/* Release MSI interrupts */ -for_each_pci_msi_entry (msi, pdev) { -if (!msi->irq) -continue ; +msi_for_each_desc (msi, &pdev->dev,MSI_DESC_ASSOCIATED ) {irq_set_msi_desc (msi->irq,NULL );irq_free_desc (msi->irq); msi->msg.address_lo =0 ;
[tip: irq/msi] s390/pci: Rework MSI descriptor walk
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 2ca5e908d0f4cde61d9d3595e8314adca5d914a1 Gitweb: https://git.kernel.org/tip/2ca5e908d0f4cde61d9d3595e8314adca5d914a1 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:23 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:18 +01:00
s390/pci: Rework MSI descriptor walk
Replace the about to vanish iterators and make use of the filtering.
--- arch/s390/pci/pci_irq.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
arch/s390/pci/pci_irq.c +2 -4
@@ -303,7 +303,7 @@ int arch_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)/* Request MSI interrupts */ hwirq = bit; -for_each_pci_msi_entry (msi, pdev) { +msi_for_each_desc (msi, &pdev->dev,MSI_DESC_NOTASSOCIATED ) { rc = -EIO ;if (hwirq - bit >= msi_vecs)break ;
@@ -362,9 +362,7 @@ void arch_teardown_msi_irqs(struct pci_dev *pdev)return ;/* Release MSI interrupts */ -for_each_pci_msi_entry (msi, pdev) { -if (!msi->irq) -continue ; +msi_for_each_desc (msi, &pdev->dev,MSI_DESC_ASSOCIATED ) {irq_set_msi_desc (msi->irq,NULL );irq_free_desc (msi->irq); msi->msg.address_lo =0 ;
PATCH v2 14/31 powerpc/4xx/hsta: Rework MSI handling
In reply to Thomas GleixnerReplace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/platforms/4xx/hsta_msi.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
arch/powerpc/platforms/4xx/hsta_msi.c +2 -5
@@ -47,7 +47,7 @@ static int hsta_setup_msi_irqs(struct pcreturn -EINVAL ; } -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_NOTASSOCIATED ) { irq =msi_bitmap_alloc_hwirqs (&ppc4xx_hsta_msi.bmp,1 );if (irq <0 ) { pr_debug("%s: Failed to allocate msi interrupt\n",
@@ -105,10 +105,7 @@ static void hsta_teardown_msi_irqs(strucstruct msi_desc *entry;int irq; -for_each_pci_msi_entry (entry, dev) { -if (!entry->irq) -continue ; - +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ASSOCIATED ) { irq =hsta_find_hwirq_offset (entry->irq);/* entry->irq should always be in irq_map */
[tip: irq/msi] powerpc/4xx/hsta: Rework MSI handling
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 85dabc2f72b65d1aa52ac8214b1112f141d17b91 Gitweb: https://git.kernel.org/tip/85dabc2f72b65d1aa52ac8214b1112f141d17b91 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:25 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:18 +01:00
powerpc/4xx/hsta: Rework MSI handling
Replace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/platforms/4xx/hsta_msi.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
arch/powerpc/platforms/4xx/hsta_msi.c +2 -5
@@ -47,7 +47,7 @@ static int hsta_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)return -EINVAL ; } -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_NOTASSOCIATED ) { irq =msi_bitmap_alloc_hwirqs (&ppc4xx_hsta_msi.bmp,1 );if (irq <0 ) { pr_debug("%s: Failed to allocate msi interrupt\n",
@@ -105,10 +105,7 @@ static void hsta_teardown_msi_irqs(struct pci_dev *dev)struct msi_desc *entry;int irq; -for_each_pci_msi_entry (entry, dev) { -if (!entry->irq) -continue ; - +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ASSOCIATED ) { irq =hsta_find_hwirq_offset (entry->irq);/* entry->irq should always be in irq_map */
PATCH v2 15/31 powerpc/cell/axon_msi: Convert to msi_on_each_desc()
In reply to Thomas GleixnerReplace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/platforms/cell/axon_msi.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
arch/powerpc/platforms/cell/axon_msi.c +2 -5
@@ -265,7 +265,7 @@ static int axon_msi_setup_msi_irqs(strucif (rc)return rc; -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_NOTASSOCIATED ) { virq =irq_create_direct_mapping (msic->irq_domain);if (!virq) { dev_warn(&dev->dev,
@@ -288,10 +288,7 @@ static void axon_msi_teardown_msi_irqs(sdev_dbg (&dev->dev,"axon_msi: tearing down msi irqs\n" ); -for_each_pci_msi_entry (entry, dev) { -if (!entry->irq) -continue ; - +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ASSOCIATED ) {irq_set_msi_desc (entry->irq,NULL );irq_dispose_mapping (entry->irq); }
[tip: irq/msi] powerpc/cell/axon_msi: Convert to msi_on_each_desc()
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 3c46658bd70389bf6a7410960905415df50350d2 Gitweb: https://git.kernel.org/tip/3c46658bd70389bf6a7410960905415df50350d2 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:26 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:18 +01:00
powerpc/cell/axon_msi: Convert to msi_on_each_desc()
Replace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/platforms/cell/axon_msi.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
arch/powerpc/platforms/cell/axon_msi.c +2 -5
@@ -262,7 +262,7 @@ static int axon_msi_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)if (rc)return rc; -for_each_pci_msi_entry (entry, dev) { +msi_for_each_desc (entry, &dev->dev,MSI_DESC_NOTASSOCIATED ) { virq =irq_create_direct_mapping (msic->irq_domain);if (!virq) { dev_warn(&dev->dev,
@@ -285,10 +285,7 @@ static void axon_msi_teardown_msi_irqs(struct pci_dev *dev)dev_dbg (&dev->dev,"axon_msi: tearing down msi irqs\n" ); -for_each_pci_msi_entry (entry, dev) { -if (!entry->irq) -continue ; - +msi_for_each_desc (entry, &dev->dev,MSI_DESC_ASSOCIATED ) {irq_set_msi_desc (entry->irq,NULL );irq_dispose_mapping (entry->irq); }
PATCH v2 16/31 powerpc/pasemi/msi: Convert to msi_on_each_dec()
In reply to Thomas GleixnerReplace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/platforms/pasemi/msi.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-)
arch/powerpc/platforms/pasemi/msi.c +2 -7
@@ -62,17 +62,12 @@ static void pasemi_msi_teardown_msi_irqspr_debug ("pasemi_msi_teardown_msi_irqs, pdev %p\n" , pdev); -for_each_pci_msi_entry (entry, pdev) { -if (!entry->irq) -continue ; - +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { hwirq =virq_to_hw (entry->irq);irq_set_msi_desc (entry->irq,NULL );irq_dispose_mapping (entry->irq);msi_bitmap_free_hwirqs (&msi_mpic->msi_bitmap, hwirq,ALLOC_CHUNK ); } - -return ; }static int pasemi_msi_setup_msi_irqs (struct pci_dev *pdev,int nvec,int type)
@@ -90,7 +85,7 @@ static int pasemi_msi_setup_msi_irqs(str msg.address_hi =0 ; msg.address_lo =PASEMI_MSI_ADDR ; -for_each_pci_msi_entry (entry, pdev) { +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_NOTASSOCIATED ) {/* Allocate 16 interrupts for now, since that's the grouping for * affinity. This can be changed later if it turns out 32 is too * few MSIs for someone, but restrictions will apply to how the
[tip: irq/msi] powerpc/pasemi/msi: Convert to msi_on_each_dec()
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: e22b0d1bbf5bd71ed2b2fb54a257b5cc38c351c3 Gitweb: https://git.kernel.org/tip/e22b0d1bbf5bd71ed2b2fb54a257b5cc38c351c3 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:28 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:18 +01:00
powerpc/pasemi/msi: Convert to msi_on_each_dec()
Replace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/platforms/pasemi/msi.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-)
arch/powerpc/platforms/pasemi/msi.c +2 -7
@@ -62,17 +62,12 @@ static void pasemi_msi_teardown_msi_irqs(struct pci_dev *pdev)pr_debug ("pasemi_msi_teardown_msi_irqs, pdev %p\n" , pdev); -for_each_pci_msi_entry (entry, pdev) { -if (!entry->irq) -continue ; - +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { hwirq =virq_to_hw (entry->irq);irq_set_msi_desc (entry->irq,NULL );irq_dispose_mapping (entry->irq);msi_bitmap_free_hwirqs (&msi_mpic->msi_bitmap, hwirq,ALLOC_CHUNK ); } - -return ; }static int pasemi_msi_setup_msi_irqs (struct pci_dev *pdev,int nvec,int type)
@@ -90,7 +85,7 @@ static int pasemi_msi_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type) msg.address_hi =0 ; msg.address_lo =PASEMI_MSI_ADDR ; -for_each_pci_msi_entry (entry, pdev) { +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_NOTASSOCIATED ) {/* Allocate 16 interrupts for now, since that's the grouping for * affinity. This can be changed later if it turns out 32 is too * few MSIs for someone, but restrictions will apply to how the
PATCH v2 17/31 powerpc/fsl_msi: Use msi_for_each_desc()
In reply to Thomas GleixnerReplace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/sysdev/fsl_msi.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-)
arch/powerpc/sysdev/fsl_msi.c +2 -6
@@ -125,17 +125,13 @@ static void fsl_teardown_msi_irqs(structstruct fsl_msi *msi_data;irq_hw_number_t hwirq; -for_each_pci_msi_entry (entry, pdev) { -if (!entry->irq) -continue ; +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { hwirq =virq_to_hw (entry->irq); msi_data =irq_get_chip_data (entry->irq);irq_set_msi_desc (entry->irq,NULL );irq_dispose_mapping (entry->irq);msi_bitmap_free_hwirqs (&msi_data->bitmap, hwirq,1 ); } - -return ; } static void fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,
@@ -215,7 +211,7 @@ static int fsl_setup_msi_irqs(struct pci } } -for_each_pci_msi_entry (entry, pdev) { +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_NOTASSOCIATED ) {/* * Loop over all the MSI devices until we find one that has an * available interrupt.
[tip: irq/msi] powerpc/fsl_msi: Use msi_for_each_desc()
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: ab430e7437789d3996115a925d260b2c34ddc8c9 Gitweb: https://git.kernel.org/tip/ab430e7437789d3996115a925d260b2c34ddc8c9 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:29 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:18 +01:00
powerpc/fsl_msi: Use msi_for_each_desc()
Replace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/sysdev/fsl_msi.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-)
arch/powerpc/sysdev/fsl_msi.c +2 -6
@@ -125,17 +125,13 @@ static void fsl_teardown_msi_irqs(struct pci_dev *pdev)struct fsl_msi *msi_data;irq_hw_number_t hwirq; -for_each_pci_msi_entry (entry, pdev) { -if (!entry->irq) -continue ; +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { hwirq =virq_to_hw (entry->irq); msi_data =irq_get_chip_data (entry->irq);irq_set_msi_desc (entry->irq,NULL );irq_dispose_mapping (entry->irq);msi_bitmap_free_hwirqs (&msi_data->bitmap, hwirq,1 ); } - -return ; } static void fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,
@@ -215,7 +211,7 @@ static int fsl_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type) } } -for_each_pci_msi_entry (entry, pdev) { +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_NOTASSOCIATED ) {/* * Loop over all the MSI devices until we find one that has an * available interrupt.
PATCH v2 18/31 powerpc/mpic_u3msi: Use msi_for_each-desc()
In reply to Thomas GleixnerReplace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/sysdev/mpic_u3msi.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-)
arch/powerpc/sysdev/mpic_u3msi.c +2 -7
@@ -104,17 +104,12 @@ static void u3msi_teardown_msi_irqs(strustruct msi_desc *entry;irq_hw_number_t hwirq; -for_each_pci_msi_entry (entry, pdev) { -if (!entry->irq) -continue ; - +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { hwirq =virq_to_hw (entry->irq);irq_set_msi_desc (entry->irq,NULL );irq_dispose_mapping (entry->irq);msi_bitmap_free_hwirqs (&msi_mpic->msi_bitmap, hwirq,1 ); } - -return ; }static int u3msi_setup_msi_irqs (struct pci_dev *pdev,int nvec,int type)
@@ -136,7 +131,7 @@ static int u3msi_setup_msi_irqs(struct preturn -ENXIO ; } -for_each_pci_msi_entry (entry, pdev) { +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_NOTASSOCIATED ) { hwirq =msi_bitmap_alloc_hwirqs (&msi_mpic->msi_bitmap,1 );if (hwirq <0 ) {pr_debug ("u3msi: failed allocating hwirq\n" );
[tip: irq/msi] powerpc/mpic_u3msi: Use msi_for_each-desc()
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 706b585a1b9554cb1ede5108c733593b94a7e1c4 Gitweb: https://git.kernel.org/tip/706b585a1b9554cb1ede5108c733593b94a7e1c4 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:31 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:19 +01:00
powerpc/mpic_u3msi: Use msi_for_each-desc()
Replace the about to vanish iterators and make use of the filtering.
--- arch/powerpc/sysdev/mpic_u3msi.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-)
arch/powerpc/sysdev/mpic_u3msi.c +2 -7
@@ -104,17 +104,12 @@ static void u3msi_teardown_msi_irqs(struct pci_dev *pdev)struct msi_desc *entry;irq_hw_number_t hwirq; -for_each_pci_msi_entry (entry, pdev) { -if (!entry->irq) -continue ; - +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { hwirq =virq_to_hw (entry->irq);irq_set_msi_desc (entry->irq,NULL );irq_dispose_mapping (entry->irq);msi_bitmap_free_hwirqs (&msi_mpic->msi_bitmap, hwirq,1 ); } - -return ; }static int u3msi_setup_msi_irqs (struct pci_dev *pdev,int nvec,int type)
@@ -136,7 +131,7 @@ static int u3msi_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)return -ENXIO ; } -for_each_pci_msi_entry (entry, pdev) { +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_NOTASSOCIATED ) { hwirq =msi_bitmap_alloc_hwirqs (&msi_mpic->msi_bitmap,1 );if (hwirq <0 ) {pr_debug ("u3msi: failed allocating hwirq\n" );
PATCH v2 19/31 PCI: hv: Rework MSI handling
In reply to Thomas GleixnerReplace the about to vanish iterators and make use of the filtering. Take the descriptor lock around the iterators.
--- drivers/pci/controller/pci-hyperv.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-)
drivers/pci/controller/pci-hyperv.c +10 -5
@@ -3445,18 +3445,23 @@ static int hv_pci_suspend(struct hv_devistatic int hv_pci_restore_msi_msg (struct pci_dev *pdev,void *arg) { -struct msi_desc *entry;struct irq_data *irq_data; +struct msi_desc *entry; +int ret =0 ; -for_each_pci_msi_entry (entry, pdev) { +msi_lock_descs (&pdev->dev); +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { irq_data =irq_get_irq_data (entry->irq); -if (WARN_ON_ONCE (!irq_data)) -return -EINVAL ; +if (WARN_ON_ONCE (!irq_data)) { + ret = -EINVAL ; +break ; + }hv_compose_msi_msg (irq_data, &entry->msg); } +msi_unlock_descs (&pdev->dev); -return 0 ; +return ret; }/*
Re: [patch V2 19/31] PCI: hv: Rework MSI handling
Quoted 4 lines · Thomas Gleixner
Replace the about to vanish iterators and make use of the filtering. Take the descriptor lock around the iterators.
Signed-off-by Thomas Gleixner <[email protected]>
Quoted 36 lines
--- drivers/pci/controller/pci-hyperv.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-)drivers/pci/controller/pci-hyperv.c +10
-5@@ -3445,18 +3445,23 @@ static int hv_pci_suspend(struct hv_devistatic int hv_pci_restore_msi_msg (struct pci_dev *pdev,void *arg) { -struct msi_desc *entry;struct irq_data *irq_data; +struct msi_desc *entry; +int ret =0 ; -for_each_pci_msi_entry (entry, pdev) { +msi_lock_descs (&pdev->dev); +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { irq_data =irq_get_irq_data (entry->irq); -if (WARN_ON_ONCE (!irq_data)) -return -EINVAL ; +if (WARN_ON_ONCE (!irq_data)) { + ret = -EINVAL ; +break ; + }hv_compose_msi_msg (irq_data, &entry->msg); } +msi_unlock_descs (&pdev->dev); -return 0 ; +return ret; }/*
[tip: irq/msi] PCI: hv: Rework MSI handling
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: dc2b453290c471266a2d56d7ead981e3c5cea05e Gitweb: https://git.kernel.org/tip/dc2b453290c471266a2d56d7ead981e3c5cea05e Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:33 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:19 +01:00
PCI: hv: Rework MSI handling
Replace the about to vanish iterators and make use of the filtering. Take the descriptor lock around the iterators.
--- drivers/pci/controller/pci-hyperv.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-)
drivers/pci/controller/pci-hyperv.c +10 -5
@@ -3445,18 +3445,23 @@ static int hv_pci_suspend(struct hv_device *hdev)static int hv_pci_restore_msi_msg (struct pci_dev *pdev,void *arg) { -struct msi_desc *entry;struct irq_data *irq_data; +struct msi_desc *entry; +int ret =0 ; -for_each_pci_msi_entry (entry, pdev) { +msi_lock_descs (&pdev->dev); +msi_for_each_desc (entry, &pdev->dev,MSI_DESC_ASSOCIATED ) { irq_data =irq_get_irq_data (entry->irq); -if (WARN_ON_ONCE (!irq_data)) -return -EINVAL ; +if (WARN_ON_ONCE (!irq_data)) { + ret = -EINVAL ; +break ; + }hv_compose_msi_msg (irq_data, &entry->msg); } +msi_unlock_descs (&pdev->dev); -return 0 ; +return ret; }/*
PATCH v2 20/31 NTB/msi: Convert to msi_on_each_desc()
In reply to Thomas GleixnerReplace the about to vanish iterators, make use of the filtering and take the descriptor lock around the iteration.
--- drivers/ntb/msi.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)
drivers/ntb/msi.c +13 -6
@@ -108,8 +108,10 @@ int ntb_msi_setup_mws(struct ntb_dev *ntif (!ntb->msi)return -EINVAL ; - desc =first_msi_entry (&ntb->pdev->dev); +msi_lock_descs (&ntb->pdev->dev); + desc =msi_first_desc (&ntb->pdev->dev,MSI_DESC_ASSOCIATED ); addr = desc->msg.address_lo + ((uint64_t )desc->msg.address_hi <<32 ); +msi_unlock_descs (&ntb->pdev->dev);for (peer =0 ; peer <ntb_peer_port_count (ntb); peer++) { peer_widx =ntb_peer_highest_mw_idx (ntb, peer);
@@ -281,13 +283,15 @@ int ntbm_msi_request_threaded_irq(struct const char *name, void *dev_id, struct ntb_msi_desc *msi_desc) { + struct device *dev = &ntb->pdev->dev;struct msi_desc *entry;int ret;if (!ntb->msi)return -EINVAL ; -for_each_pci_msi_entry (entry, ntb->pdev) { +msi_lock_descs (dev); +msi_for_each_desc (entry, dev,MSI_DESC_ASSOCIATED ) {if (irq_has_action (entry->irq))continue ;
@@ -304,14 +308,17 @@ int ntbm_msi_request_threaded_irq(struct ret =ntbm_msi_setup_callback (ntb, entry, msi_desc);if (ret) {devm_free_irq (&ntb->dev, entry->irq, dev_id); -return ret; + goto unlock; } - -return entry->irq; + ret = entry->irq; + goto unlock; } + ret = -ENODEV ; -return -ENODEV ; +unlock: +msi_unlock_descs (dev); +return ret; }EXPORT_SYMBOL (ntbm_msi_request_threaded_irq);
[tip: irq/msi] NTB/msi: Convert to msi_on_each_desc()
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 68e3183580bea59e764d33283875e5f0adc753f3 Gitweb: https://git.kernel.org/tip/68e3183580bea59e764d33283875e5f0adc753f3 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:34 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:19 +01:00
NTB/msi: Convert to msi_on_each_desc()
Replace the about to vanish iterators, make use of the filtering and take the descriptor lock around the iteration.
--- drivers/ntb/msi.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)
drivers/ntb/msi.c +13 -6
@@ -108,8 +108,10 @@ int ntb_msi_setup_mws(struct ntb_dev *ntb)if (!ntb->msi)return -EINVAL ; - desc =first_msi_entry (&ntb->pdev->dev); +msi_lock_descs (&ntb->pdev->dev); + desc =msi_first_desc (&ntb->pdev->dev,MSI_DESC_ASSOCIATED ); addr = desc->msg.address_lo + ((uint64_t )desc->msg.address_hi <<32 ); +msi_unlock_descs (&ntb->pdev->dev);for (peer =0 ; peer <ntb_peer_port_count (ntb); peer++) { peer_widx =ntb_peer_highest_mw_idx (ntb, peer);
@@ -281,13 +283,15 @@ int ntbm_msi_request_threaded_irq(struct ntb_dev *ntb, irq_handler_t handler, const char *name, void *dev_id, struct ntb_msi_desc *msi_desc) { + struct device *dev = &ntb->pdev->dev;struct msi_desc *entry;int ret;if (!ntb->msi)return -EINVAL ; -for_each_pci_msi_entry (entry, ntb->pdev) { +msi_lock_descs (dev); +msi_for_each_desc (entry, dev,MSI_DESC_ASSOCIATED ) {if (irq_has_action (entry->irq))continue ;
@@ -304,14 +308,17 @@ int ntbm_msi_request_threaded_irq(struct ntb_dev *ntb, irq_handler_t handler, ret =ntbm_msi_setup_callback (ntb, entry, msi_desc);if (ret) {devm_free_irq (&ntb->dev, entry->irq, dev_id); -return ret; + goto unlock; } - -return entry->irq; + ret = entry->irq; + goto unlock; } + ret = -ENODEV ; -return -ENODEV ; +unlock: +msi_unlock_descs (dev); +return ret; }EXPORT_SYMBOL (ntbm_msi_request_threaded_irq);
PATCH v2 21/31 soc: ti: ti_sci_inta_msi: Rework MSI descriptor allocation
In reply to Thomas GleixnerProtect the allocation properly and use the core allocation and free mechanism.
No functional change intended.
--- drivers/soc/ti/ti_sci_inta_msi.c | 71 +++++++++++++-------------------------- 1 file changed, 25 insertions(+), 46 deletions(-)
drivers/soc/ti/ti_sci_inta_msi.c +25 -46
@@ -51,6 +51,7 @@ struct irq_domain *ti_sci_inta_msi_creatstruct irq_domain *domain;ti_sci_inta_msi_update_chip_ops (info); + info->flags |=MSI_FLAG_FREE_MSI_DESCS ; domain =msi_create_irq_domain (fwnode, info, parent);if (domain)
@@ -60,50 +61,31 @@ struct irq_domain *ti_sci_inta_msi_creat }EXPORT_SYMBOL_GPL (ti_sci_inta_msi_create_irq_domain); -static void ti_sci_inta_msi_free_descs (struct device *dev) -{ -struct msi_desc *desc, *tmp; - -list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { -list_del (&desc->list); -free_msi_entry (desc); - } -} -static int ti_sci_inta_msi_alloc_descs (struct device *dev,struct ti_sci_resource *res) { -struct msi_desc *msi_desc; +struct msi_desc msi_desc;int set, i, count =0 ; +memset (&msi_desc,0 ,sizeof (msi_desc)); +for (set =0 ; set < res->sets; set++) { -for (i =0 ; i < res->desc[set].num; i++) { - msi_desc =alloc_msi_entry (dev,1 ,NULL ); -if (!msi_desc) { -ti_sci_inta_msi_free_descs (dev); -return -ENOMEM ; - } - - msi_desc->msi_index = res->desc[set].start + i; -INIT_LIST_HEAD (&msi_desc->list); -list_add_tail (&msi_desc->list,dev_to_msi_list (dev)); - count++; +for (i =0 ; i < res->desc[set].num; i++, count++) { + msi_desc.msi_index = res->desc[set].start + i; +if (msi_add_msi_desc (dev, &msi_desc)) + goto fail; } -for (i =0 ; i < res->desc[set].num_sec; i++) { - msi_desc =alloc_msi_entry (dev,1 ,NULL ); -if (!msi_desc) { -ti_sci_inta_msi_free_descs (dev); -return -ENOMEM ; - } - - msi_desc->msi_index = res->desc[set].start_sec + i; -INIT_LIST_HEAD (&msi_desc->list); -list_add_tail (&msi_desc->list,dev_to_msi_list (dev)); - count++; + +for (i =0 ; i < res->desc[set].num_sec; i++, count++) { + msi_desc.msi_index = res->desc[set].start_sec + i; +if (msi_add_msi_desc (dev, &msi_desc)) + goto fail; } } -return count; +fail: +msi_free_msi_descs (dev); +return -ENOMEM ; } int ti_sci_inta_msi_domain_alloc_irqs(struct device *dev,
@@ -124,20 +106,18 @@ int ti_sci_inta_msi_domain_alloc_irqs(stif (ret)return ret; +msi_lock_descs (dev); nvec =ti_sci_inta_msi_alloc_descs (dev, res); -if (nvec <=0 ) -return nvec; - - ret =msi_domain_alloc_irqs (msi_domain, dev, nvec); -if (ret) { -dev_err (dev,"Failed to allocate IRQs %d\n" , ret); - goto cleanup; +if (nvec <=0 ) { + ret = nvec; + goto unlock; } -return 0 ; - -cleanup: -ti_sci_inta_msi_free_descs (&pdev->dev); + ret =msi_domain_alloc_irqs_descs_locked (msi_domain, dev, nvec); +if (ret) +dev_err (dev,"Failed to allocate IRQs %d\n" , ret); +unlock: +msi_unlock_descs (dev);return ret; }EXPORT_SYMBOL_GPL (ti_sci_inta_msi_domain_alloc_irqs);
@@ -145,6 +125,5 @@ EXPORT_SYMBOL_GPL(ti_sci_inta_msi_domainvoid ti_sci_inta_msi_domain_free_irqs (struct device *dev) {msi_domain_free_irqs (dev->msi.domain, dev); -ti_sci_inta_msi_free_descs (dev); }EXPORT_SYMBOL_GPL (ti_sci_inta_msi_domain_free_irqs);
Re: [patch V2 21/31] soc: ti: ti_sci_inta_msi: Rework MSI descriptor allocation
Quoted 2 lines · Thomas Gleixner
No functional change intended.
Famous last words.
Review
Quoted 8 lines
static int ti_sci_inta_msi_alloc_descs(struct device *dev,
(quoted diff) +2
-1struct ti_sci_resource *res) { - struct msi_desc *msi_desc; + struct msi_desc msi_desc; int set, i, count = 0; + memset(&msi_desc, 0, sizeof(msi_desc));
This fails to initialize msi_desc.nvec_used which makes the subsequent interrupt allocation fail. Delta fix below.
Thanks,
tglx
---
drivers/soc/ti/ti_sci_inta_msi.c +1 -0
@@ -68,6 +68,7 @@ static int ti_sci_inta_msi_alloc_descs(sint set, i, count =0 ;memset (&msi_desc,0 ,sizeof (msi_desc)); + msi_desc.nvec_used =1 ;for (set =0 ; set < res->sets; set++) {for (i =0 ; i < res->desc[set].num; i++, count++) {
[tip: irq/msi] soc: ti: ti_sci_inta_msi: Rework MSI descriptor allocation
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 49fbfdc222504b7f0d83a58c13869d599cf8e184 Gitweb: https://git.kernel.org/tip/49fbfdc222504b7f0d83a58c13869d599cf8e184 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:36 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:19 +01:00
soc: ti: ti_sci_inta_msi: Rework MSI descriptor allocation
Protect the allocation properly and use the core allocation and free mechanism.
No functional change intended.
--- drivers/soc/ti/ti_sci_inta_msi.c | 72 +++++++++++-------------------- 1 file changed, 26 insertions(+), 46 deletions(-)
drivers/soc/ti/ti_sci_inta_msi.c +26 -46
@@ -51,6 +51,7 @@ struct irq_domain *ti_sci_inta_msi_create_irq_domain(struct fwnode_handle *fwnodstruct irq_domain *domain;ti_sci_inta_msi_update_chip_ops (info); + info->flags |=MSI_FLAG_FREE_MSI_DESCS ; domain =msi_create_irq_domain (fwnode, info, parent);if (domain)
@@ -60,50 +61,32 @@ struct irq_domain *ti_sci_inta_msi_create_irq_domain(struct fwnode_handle *fwnod }EXPORT_SYMBOL_GPL (ti_sci_inta_msi_create_irq_domain); -static void ti_sci_inta_msi_free_descs (struct device *dev) -{ -struct msi_desc *desc, *tmp; - -list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { -list_del (&desc->list); -free_msi_entry (desc); - } -} -static int ti_sci_inta_msi_alloc_descs (struct device *dev,struct ti_sci_resource *res) { -struct msi_desc *msi_desc; +struct msi_desc msi_desc;int set, i, count =0 ; +memset (&msi_desc,0 ,sizeof (msi_desc)); + msi_desc.nvec_used =1 ; +for (set =0 ; set < res->sets; set++) { -for (i =0 ; i < res->desc[set].num; i++) { - msi_desc =alloc_msi_entry (dev,1 ,NULL ); -if (!msi_desc) { -ti_sci_inta_msi_free_descs (dev); -return -ENOMEM ; - } - - msi_desc->msi_index = res->desc[set].start + i; -INIT_LIST_HEAD (&msi_desc->list); -list_add_tail (&msi_desc->list,dev_to_msi_list (dev)); - count++; +for (i =0 ; i < res->desc[set].num; i++, count++) { + msi_desc.msi_index = res->desc[set].start + i; +if (msi_add_msi_desc (dev, &msi_desc)) + goto fail; } -for (i =0 ; i < res->desc[set].num_sec; i++) { - msi_desc =alloc_msi_entry (dev,1 ,NULL ); -if (!msi_desc) { -ti_sci_inta_msi_free_descs (dev); -return -ENOMEM ; - } - - msi_desc->msi_index = res->desc[set].start_sec + i; -INIT_LIST_HEAD (&msi_desc->list); -list_add_tail (&msi_desc->list,dev_to_msi_list (dev)); - count++; + +for (i =0 ; i < res->desc[set].num_sec; i++, count++) { + msi_desc.msi_index = res->desc[set].start_sec + i; +if (msi_add_msi_desc (dev, &msi_desc)) + goto fail; } } -return count; +fail: +msi_free_msi_descs (dev); +return -ENOMEM ; } int ti_sci_inta_msi_domain_alloc_irqs(struct device *dev,
@@ -124,20 +107,18 @@ int ti_sci_inta_msi_domain_alloc_irqs(struct device *dev,if (ret)return ret; +msi_lock_descs (dev); nvec =ti_sci_inta_msi_alloc_descs (dev, res); -if (nvec <=0 ) -return nvec; - - ret =msi_domain_alloc_irqs (msi_domain, dev, nvec); -if (ret) { -dev_err (dev,"Failed to allocate IRQs %d\n" , ret); - goto cleanup; +if (nvec <=0 ) { + ret = nvec; + goto unlock; } -return 0 ; - -cleanup: -ti_sci_inta_msi_free_descs (&pdev->dev); + ret =msi_domain_alloc_irqs_descs_locked (msi_domain, dev, nvec); +if (ret) +dev_err (dev,"Failed to allocate IRQs %d\n" , ret); +unlock: +msi_unlock_descs (dev);return ret; }EXPORT_SYMBOL_GPL (ti_sci_inta_msi_domain_alloc_irqs);
@@ -145,6 +126,5 @@ EXPORT_SYMBOL_GPL(ti_sci_inta_msi_domain_alloc_irqs);void ti_sci_inta_msi_domain_free_irqs (struct device *dev) {msi_domain_free_irqs (dev->msi.domain, dev); -ti_sci_inta_msi_free_descs (dev); }EXPORT_SYMBOL_GPL (ti_sci_inta_msi_domain_free_irqs);
PATCH v2 22/31 soc: ti: ti_sci_inta_msi: Remove ti_sci_inta_msi_domain_free_irqs()
In reply to Thomas GleixnerThe function has no users and is pointless now that the core frees the MSI descriptors, which means potential users can just use msi_domain_free_irqs().
--- drivers/soc/ti/ti_sci_inta_msi.c | 6 ------ include/linux/soc/ti/ti_sci_inta_msi.h | 1 - 2 files changed, 7 deletions(-)
drivers/soc/ti/ti_sci_inta_msi.c +0 -6
@@ -121,9 +121,3 @@ int ti_sci_inta_msi_domain_alloc_irqs(streturn ret; }EXPORT_SYMBOL_GPL (ti_sci_inta_msi_domain_alloc_irqs); - -void ti_sci_inta_msi_domain_free_irqs (struct device *dev) -{ -msi_domain_free_irqs (dev->msi.domain, dev); -} -EXPORT_SYMBOL_GPL (ti_sci_inta_msi_domain_free_irqs);
include/linux/soc/ti/ti_sci_inta_msi.h +0 -1
@@ -18,5 +18,4 @@ struct irq_domain struct irq_domain *parent);int ti_sci_inta_msi_domain_alloc_irqs (struct device *dev,struct ti_sci_resource *res); -void ti_sci_inta_msi_domain_free_irqs (struct device *dev);#endif /* __INCLUDE_LINUX_IRQCHIP_TI_SCI_INTA_H */
[tip: irq/msi] soc: ti: ti_sci_inta_msi: Remove ti_sci_inta_msi_domain_free_irqs()
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 7ad321a5eadb52b4af1c577dda51783e08235ea7 Gitweb: https://git.kernel.org/tip/7ad321a5eadb52b4af1c577dda51783e08235ea7 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:37 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:19 +01:00
soc: ti: ti_sci_inta_msi: Remove ti_sci_inta_msi_domain_free_irqs()
The function has no users and is pointless now that the core frees the MSI descriptors, which means potential users can just use msi_domain_free_irqs().
--- drivers/soc/ti/ti_sci_inta_msi.c | 6 ------ include/linux/soc/ti/ti_sci_inta_msi.h | 1 - 2 files changed, 7 deletions(-)
drivers/soc/ti/ti_sci_inta_msi.c +0 -6
@@ -122,9 +122,3 @@ unlock:return ret; }EXPORT_SYMBOL_GPL (ti_sci_inta_msi_domain_alloc_irqs); - -void ti_sci_inta_msi_domain_free_irqs (struct device *dev) -{ -msi_domain_free_irqs (dev->msi.domain, dev); -} -EXPORT_SYMBOL_GPL (ti_sci_inta_msi_domain_free_irqs);
include/linux/soc/ti/ti_sci_inta_msi.h +0 -1
@@ -18,5 +18,4 @@ struct irq_domain struct irq_domain *parent);int ti_sci_inta_msi_domain_alloc_irqs (struct device *dev,struct ti_sci_resource *res); -void ti_sci_inta_msi_domain_free_irqs (struct device *dev);#endif /* __INCLUDE_LINUX_IRQCHIP_TI_SCI_INTA_H */
PATCH v2 23/31 bus: fsl-mc-msi: Simplify MSI descriptor handling
In reply to Thomas GleixnerLet the MSI irq domain code handle descriptor allocation and free.
--- drivers/bus/fsl-mc/fsl-mc-msi.c | 61 ++-------------------------------------- 1 file changed, 4 insertions(+), 57 deletions(-)
drivers/bus/fsl-mc/fsl-mc-msi.c +4 -57
@@ -170,6 +170,7 @@ struct irq_domain *fsl_mc_msi_create_irqfsl_mc_msi_update_dom_ops (info);if (info->flags &MSI_FLAG_USE_DEF_CHIP_OPS )fsl_mc_msi_update_chip_ops (info); + info->flags |=MSI_FLAG_ALLOC_SIMPLE_MSI_DESCS |MSI_FLAG_FREE_MSI_DESCS ; domain =msi_create_irq_domain (fwnode, info, parent);if (domain)
@@ -210,45 +211,7 @@ struct irq_domain *fsl_mc_find_msi_domaireturn msi_domain; } -static void fsl_mc_msi_free_descs (struct device *dev) -{ -struct msi_desc *desc, *tmp; - -list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { -list_del (&desc->list); -free_msi_entry (desc); - } -} - -static int fsl_mc_msi_alloc_descs (struct device *dev,unsigned int irq_count) - -{ -unsigned int i; -int error; -struct msi_desc *msi_desc; - -for (i =0 ; i < irq_count; i++) { - msi_desc =alloc_msi_entry (dev,1 ,NULL ); -if (!msi_desc) { -dev_err (dev,"Failed to allocate msi entry\n" ); - error = -ENOMEM ; - goto cleanup_msi_descs; - } - - msi_desc->msi_index = i; -INIT_LIST_HEAD (&msi_desc->list); -list_add_tail (&msi_desc->list,dev_to_msi_list (dev)); - } - -return 0 ; - -cleanup_msi_descs: -fsl_mc_msi_free_descs (dev); -return error; -} - -int fsl_mc_msi_domain_alloc_irqs (struct device *dev, -unsigned int irq_count) +int fsl_mc_msi_domain_alloc_irqs (struct device *dev,unsigned int irq_count) {struct irq_domain *msi_domain;int error;
@@ -261,28 +224,17 @@ int fsl_mc_msi_domain_alloc_irqs(structif (error)return error; -if (!list_empty (dev_to_msi_list (dev))) +if (msi_first_desc (dev,MSI_DESC_ALL ))return -EINVAL ; - error =fsl_mc_msi_alloc_descs (dev, irq_count); -if (error <0 ) -return error; -/* * NOTE: Calling this function will trigger the invocation of the * its_fsl_mc_msi_prepare() callback */ error =msi_domain_alloc_irqs (msi_domain, dev, irq_count); -if (error) { +if (error)dev_err (dev,"Failed to allocate IRQs\n" ); - goto cleanup_msi_descs; - } - -return 0 ; - -cleanup_msi_descs: -fsl_mc_msi_free_descs (dev);return error; }
@@ -295,9 +247,4 @@ void fsl_mc_msi_domain_free_irqs(structreturn ;msi_domain_free_irqs (msi_domain, dev); - -if (list_empty (dev_to_msi_list (dev))) -return ; - -fsl_mc_msi_free_descs (dev); }
[tip: irq/msi] bus: fsl-mc-msi: Simplify MSI descriptor handling
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: e8604b1447b4a0c178019bdf809a4d52e1c235b6 Gitweb: https://git.kernel.org/tip/e8604b1447b4a0c178019bdf809a4d52e1c235b6 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:39 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:19 +01:00
bus: fsl-mc-msi: Simplify MSI descriptor handling
Let the MSI irq domain code handle descriptor allocation and free.
--- drivers/bus/fsl-mc/fsl-mc-msi.c | 61 ++------------------------------ 1 file changed, 4 insertions(+), 57 deletions(-)
drivers/bus/fsl-mc/fsl-mc-msi.c +4 -57
@@ -170,6 +170,7 @@ struct irq_domain *fsl_mc_msi_create_irq_domain(struct fwnode_handle *fwnode,fsl_mc_msi_update_dom_ops (info);if (info->flags &MSI_FLAG_USE_DEF_CHIP_OPS )fsl_mc_msi_update_chip_ops (info); + info->flags |=MSI_FLAG_ALLOC_SIMPLE_MSI_DESCS |MSI_FLAG_FREE_MSI_DESCS ; domain =msi_create_irq_domain (fwnode, info, parent);if (domain)
@@ -210,45 +211,7 @@ struct irq_domain *fsl_mc_find_msi_domain(struct device *dev)return msi_domain; } -static void fsl_mc_msi_free_descs (struct device *dev) -{ -struct msi_desc *desc, *tmp; - -list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { -list_del (&desc->list); -free_msi_entry (desc); - } -} - -static int fsl_mc_msi_alloc_descs (struct device *dev,unsigned int irq_count) - -{ -unsigned int i; -int error; -struct msi_desc *msi_desc; - -for (i =0 ; i < irq_count; i++) { - msi_desc =alloc_msi_entry (dev,1 ,NULL ); -if (!msi_desc) { -dev_err (dev,"Failed to allocate msi entry\n" ); - error = -ENOMEM ; - goto cleanup_msi_descs; - } - - msi_desc->msi_index = i; -INIT_LIST_HEAD (&msi_desc->list); -list_add_tail (&msi_desc->list,dev_to_msi_list (dev)); - } - -return 0 ; - -cleanup_msi_descs: -fsl_mc_msi_free_descs (dev); -return error; -} - -int fsl_mc_msi_domain_alloc_irqs (struct device *dev, -unsigned int irq_count) +int fsl_mc_msi_domain_alloc_irqs (struct device *dev,unsigned int irq_count) {struct irq_domain *msi_domain;int error;
@@ -261,28 +224,17 @@ int fsl_mc_msi_domain_alloc_irqs(struct device *dev,if (error)return error; -if (!list_empty (dev_to_msi_list (dev))) +if (msi_first_desc (dev,MSI_DESC_ALL ))return -EINVAL ; - error =fsl_mc_msi_alloc_descs (dev, irq_count); -if (error <0 ) -return error; -/* * NOTE: Calling this function will trigger the invocation of the * its_fsl_mc_msi_prepare() callback */ error =msi_domain_alloc_irqs (msi_domain, dev, irq_count); -if (error) { +if (error)dev_err (dev,"Failed to allocate IRQs\n" ); - goto cleanup_msi_descs; - } - -return 0 ; - -cleanup_msi_descs: -fsl_mc_msi_free_descs (dev);return error; }
@@ -295,9 +247,4 @@ void fsl_mc_msi_domain_free_irqs(struct device *dev)return ;msi_domain_free_irqs (msi_domain, dev); - -if (list_empty (dev_to_msi_list (dev))) -return ; - -fsl_mc_msi_free_descs (dev); }
PATCH v2 24/31 platform-msi: Let core code handle MSI descriptors
In reply to Thomas GleixnerUse the core functionality for platform MSI interrupt domains. The platform device MSI interrupt domains will be converted in a later step.
--- drivers/base/platform-msi.c | 112 ++++++++++++++++++-------------------------- 1 file changed, 48 insertions(+), 64 deletions(-)
drivers/base/platform-msi.c +48 -64
@@ -107,57 +107,6 @@ static void platform_msi_update_chip_ops info->flags &= ~MSI_FLAG_LEVEL_CAPABLE ; } -static void platform_msi_free_descs (struct device *dev,int base,int nvec) -{ -struct msi_desc *desc, *tmp; - -list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { -if (desc->msi_index >= base && - desc->msi_index < (base + nvec)) { -list_del (&desc->list); -free_msi_entry (desc); - } - } -} - -static int platform_msi_alloc_descs_with_irq (struct device *dev,int virq, -int nvec) -{ -struct msi_desc *desc; -int i, base =0 ; - -if (!list_empty (dev_to_msi_list (dev))) { - desc =list_last_entry (dev_to_msi_list (dev), - struct msi_desc, list); - base = desc->msi_index +1 ; - } - -for (i =0 ; i < nvec; i++) { - desc =alloc_msi_entry (dev,1 ,NULL ); -if (!desc) -break ; - - desc->msi_index = base + i; - desc->irq = virq ? virq + i :0 ; - -list_add_tail (&desc->list,dev_to_msi_list (dev)); - } - -if (i != nvec) { -/* Clean up the mess */ -platform_msi_free_descs (dev, base, nvec); - -return -ENOMEM ; - } - -return 0 ; -} - -static int platform_msi_alloc_descs (struct device *dev,int nvec) -{ -return platform_msi_alloc_descs_with_irq (dev,0 , nvec); -} -/** * platform_msi_create_irq_domain - Create a platform MSI interrupt domain * @fwnode: Optional fwnode of the interrupt controller
@@ -180,7 +129,8 @@ struct irq_domain *platform_msi_create_iplatform_msi_update_dom_ops (info);if (info->flags &MSI_FLAG_USE_DEF_CHIP_OPS )platform_msi_update_chip_ops (info); - info->flags |=MSI_FLAG_DEV_SYSFS ; + info->flags |=MSI_FLAG_DEV_SYSFS |MSI_FLAG_ALLOC_SIMPLE_MSI_DESCS | +MSI_FLAG_FREE_MSI_DESCS ; domain =msi_create_irq_domain (fwnode, info, parent);if (domain)
@@ -262,20 +212,10 @@ int platform_msi_domain_alloc_irqs(strucif (err)return err; - err =platform_msi_alloc_descs (dev, nvec); -if (err) - goto out_free_priv_data; - err =msi_domain_alloc_irqs (dev->msi.domain, dev, nvec);if (err) - goto out_free_desc; - -return 0 ; +platform_msi_free_priv_data (dev); -out_free_desc: -platform_msi_free_descs (dev,0 , nvec); -out_free_priv_data: -platform_msi_free_priv_data (dev);return err; }EXPORT_SYMBOL_GPL (platform_msi_domain_alloc_irqs);
@@ -287,7 +227,6 @@ EXPORT_SYMBOL_GPL(platform_msi_domain_alvoid platform_msi_domain_free_irqs (struct device *dev) {msi_domain_free_irqs (dev->msi.domain, dev); -platform_msi_free_descs (dev,0 ,MAX_DEV_MSIS );platform_msi_free_priv_data (dev); }EXPORT_SYMBOL_GPL (platform_msi_domain_free_irqs);
@@ -361,6 +300,51 @@ struct irq_domain *return NULL ; } +static void platform_msi_free_descs (struct device *dev,int base,int nvec) +{ +struct msi_desc *desc, *tmp; + +list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { +if (desc->msi_index >= base && + desc->msi_index < (base + nvec)) { +list_del (&desc->list); +free_msi_entry (desc); + } + } +} + +static int platform_msi_alloc_descs_with_irq (struct device *dev,int virq, +int nvec) +{ +struct msi_desc *desc; +int i, base =0 ; + +if (!list_empty (dev_to_msi_list (dev))) { + desc =list_last_entry (dev_to_msi_list (dev), + struct msi_desc, list); + base = desc->msi_index +1 ; + } + +for (i =0 ; i < nvec; i++) { + desc =alloc_msi_entry (dev,1 ,NULL ); +if (!desc) +break ; + + desc->msi_index = base + i; + desc->irq = virq + i; + +list_add_tail (&desc->list,dev_to_msi_list (dev)); + } + +if (i != nvec) { +/* Clean up the mess */ +platform_msi_free_descs (dev, base, nvec); +return -ENOMEM ; + } + +return 0 ; +} +/** * platform_msi_device_domain_free - Free interrupts associated with a platform-msi * device domain
[tip: irq/msi] platform-msi: Let core code handle MSI descriptors
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 653b50c5f96918238e0b51e783b291f6e9e692f9 Gitweb: https://git.kernel.org/tip/653b50c5f96918238e0b51e783b291f6e9e692f9 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:41 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:19 +01:00
platform-msi: Let core code handle MSI descriptors
Use the core functionality for platform MSI interrupt domains. The platform device MSI interrupt domains will be converted in a later step.
--- drivers/base/platform-msi.c | 112 +++++++++++++++-------------------- 1 file changed, 48 insertions(+), 64 deletions(-)
drivers/base/platform-msi.c +48 -64
@@ -107,57 +107,6 @@ static void platform_msi_update_chip_ops(struct msi_domain_info *info) info->flags &= ~MSI_FLAG_LEVEL_CAPABLE ; } -static void platform_msi_free_descs (struct device *dev,int base,int nvec) -{ -struct msi_desc *desc, *tmp; - -list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { -if (desc->msi_index >= base && - desc->msi_index < (base + nvec)) { -list_del (&desc->list); -free_msi_entry (desc); - } - } -} - -static int platform_msi_alloc_descs_with_irq (struct device *dev,int virq, -int nvec) -{ -struct msi_desc *desc; -int i, base =0 ; - -if (!list_empty (dev_to_msi_list (dev))) { - desc =list_last_entry (dev_to_msi_list (dev), - struct msi_desc, list); - base = desc->msi_index +1 ; - } - -for (i =0 ; i < nvec; i++) { - desc =alloc_msi_entry (dev,1 ,NULL ); -if (!desc) -break ; - - desc->msi_index = base + i; - desc->irq = virq ? virq + i :0 ; - -list_add_tail (&desc->list,dev_to_msi_list (dev)); - } - -if (i != nvec) { -/* Clean up the mess */ -platform_msi_free_descs (dev, base, nvec); - -return -ENOMEM ; - } - -return 0 ; -} - -static int platform_msi_alloc_descs (struct device *dev,int nvec) -{ -return platform_msi_alloc_descs_with_irq (dev,0 , nvec); -} -/** * platform_msi_create_irq_domain - Create a platform MSI interrupt domain * @fwnode: Optional fwnode of the interrupt controller
@@ -180,7 +129,8 @@ struct irq_domain *platform_msi_create_irq_domain(struct fwnode_handle *fwnode,platform_msi_update_dom_ops (info);if (info->flags &MSI_FLAG_USE_DEF_CHIP_OPS )platform_msi_update_chip_ops (info); - info->flags |=MSI_FLAG_DEV_SYSFS ; + info->flags |=MSI_FLAG_DEV_SYSFS |MSI_FLAG_ALLOC_SIMPLE_MSI_DESCS | +MSI_FLAG_FREE_MSI_DESCS ; domain =msi_create_irq_domain (fwnode, info, parent);if (domain)
@@ -262,20 +212,10 @@ int platform_msi_domain_alloc_irqs(struct device *dev, unsigned int nvec,if (err)return err; - err =platform_msi_alloc_descs (dev, nvec); -if (err) - goto out_free_priv_data; - err =msi_domain_alloc_irqs (dev->msi.domain, dev, nvec);if (err) - goto out_free_desc; - -return 0 ; +platform_msi_free_priv_data (dev); -out_free_desc: -platform_msi_free_descs (dev,0 , nvec); -out_free_priv_data: -platform_msi_free_priv_data (dev);return err; }EXPORT_SYMBOL_GPL (platform_msi_domain_alloc_irqs);
@@ -287,7 +227,6 @@ EXPORT_SYMBOL_GPL(platform_msi_domain_alloc_irqs);void platform_msi_domain_free_irqs (struct device *dev) {msi_domain_free_irqs (dev->msi.domain, dev); -platform_msi_free_descs (dev,0 ,MAX_DEV_MSIS );platform_msi_free_priv_data (dev); }EXPORT_SYMBOL_GPL (platform_msi_domain_free_irqs);
@@ -361,6 +300,51 @@ free_priv:return NULL ; } +static void platform_msi_free_descs (struct device *dev,int base,int nvec) +{ +struct msi_desc *desc, *tmp; + +list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { +if (desc->msi_index >= base && + desc->msi_index < (base + nvec)) { +list_del (&desc->list); +free_msi_entry (desc); + } + } +} + +static int platform_msi_alloc_descs_with_irq (struct device *dev,int virq, +int nvec) +{ +struct msi_desc *desc; +int i, base =0 ; + +if (!list_empty (dev_to_msi_list (dev))) { + desc =list_last_entry (dev_to_msi_list (dev), + struct msi_desc, list); + base = desc->msi_index +1 ; + } + +for (i =0 ; i < nvec; i++) { + desc =alloc_msi_entry (dev,1 ,NULL ); +if (!desc) +break ; + + desc->msi_index = base + i; + desc->irq = virq + i; + +list_add_tail (&desc->list,dev_to_msi_list (dev)); + } + +if (i != nvec) { +/* Clean up the mess */ +platform_msi_free_descs (dev, base, nvec); +return -ENOMEM ; + } + +return 0 ; +} +/** * platform_msi_device_domain_free - Free interrupts associated with a platform-msi * device domain
PATCH v2 25/31 platform-msi: Simplify platform device MSI code
In reply to Thomas GleixnerThe allocation code is overly complex. It tries to have the MSI index space packed, which is not working when an interrupt is freed. There is no requirement for this. The only requirement is that the MSI index is unique.
Move the MSI descriptor allocation into msi_domain_populate_irqs() and use the Linux interrupt number as MSI index which fulfils the unique requirement.
This requires to lock the MSI descriptors which makes the lock order reverse to the regular MSI alloc/free functions vs. the domain mutex. Assign a seperate lockdep class for these MSI device domains.
--- drivers/base/platform-msi.c | 88 +++++++++----------------------------------- kernel/irq/msi.c | 45 ++++++++++------------ 2 files changed, 39 insertions(+), 94 deletions(-)
drivers/base/platform-msi.c +18 -70
@@ -246,6 +246,8 @@ void *platform_msi_get_host_data(structreturn data->host_data; } +static struct lock_class_key platform_device_msi_lock_class; +/** * __platform_msi_create_device_domain - Create a platform-msi device domain *
@@ -278,6 +280,13 @@ struct irq_domain *if (err)return NULL ; +/* +* Use a separate lock class for the MSI descriptor mutex on +* platform MSI device domains because the descriptor mutex nests +* into the domain mutex. See alloc/free below. +*/ +lockdep_set_class (&dev->msi.data->mutex, &platform_device_msi_lock_class); + data = dev->msi.data->platform_data; data->host_data = host_data; domain = irq_domain_create_hierarchy(dev->msi.domain, 0,
@@ -300,75 +309,23 @@ struct irq_domain *return NULL ; } -static void platform_msi_free_descs (struct device *dev,int base,int nvec) -{ -struct msi_desc *desc, *tmp; - -list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { -if (desc->msi_index >= base && - desc->msi_index < (base + nvec)) { -list_del (&desc->list); -free_msi_entry (desc); - } - } -} - -static int platform_msi_alloc_descs_with_irq (struct device *dev,int virq, -int nvec) -{ -struct msi_desc *desc; -int i, base =0 ; - -if (!list_empty (dev_to_msi_list (dev))) { - desc =list_last_entry (dev_to_msi_list (dev), - struct msi_desc, list); - base = desc->msi_index +1 ; - } - -for (i =0 ; i < nvec; i++) { - desc =alloc_msi_entry (dev,1 ,NULL ); -if (!desc) -break ; - - desc->msi_index = base + i; - desc->irq = virq + i; - -list_add_tail (&desc->list,dev_to_msi_list (dev)); - } - -if (i != nvec) { -/* Clean up the mess */ -platform_msi_free_descs (dev, base, nvec); -return -ENOMEM ; - } - -return 0 ; -} -/** * platform_msi_device_domain_free - Free interrupts associated with a platform-msi * device domain * * @domain: The platform-msi device domain * @virq: The base irq from which to perform the free operation -* @nvec: How many interrupts to free from @virq +* @nr_irqs: How many interrupts to free from @virq */ void platform_msi_device_domain_free (struct irq_domain *domain,unsigned int virq, -unsigned int nvec) +unsigned int nr_irqs) {struct platform_msi_priv_data *data = domain->host_data; -struct msi_desc *desc, *tmp; -for_each_msi_entry_safe (desc, tmp, data->dev) { -if (WARN_ON (!desc->irq || desc->nvec_used !=1 )) -return ; -if (!(desc->irq >= virq && desc->irq < (virq + nvec))) -continue ; - -irq_domain_free_irqs_common (domain, desc->irq,1 ); -list_del (&desc->list); -free_msi_entry (desc); - } +msi_lock_descs (data->dev); +irq_domain_free_irqs_common (domain, virq, nr_irqs); +msi_free_msi_descs_range (data->dev,MSI_DESC_ALL , virq, virq + nr_irqs -1 ); +msi_unlock_descs (data->dev); }/**
@@ -377,7 +334,7 @@ void platform_msi_device_domain_free(str* * @domain: The platform-msi device domain * @virq: The base irq from which to perform the allocate operation -* @nr_irqs: How many interrupts to free from @virq +* @nr_irqs: How many interrupts to allocate from @virq * * Return 0 on success, or an error code on failure. Must be called * with irq_domain_mutex held (which can only be done as part of a
@@ -387,16 +344,7 @@ int platform_msi_device_domain_alloc(str unsigned int nr_irqs) {struct platform_msi_priv_data *data = domain->host_data; -int err; - - err =platform_msi_alloc_descs_with_irq (data->dev, virq, nr_irqs); -if (err) -return err; - - err =msi_domain_populate_irqs (domain->parent, data->dev, - virq, nr_irqs, &data->arg); -if (err) -platform_msi_device_domain_free (domain, virq, nr_irqs); +struct device *dev = data->dev; -return err; +return msi_domain_populate_irqs (domain->parent, dev, virq, nr_irqs, &data->arg); }
kernel/irq/msi.c +21 -24
64 lines not on this page · raw message
[tip: irq/msi] platform-msi: Simplify platform device MSI code
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: a80713fea3d12344e1da18f9113c74cdb3c463f1 Gitweb: https://git.kernel.org/tip/a80713fea3d12344e1da18f9113c74cdb3c463f1 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:42 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:19 +01:00
platform-msi: Simplify platform device MSI code
The allocation code is overly complex. It tries to have the MSI index space packed, which is not working when an interrupt is freed. There is no requirement for this. The only requirement is that the MSI index is unique.
Move the MSI descriptor allocation into msi_domain_populate_irqs() and use the Linux interrupt number as MSI index which fulfils the unique requirement.
This requires to lock the MSI descriptors which makes the lock order reverse to the regular MSI alloc/free functions vs. the domain mutex. Assign a seperate lockdep class for these MSI device domains.
--- drivers/base/platform-msi.c | 88 +++++++----------------------------- kernel/irq/msi.c | 45 ++++++++---------- 2 files changed, 39 insertions(+), 94 deletions(-)
drivers/base/platform-msi.c +18 -70
@@ -246,6 +246,8 @@ void *platform_msi_get_host_data(struct irq_domain *domain)return data->host_data; } +static struct lock_class_key platform_device_msi_lock_class; +/** * __platform_msi_create_device_domain - Create a platform-msi device domain *
@@ -278,6 +280,13 @@ __platform_msi_create_device_domain(struct device *dev,if (err)return NULL ; +/* +* Use a separate lock class for the MSI descriptor mutex on +* platform MSI device domains because the descriptor mutex nests +* into the domain mutex. See alloc/free below. +*/ +lockdep_set_class (&dev->msi.data->mutex, &platform_device_msi_lock_class); + data = dev->msi.data->platform_data; data->host_data = host_data; domain = irq_domain_create_hierarchy(dev->msi.domain, 0,
@@ -300,75 +309,23 @@ free_priv:return NULL ; } -static void platform_msi_free_descs (struct device *dev,int base,int nvec) -{ -struct msi_desc *desc, *tmp; - -list_for_each_entry_safe (desc, tmp,dev_to_msi_list (dev), list) { -if (desc->msi_index >= base && - desc->msi_index < (base + nvec)) { -list_del (&desc->list); -free_msi_entry (desc); - } - } -} - -static int platform_msi_alloc_descs_with_irq (struct device *dev,int virq, -int nvec) -{ -struct msi_desc *desc; -int i, base =0 ; - -if (!list_empty (dev_to_msi_list (dev))) { - desc =list_last_entry (dev_to_msi_list (dev), - struct msi_desc, list); - base = desc->msi_index +1 ; - } - -for (i =0 ; i < nvec; i++) { - desc =alloc_msi_entry (dev,1 ,NULL ); -if (!desc) -break ; - - desc->msi_index = base + i; - desc->irq = virq + i; - -list_add_tail (&desc->list,dev_to_msi_list (dev)); - } - -if (i != nvec) { -/* Clean up the mess */ -platform_msi_free_descs (dev, base, nvec); -return -ENOMEM ; - } - -return 0 ; -} -/** * platform_msi_device_domain_free - Free interrupts associated with a platform-msi * device domain * * @domain: The platform-msi device domain * @virq: The base irq from which to perform the free operation -* @nvec: How many interrupts to free from @virq +* @nr_irqs: How many interrupts to free from @virq */ void platform_msi_device_domain_free (struct irq_domain *domain,unsigned int virq, -unsigned int nvec) +unsigned int nr_irqs) {struct platform_msi_priv_data *data = domain->host_data; -struct msi_desc *desc, *tmp; -for_each_msi_entry_safe (desc, tmp, data->dev) { -if (WARN_ON (!desc->irq || desc->nvec_used !=1 )) -return ; -if (!(desc->irq >= virq && desc->irq < (virq + nvec))) -continue ; - -irq_domain_free_irqs_common (domain, desc->irq,1 ); -list_del (&desc->list); -free_msi_entry (desc); - } +msi_lock_descs (data->dev); +irq_domain_free_irqs_common (domain, virq, nr_irqs); +msi_free_msi_descs_range (data->dev,MSI_DESC_ALL , virq, virq + nr_irqs -1 ); +msi_unlock_descs (data->dev); }/**
@@ -377,7 +334,7 @@ void platform_msi_device_domain_free(struct irq_domain *domain, unsigned int vir* * @domain: The platform-msi device domain * @virq: The base irq from which to perform the allocate operation -* @nr_irqs: How many interrupts to free from @virq +* @nr_irqs: How many interrupts to allocate from @virq * * Return 0 on success, or an error code on failure. Must be called * with irq_domain_mutex held (which can only be done as part of a
@@ -387,16 +344,7 @@ int platform_msi_device_domain_alloc(struct irq_domain *domain, unsigned int vir unsigned int nr_irqs) {struct platform_msi_priv_data *data = domain->host_data; -int err; - - err =platform_msi_alloc_descs_with_irq (data->dev, virq, nr_irqs); -if (err) -return err; - - err =msi_domain_populate_irqs (domain->parent, data->dev, - virq, nr_irqs, &data->arg); -if (err) -platform_msi_device_domain_free (domain, virq, nr_irqs); +struct device *dev = data->dev; -return err; +return msi_domain_populate_irqs (domain->parent, dev, virq, nr_irqs, &data->arg); }
kernel/irq/msi.c +21 -24
64 lines not on this page · raw message
PATCH v2 26/31 genirq/msi: Make interrupt allocation less convoluted
In reply to Thomas GleixnerThere is no real reason to do several loops over the MSI descriptors instead of just doing one loop. In case of an error everything is undone anyway so it does not matter whether it's a partial or a full rollback.
--- .clang-format | 1 include/linux/msi.h | 6 -- kernel/irq/msi.c | 129 +++++++++++++++++++++++++++------------------------- 3 files changed, 69 insertions(+), 67 deletions(-)
.clang-format +0 -1
@@ -216,7 +216,6 @@ ExperimentalAutoDetectBinPacking: false - 'for_each_migratetype_order' - 'for_each_msi_entry' - 'for_each_msi_entry_safe' - - 'for_each_msi_vector' - 'for_each_net' - 'for_each_net_continue_reverse' - 'for_each_netdev'
include/linux/msi.h +0 -6
@@ -223,12 +223,6 @@ struct msi_desc *msi_next_desc(struct de list_for_each_entry((desc), dev_to_msi_list((dev)), list)#define for_each_msi_entry_safe (desc, tmp, dev) \ list_for_each_entry_safe((desc), (tmp), dev_to_msi_list((dev)), list) -#define for_each_msi_vector (desc, __irq, dev) \ - for_each_msi_entry((desc), (dev)) \ - if ((desc)->irq) \ - for (__irq = (desc)->irq; \ - __irq < ((desc)->irq + (desc)->nvec_used); \ - __irq++)#ifdef CONFIG_IRQ_MSI_IOMMU static inline const void *msi_desc_get_iommu_cookie (struct msi_desc *desc)
kernel/irq/msi.c +69 -60
167 lines not on this page · raw message
[tip: irq/msi] genirq/msi: Make interrupt allocation less convoluted
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: ef8dd01538ea2553ab101ddce6a85a321406d9c0 Gitweb: https://git.kernel.org/tip/ef8dd01538ea2553ab101ddce6a85a321406d9c0 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:44 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:20 +01:00
genirq/msi: Make interrupt allocation less convoluted
There is no real reason to do several loops over the MSI descriptors instead of just doing one loop. In case of an error everything is undone anyway so it does not matter whether it's a partial or a full rollback.
--- .clang-format | 1 +- include/linux/msi.h | 6 +-- kernel/irq/msi.c | 129 +++++++++++++++++++++++-------------------- 3 files changed, 69 insertions(+), 67 deletions(-)
.clang-format +0 -1
@@ -216,7 +216,6 @@ ForEachMacros: - 'for_each_migratetype_order' - 'for_each_msi_entry' - 'for_each_msi_entry_safe' - - 'for_each_msi_vector' - 'for_each_net' - 'for_each_net_continue_reverse' - 'for_each_netdev'
include/linux/msi.h +0 -6
@@ -206,12 +206,6 @@ struct msi_desc *msi_next_desc(struct device *dev, enum msi_desc_filter filter); list_for_each_entry((desc), dev_to_msi_list((dev)), list)#define for_each_msi_entry_safe (desc, tmp, dev) \ list_for_each_entry_safe((desc), (tmp), dev_to_msi_list((dev)), list) -#define for_each_msi_vector (desc, __irq, dev) \ - for_each_msi_entry((desc), (dev)) \ - if ((desc)->irq) \ - for (__irq = (desc)->irq; \ - __irq < ((desc)->irq + (desc)->nvec_used); \ - __irq++)#ifdef CONFIG_IRQ_MSI_IOMMU static inline const void *msi_desc_get_iommu_cookie (struct msi_desc *desc)
kernel/irq/msi.c +69 -60
167 lines not on this page · raw message
PATCH v2 27/31 genirq/msi: Convert to new functions
In reply to Thomas GleixnerUse the new iterator functions and add locking where required.
--- kernel/irq/msi.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)
kernel/irq/msi.c +14 -9
@@ -348,6 +348,7 @@ EXPORT_SYMBOL_GPL(msi_next_desc);unsigned int msi_get_virq (struct device *dev,unsigned int index) {struct msi_desc *desc; +unsigned int ret =0 ;bool pcimsi;if (!dev->msi.data)
@@ -355,11 +356,12 @@ unsigned int msi_get_virq(struct device pcimsi =msi_device_has_property (dev,MSI_PROP_PCI_MSI ); -for_each_msi_entry (desc, dev) { +msi_lock_descs (dev); +msi_for_each_desc (desc, dev,MSI_DESC_ASSOCIATED ) {/* PCI-MSI has only one descriptor for multiple interrupts. */ if (pcimsi) { -if (desc->irq && index < desc->nvec_used) -return desc->irq + index; +if (index < desc->nvec_used) + ret = desc->irq + index;break ; }
@@ -367,10 +369,13 @@ unsigned int msi_get_virq(struct device* PCI-MSIX and platform MSI use a descriptor per * interrupt. */ -if (desc->msi_index == index) -return desc->irq; +if (desc->msi_index == index) { + ret = desc->irq; +break ; + } } -return 0 ; +msi_unlock_descs (dev); +return ret; }EXPORT_SYMBOL_GPL (msi_get_virq);
@@ -401,7 +406,7 @@ static const struct attribute_group **msint i;/* Determine how many msi entries we have */ -for_each_msi_entry (entry, dev) +msi_for_each_desc (entry, dev,MSI_DESC_ALL ) num_msi += entry->nvec_used;if (!num_msi)return NULL ;
@@ -411,7 +416,7 @@ static const struct attribute_group **msif (!msi_attrs)return ERR_PTR (-ENOMEM ); -for_each_msi_entry (entry, dev) { +msi_for_each_desc (entry, dev,MSI_DESC_ALL ) {for (i =0 ; i < entry->nvec_used; i++) { msi_dev_attr =kzalloc (sizeof (*msi_dev_attr),GFP_KERNEL );if (!msi_dev_attr)
@@ -831,7 +836,7 @@ static bool msi_check_reservation_mode(s* Checking the first MSI descriptor is sufficient. MSIX supports * masking and MSI does so when the can_mask attribute is set. */ - desc =first_msi_entry (dev); + desc =msi_first_desc (dev,MSI_DESC_ALL );return desc->pci.msi_attrib.is_msix || desc->pci.msi_attrib.can_mask; }
[tip: irq/msi] genirq/msi: Convert to new functions
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 495c66aca3da704e063fa373fdbe371e71d3f4ee Gitweb: https://git.kernel.org/tip/495c66aca3da704e063fa373fdbe371e71d3f4ee Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:45 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:20 +01:00
genirq/msi: Convert to new functions
Use the new iterator functions and add locking where required.
--- kernel/irq/msi.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)
kernel/irq/msi.c +14 -9
@@ -320,6 +320,7 @@ EXPORT_SYMBOL_GPL(msi_next_desc);unsigned int msi_get_virq (struct device *dev,unsigned int index) {struct msi_desc *desc; +unsigned int ret =0 ;bool pcimsi;if (!dev->msi.data)
@@ -327,11 +328,12 @@ unsigned int msi_get_virq(struct device *dev, unsigned int index) pcimsi =dev_is_pci (dev) ?to_pci_dev (dev)->msi_enabled : false; -for_each_msi_entry (desc, dev) { +msi_lock_descs (dev); +msi_for_each_desc (desc, dev,MSI_DESC_ASSOCIATED ) {/* PCI-MSI has only one descriptor for multiple interrupts. */ if (pcimsi) { -if (desc->irq && index < desc->nvec_used) -return desc->irq + index; +if (index < desc->nvec_used) + ret = desc->irq + index;break ; }
@@ -339,10 +341,13 @@ unsigned int msi_get_virq(struct device *dev, unsigned int index)* PCI-MSIX and platform MSI use a descriptor per * interrupt. */ -if (desc->msi_index == index) -return desc->irq; +if (desc->msi_index == index) { + ret = desc->irq; +break ; + } } -return 0 ; +msi_unlock_descs (dev); +return ret; }EXPORT_SYMBOL_GPL (msi_get_virq);
@@ -373,7 +378,7 @@ static const struct attribute_group **msi_populate_sysfs(struct device *dev)int i;/* Determine how many msi entries we have */ -for_each_msi_entry (entry, dev) +msi_for_each_desc (entry, dev,MSI_DESC_ALL ) num_msi += entry->nvec_used;if (!num_msi)return NULL ;
@@ -383,7 +388,7 @@ static const struct attribute_group **msi_populate_sysfs(struct device *dev)if (!msi_attrs)return ERR_PTR (-ENOMEM ); -for_each_msi_entry (entry, dev) { +msi_for_each_desc (entry, dev,MSI_DESC_ALL ) {for (i =0 ; i < entry->nvec_used; i++) { msi_dev_attr =kzalloc (sizeof (*msi_dev_attr),GFP_KERNEL );if (!msi_dev_attr)
@@ -803,7 +808,7 @@ static bool msi_check_reservation_mode(struct irq_domain *domain,* Checking the first MSI descriptor is sufficient. MSIX supports * masking and MSI does so when the can_mask attribute is set. */ - desc =first_msi_entry (dev); + desc =msi_first_desc (dev,MSI_DESC_ALL );return desc->pci.msi_attrib.is_msix || desc->pci.msi_attrib.can_mask; }
PATCH v2 28/31 genirq/msi: Mop up old interfaces
In reply to Thomas GleixnerGet rid of the old iterators, alloc/free functions and adjust the core code accordingly.
--- include/linux/msi.h | 15 --------------- kernel/irq/msi.c | 31 +++++++++++++++---------------- 2 files changed, 15 insertions(+), 31 deletions(-)
include/linux/msi.h +0 -15
@@ -214,15 +214,7 @@ struct msi_desc *msi_next_desc(struct defor ((desc) =msi_first_desc ((dev), (filter)); (desc); \ (desc) = msi_next_desc((dev), (filter))) -/* Helpers to hide struct msi_desc implementation details */#define msi_desc_to_dev (desc) ((desc)->dev) -#define dev_to_msi_list (dev) (&(dev)->msi.data->list) -#define first_msi_entry (dev) \ - list_first_entry(dev_to_msi_list((dev)), struct msi_desc, list) -#define for_each_msi_entry (desc, dev) \ - list_for_each_entry((desc), dev_to_msi_list((dev)), list) -#define for_each_msi_entry_safe (desc, tmp, dev) \ - list_for_each_entry_safe((desc), (tmp), dev_to_msi_list((dev)), list)#ifdef CONFIG_IRQ_MSI_IOMMU static inline const void *msi_desc_get_iommu_cookie (struct msi_desc *desc)
@@ -248,10 +240,6 @@ static inline void msi_desc_set_iommu_co#endif #ifdef CONFIG_PCI_MSI -#define first_pci_msi_entry (pdev) first_msi_entry(&(pdev)->dev) -#define for_each_pci_msi_entry (desc, pdev) \ - for_each_msi_entry((desc), &(pdev)->dev) -struct pci_dev *msi_desc_to_pci_dev (struct msi_desc *desc);void pci_write_msi_msg (unsigned int irq,struct msi_msg *msg);#else /* CONFIG_PCI_MSI */
@@ -273,9 +261,6 @@ static inline void msi_free_msi_descs(stmsi_free_msi_descs_range (dev,MSI_DESC_ALL ,0 ,MSI_MAX_INDEX ); } -struct msi_desc *alloc_msi_entry (struct device *dev,int nvec, -const struct irq_affinity_desc *affinity); -void free_msi_entry (struct msi_desc *entry);void __pci_read_msi_msg (struct msi_desc *entry,struct msi_msg *msg);void __pci_write_msi_msg (struct msi_desc *entry,struct msi_msg *msg);
kernel/irq/msi.c +15 -16
@@ -19,8 +19,10 @@#include "internals.h" +#define dev_to_msi_list (dev) (&(dev)->msi.data->list) +/** -* alloc_msi_entry - Allocate an initialized msi_desc +* msi_alloc_desc - Allocate an initialized msi_desc * @dev: Pointer to the device for which this is allocated * @nvec: The number of vectors used in this entry * @affinity: Optional pointer to an affinity mask array size of @nvec
@@ -30,12 +32,11 @@* * Return: pointer to allocated &msi_desc on success or %NULL on failure */ -struct msi_desc *alloc_msi_entry (struct device *dev,int nvec, -const struct irq_affinity_desc *affinity) +static struct msi_desc *msi_alloc_desc (struct device *dev,int nvec, +const struct irq_affinity_desc *affinity) { -struct msi_desc *desc; +struct msi_desc *desc =kzalloc (sizeof (*desc),GFP_KERNEL ); - desc =kzalloc (sizeof (*desc),GFP_KERNEL );if (!desc)return NULL ;
@@ -43,21 +44,19 @@ struct msi_desc *alloc_msi_entry(struct desc->dev = dev; desc->nvec_used = nvec;if (affinity) { - desc->affinity =kmemdup (affinity, - nvec *sizeof (*desc->affinity),GFP_KERNEL ); + desc->affinity =kmemdup (affinity, nvec *sizeof (*desc->affinity),GFP_KERNEL );if (!desc->affinity) {kfree (desc);return NULL ; } } -return desc; } -void free_msi_entry (struct msi_desc *entry) +static void msi_free_desc (struct msi_desc *desc) { -kfree (entry->affinity); -kfree (entry); +kfree (desc->affinity); +kfree (desc); }/**
@@ -73,7 +72,7 @@ int msi_add_msi_desc(struct device *dev,lockdep_assert_held (&dev->msi.data->mutex); - desc =alloc_msi_entry (dev, init_desc->nvec_used, init_desc->affinity); + desc =msi_alloc_desc (dev, init_desc->nvec_used, init_desc->affinity);if (!desc)return -ENOMEM ;
@@ -102,7 +101,7 @@ static int msi_add_simple_msi_descs(strulockdep_assert_held (&dev->msi.data->mutex);for (i =0 ; i < ndesc; i++) { - desc =alloc_msi_entry (dev,1 ,NULL ); + desc =msi_alloc_desc (dev,1 ,NULL );if (!desc) goto fail; desc->msi_index = index + i;
@@ -114,7 +113,7 @@ static int msi_add_simple_msi_descs(stru fail:list_for_each_entry_safe (desc, tmp, &list, list) {list_del (&desc->list); -free_msi_entry (desc); +msi_free_desc (desc); }return -ENOMEM ; }
@@ -141,7 +140,7 @@ void msi_free_msi_descs_range(struct devif (desc->msi_index < first_index || desc->msi_index > last_index)continue ;list_del (&desc->list); -free_msi_entry (desc); +msi_free_desc (desc); } }
@@ -762,7 +761,7 @@ int msi_domain_populate_irqs(struct irq_msi_lock_descs (dev);for (virq = virq_base; virq < virq_base + nvec; virq++) { - desc =alloc_msi_entry (dev,1 ,NULL ); + desc =msi_alloc_desc (dev,1 ,NULL );if (!desc) { ret = -ENOMEM ; goto fail;
[tip: irq/msi] genirq/msi: Mop up old interfaces
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: cc9a246dbf6bdef56d9eee296a1db52dd0607976 Gitweb: https://git.kernel.org/tip/cc9a246dbf6bdef56d9eee296a1db52dd0607976 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:47 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:20 +01:00
genirq/msi: Mop up old interfaces
Get rid of the old iterators, alloc/free functions and adjust the core code accordingly.
--- include/linux/msi.h | 15 --------------- kernel/irq/msi.c | 31 +++++++++++++++---------------- 2 files changed, 15 insertions(+), 31 deletions(-)
include/linux/msi.h +0 -15
@@ -197,15 +197,7 @@ struct msi_desc *msi_next_desc(struct device *dev, enum msi_desc_filter filter);for ((desc) =msi_first_desc ((dev), (filter)); (desc); \ (desc) = msi_next_desc((dev), (filter))) -/* Helpers to hide struct msi_desc implementation details */#define msi_desc_to_dev (desc) ((desc)->dev) -#define dev_to_msi_list (dev) (&(dev)->msi.data->list) -#define first_msi_entry (dev) \ - list_first_entry(dev_to_msi_list((dev)), struct msi_desc, list) -#define for_each_msi_entry (desc, dev) \ - list_for_each_entry((desc), dev_to_msi_list((dev)), list) -#define for_each_msi_entry_safe (desc, tmp, dev) \ - list_for_each_entry_safe((desc), (tmp), dev_to_msi_list((dev)), list)#ifdef CONFIG_IRQ_MSI_IOMMU static inline const void *msi_desc_get_iommu_cookie (struct msi_desc *desc)
@@ -231,10 +223,6 @@ static inline void msi_desc_set_iommu_cookie(struct msi_desc *desc,#endif #ifdef CONFIG_PCI_MSI -#define first_pci_msi_entry (pdev) first_msi_entry(&(pdev)->dev) -#define for_each_pci_msi_entry (desc, pdev) \ - for_each_msi_entry((desc), &(pdev)->dev) -struct pci_dev *msi_desc_to_pci_dev (struct msi_desc *desc);void pci_write_msi_msg (unsigned int irq,struct msi_msg *msg);#else /* CONFIG_PCI_MSI */
@@ -256,9 +244,6 @@ static inline void msi_free_msi_descs(struct device *dev)msi_free_msi_descs_range (dev,MSI_DESC_ALL ,0 ,MSI_MAX_INDEX ); } -struct msi_desc *alloc_msi_entry (struct device *dev,int nvec, -const struct irq_affinity_desc *affinity); -void free_msi_entry (struct msi_desc *entry);void __pci_read_msi_msg (struct msi_desc *entry,struct msi_msg *msg);void __pci_write_msi_msg (struct msi_desc *entry,struct msi_msg *msg);
kernel/irq/msi.c +15 -16
@@ -19,8 +19,10 @@#include "internals.h" +#define dev_to_msi_list (dev) (&(dev)->msi.data->list) +/** -* alloc_msi_entry - Allocate an initialized msi_desc +* msi_alloc_desc - Allocate an initialized msi_desc * @dev: Pointer to the device for which this is allocated * @nvec: The number of vectors used in this entry * @affinity: Optional pointer to an affinity mask array size of @nvec
@@ -30,12 +32,11 @@* * Return: pointer to allocated &msi_desc on success or %NULL on failure */ -struct msi_desc *alloc_msi_entry (struct device *dev,int nvec, -const struct irq_affinity_desc *affinity) +static struct msi_desc *msi_alloc_desc (struct device *dev,int nvec, +const struct irq_affinity_desc *affinity) { -struct msi_desc *desc; +struct msi_desc *desc =kzalloc (sizeof (*desc),GFP_KERNEL ); - desc =kzalloc (sizeof (*desc),GFP_KERNEL );if (!desc)return NULL ;
@@ -43,21 +44,19 @@ struct msi_desc *alloc_msi_entry(struct device *dev, int nvec, desc->dev = dev; desc->nvec_used = nvec;if (affinity) { - desc->affinity =kmemdup (affinity, - nvec *sizeof (*desc->affinity),GFP_KERNEL ); + desc->affinity =kmemdup (affinity, nvec *sizeof (*desc->affinity),GFP_KERNEL );if (!desc->affinity) {kfree (desc);return NULL ; } } -return desc; } -void free_msi_entry (struct msi_desc *entry) +static void msi_free_desc (struct msi_desc *desc) { -kfree (entry->affinity); -kfree (entry); +kfree (desc->affinity); +kfree (desc); }/**
@@ -73,7 +72,7 @@ int msi_add_msi_desc(struct device *dev, struct msi_desc *init_desc)lockdep_assert_held (&dev->msi.data->mutex); - desc =alloc_msi_entry (dev, init_desc->nvec_used, init_desc->affinity); + desc =msi_alloc_desc (dev, init_desc->nvec_used, init_desc->affinity);if (!desc)return -ENOMEM ;
@@ -102,7 +101,7 @@ static int msi_add_simple_msi_descs(struct device *dev, unsigned int index, unsilockdep_assert_held (&dev->msi.data->mutex);for (i =0 ; i < ndesc; i++) { - desc =alloc_msi_entry (dev,1 ,NULL ); + desc =msi_alloc_desc (dev,1 ,NULL );if (!desc) goto fail; desc->msi_index = index + i;
@@ -114,7 +113,7 @@ static int msi_add_simple_msi_descs(struct device *dev, unsigned int index, unsi fail:list_for_each_entry_safe (desc, tmp, &list, list) {list_del (&desc->list); -free_msi_entry (desc); +msi_free_desc (desc); }return -ENOMEM ; }
@@ -141,7 +140,7 @@ void msi_free_msi_descs_range(struct device *dev, enum msi_desc_filter filter,if (desc->msi_index < first_index || desc->msi_index > last_index)continue ;list_del (&desc->list); -free_msi_entry (desc); +msi_free_desc (desc); } }
@@ -745,7 +744,7 @@ int msi_domain_populate_irqs(struct irq_domain *domain, struct device *dev,msi_lock_descs (dev);for (virq = virq_base; virq < virq_base + nvec; virq++) { - desc =alloc_msi_entry (dev,1 ,NULL ); + desc =msi_alloc_desc (dev,1 ,NULL );if (!desc) { ret = -ENOMEM ; goto fail;
PATCH v2 29/31 genirq/msi: Add abuse prevention comment to msi header
In reply to Thomas Gleixner--- include/linux/msi.h | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
include/linux/msi.h +14 -0
@@ -2,6 +2,20 @@#ifndef LINUX_MSI_H #define LINUX_MSI_H +/* +* This header file contains MSI data structures and functions which are +* only relevant for: +* - Interrupt core code +* - PCI/MSI core code +* - MSI interrupt domain implementations +* - IOMMU, low level VFIO, NTB and other justified exceptions +* dealing with low level MSI details. +* +* Regular device drivers have no business with any of these functions and +* especially storing MSI descriptor pointers in random code is considered +* abuse. The only function which is relevant for drivers is msi_get_virq(). +*/ +#include <linux/cpumask.h> #include <linux/mutex.h> #include <linux/list.h>
Re: [patch V2 29/31] genirq/msi: Add abuse prevention comment to msi header
Quoted 19 lines · Thomas Gleixner
Signed-off-by Thomas Gleixner <[email protected]>--- include/linux/msi.h | 14 ++++++++++++++ 1 file changed, 14 insertions(+)include/linux/msi.h +7
-0@@ -2,6 +2,20 @@#ifndef LINUX_MSI_H #define LINUX_MSI_H +/* +* This header file contains MSI data structures and functions which are +* only relevant for: +* - Interrupt core code +* - PCI/MSI core code +* - MSI interrupt domain implementations +* - IOMMU, low level VFIO, NTB and other justified exceptions
include/linux/msi.h line 21
Quoted 10 lines
include/linux/msi.h +7
-0+* dealing with low level MSI details. +* +* Regular device drivers have no business with any of these functions and +* especially storing MSI descriptor pointers in random code is considered +* abuse. The only function which is relevant for drivers is msi_get_virq(). +*/ +#include <linux/cpumask.h> #include <linux/mutex.h> #include <linux/list.h>
Ah, to be young and idealistic and hope that kernel developers read comments in header files :)
You might want to add this to the driver-api kernel doc build?
Anyway, looks good to me:
Re: [patch V2 29/31] genirq/msi: Add abuse prevention comment to msi header
Quoted 7 lines · Greg Kroah-Hartman
Quoted 4 lines · Thomas Gleixner
#include <
linux/cpumask.h>
#include <linux/mutex.h>
#include <linux/list.h>Ah, to be young and idealistic and hope that kernel developers read comments in header files :)
Hope dies last.
Quoted 1 line
You might want to add this to the driver-api kernel doc build?
When I do the next round of refactoring, I'm going to move the functions which are available for drivers into a separate header file.
Thanks,
tglx
[tip: irq/msi] genirq/msi: Add abuse prevention comment to msi header
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: ef3350c53d2aac65cf1c4ecc968bbb1de5f421ea Gitweb: https://git.kernel.org/tip/ef3350c53d2aac65cf1c4ecc968bbb1de5f421ea Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:49 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:20 +01:00
genirq/msi: Add abuse prevention comment to msi header
Hope dies last.
--- include/linux/msi.h | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
include/linux/msi.h +14 -0
@@ -2,6 +2,20 @@#ifndef LINUX_MSI_H #define LINUX_MSI_H +/* +* This header file contains MSI data structures and functions which are +* only relevant for: +* - Interrupt core code +* - PCI/MSI core code +* - MSI interrupt domain implementations +* - IOMMU, low level VFIO, NTB and other justified exceptions +* dealing with low level MSI details. +* +* Regular device drivers have no business with any of these functions and +* especially storing MSI descriptor pointers in random code is considered +* abuse. The only function which is relevant for drivers is msi_get_virq(). +*/ +#include <linux/cpumask.h> #include <linux/mutex.h> #include <linux/list.h>
PATCH v2 30/31 genirq/msi: Simplify sysfs handling
In reply to Thomas GleixnerThe sysfs handling for MSI is a convoluted maze and it is in the way of supporting dynamic expansion of the MSI-X vectors because it only supports a one off bulk population/free of the sysfs entries.
Change it to do:
1) Creating an empty sysfs attribute group when msi_device_data is allocated
2) Populate the entries when the MSI descriptor is initialized
3) Free the entries when a MSI descriptor is detached from a Linux interrupt.
4) Provide functions for the legacy non-irqdomain fallback code to do a bulk population/free. This code won't support dynamic expansion.
This makes the code simpler and reduces the number of allocations as the empty attribute group can be shared.
--- include/linux/msi.h | 8 +- kernel/irq/msi.c | 196 +++++++++++++++++++++++----------------------------- 2 files changed, 95 insertions(+), 109 deletions(-)
include/linux/msi.h +5 -3
@@ -72,7 +72,7 @@ struct irq_data;struct msi_desc ;struct pci_dev ;struct platform_msi_priv_data ; -struct attribute_group ; +struct device_attribute ;void __get_cached_msi_msg (struct msi_desc *entry,struct msi_msg *msg);#ifdef CONFIG_GENERIC_MSI_IRQ
@@ -130,6 +130,7 @@ struct pci_msi_desc {* @dev: Pointer to the device which uses this descriptor * @msg: The last set MSI message cached for reuse * @affinity: Optional pointer to a cpu affinity mask for this descriptor +* @sysfs_attr: Pointer to sysfs device attribute * * @write_msi_msg: Callback that may be called when the MSI message * address or data changes
@@ -149,6 +150,9 @@ struct msi_desc {#ifdef CONFIG_IRQ_MSI_IOMMU const void *iommu_cookie;#endif +#ifdef CONFIG_SYSFS +struct device_attribute *sysfs_attrs; +#endif void (*write_msi_msg)(struct msi_desc *entry,void *data);void *write_msi_msg_data;
@@ -172,7 +176,6 @@ enum msi_desc_filter {/** * msi_device_data - MSI per device data * @properties: MSI properties which are interesting to drivers -* @attrs: Pointer to the sysfs attribute group * @platform_data: Platform-MSI specific data * @list: List of MSI descriptors associated to the device * @mutex: Mutex protecting the MSI list
@@ -180,7 +183,6 @@ enum msi_desc_filter {*/ struct msi_device_data {unsigned long properties; -const struct attribute_group **attrs;struct platform_msi_priv_data *platform_data;struct list_head list;struct mutex mutex;
kernel/irq/msi.c +90 -106
283 lines not on this page · raw message
[tip: irq/msi] genirq/msi: Simplify sysfs handling
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: bf5e758f02fc739589dcc6a3395c3a3eb77b5c90 Gitweb: https://git.kernel.org/tip/bf5e758f02fc739589dcc6a3395c3a3eb77b5c90 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:50 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:20 +01:00
genirq/msi: Simplify sysfs handling
The sysfs handling for MSI is a convoluted maze and it is in the way of supporting dynamic expansion of the MSI-X vectors because it only supports a one off bulk population/free of the sysfs entries.
Change it to do:
1) Creating an empty sysfs attribute group when msi_device_data is allocated
2) Populate the entries when the MSI descriptor is initialized
3) Free the entries when a MSI descriptor is detached from a Linux interrupt.
4) Provide functions for the legacy non-irqdomain fallback code to do a bulk population/free. This code won't support dynamic expansion.
This makes the code simpler and reduces the number of allocations as the empty attribute group can be shared.
--- include/linux/msi.h | 23 ++--- kernel/irq/msi.c | 198 +++++++++++++++++++------------------------ 2 files changed, 103 insertions(+), 118 deletions(-)
include/linux/msi.h +12 -11
@@ -71,7 +71,7 @@ struct irq_data;struct msi_desc ;struct pci_dev ;struct platform_msi_priv_data ; -struct attribute_group ; +struct device_attribute ;void __get_cached_msi_msg (struct msi_desc *entry,struct msi_msg *msg);#ifdef CONFIG_GENERIC_MSI_IRQ
@@ -129,6 +129,7 @@ struct pci_msi_desc {* @dev: Pointer to the device which uses this descriptor * @msg: The last set MSI message cached for reuse * @affinity: Optional pointer to a cpu affinity mask for this descriptor +* @sysfs_attr: Pointer to sysfs device attribute * * @write_msi_msg: Callback that may be called when the MSI message * address or data changes
@@ -148,6 +149,9 @@ struct msi_desc {#ifdef CONFIG_IRQ_MSI_IOMMU const void *iommu_cookie;#endif +#ifdef CONFIG_SYSFS +struct device_attribute *sysfs_attrs; +#endif void (*write_msi_msg)(struct msi_desc *entry,void *data);void *write_msi_msg_data;
@@ -171,7 +175,6 @@ enum msi_desc_filter {/** * msi_device_data - MSI per device data * @properties: MSI properties which are interesting to drivers -* @attrs: Pointer to the sysfs attribute group * @platform_data: Platform-MSI specific data * @list: List of MSI descriptors associated to the device * @mutex: Mutex protecting the MSI list
@@ -179,7 +182,6 @@ enum msi_desc_filter {*/ struct msi_device_data {unsigned long properties; -const struct attribute_group **attrs;struct platform_msi_priv_data *platform_data;struct list_head list;struct mutex mutex;
@@ -264,14 +266,6 @@ void __pci_write_msi_msg(struct msi_desc *entry, struct msi_msg *msg);void pci_msi_mask_irq (struct irq_data *data);void pci_msi_unmask_irq (struct irq_data *data); -#ifdef CONFIG_SYSFS -int msi_device_populate_sysfs (struct device *dev); -void msi_device_destroy_sysfs (struct device *dev); -#else /* CONFIG_SYSFS */ -static inline int msi_device_populate_sysfs (struct device *dev) {return 0 ; } -static inline void msi_device_destroy_sysfs (struct device *dev) { } -#endif /* !CONFIG_SYSFS */ -/* * The arch hooks to setup up msi irqs. Default functions are implemented * as weak symbols so that they /can/ be overriden by architecture specific
@@ -285,6 +279,13 @@ int arch_setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc);void arch_teardown_msi_irq (unsigned int irq);int arch_setup_msi_irqs (struct pci_dev *dev,int nvec,int type);void arch_teardown_msi_irqs (struct pci_dev *dev); +#ifdef CONFIG_SYSFS +int msi_device_populate_sysfs (struct device *dev); +void msi_device_destroy_sysfs (struct device *dev); +#else /* CONFIG_SYSFS */ +static inline int msi_device_populate_sysfs (struct device *dev) {return 0 ; } +static inline void msi_device_destroy_sysfs (struct device *dev) { } +#endif /* !CONFIG_SYSFS */ #endif /* CONFIG_PCI_MSI_ARCH_FALLBACKS */ /*
kernel/irq/msi.c +91 -107
284 lines not on this page · raw message
PATCH 1/1 genirq/msi: Populate sysfs entry only once
In reply to Thomas GleixnerThe MSI entries for multi-MSI are populated en bloc for the MSI descriptor, but the current code invokes the population inside the per interrupt loop which triggers a warning in the sysfs code and causes the interrupt allocation to fail.
Move it outside of the loop so it works correctly for single and multi-MSI.
--- kernel/irq/msi.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)
kernel/irq/msi.c +5 -6
@@ -887,12 +887,11 @@ int __msi_domain_alloc_irqs(struct irq_d ret =msi_init_virq (domain, virq + i, vflags);if (ret)return ret; - -if (info->flags &MSI_FLAG_DEV_SYSFS ) { - ret =msi_sysfs_populate_desc (dev, desc); -if (ret) -return ret; - } + } +if (info->flags &MSI_FLAG_DEV_SYSFS ) { + ret =msi_sysfs_populate_desc (dev, desc); +if (ret) +return ret; } allocated++; }
Re: [patch] genirq/msi: Populate sysfs entry only once
Quoted 24 lines · Thomas Gleixner
The MSI entries for multi-MSI are populated en bloc for the MSI descriptor, but the current code invokes the population inside the per interrupt loop which triggers a warning in the sysfs code and causes the interrupt allocation to fail.
Move it outside of the loop so it works correctly for single and multi-MSI.
Fixes bf5e758f02fc ("genirq/msi: Simplify sysfs handling")Reported-by Borislav Petkov <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>--- kernel/irq/msi.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)kernel/irq/msi.c +0
-4@@ -887,12 +887,11 @@ int __msi_domain_alloc_irqs(struct irq_d ret =msi_init_virq (domain, virq + i, vflags);if (ret)return ret; - -if (info->flags &MSI_FLAG_DEV_SYSFS ) { - ret =msi_sysfs_populate_desc (dev, desc); -if (ret)
kernel/irq/msi.c int __msi_domain_alloc_irqs(struct irq_d · line 897
Quoted 10 lines
kernel/irq/msi.c +5
-2-return ret; - } + } +if (info->flags &MSI_FLAG_DEV_SYSFS ) { + ret =msi_sysfs_populate_desc (dev, desc); +if (ret) +return ret; } allocated++; }
Yap, works.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquette[tip: irq/msi] genirq/msi: Populate sysfs entry only once
In reply to Thomas GleixnerThe following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: 74a5257a0c175810d620b5e631c4e7554955ac25 Gitweb: https://git.kernel.org/tip/74a5257a0c175810d620b5e631c4e7554955ac25 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 10 Jan 2022 19:12:45 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Mon, 10 Jan 2022 19:22:10 +01:00
genirq/msi: Populate sysfs entry only once
The MSI entries for multi-MSI are populated en bloc for the MSI descriptor, but the current code invokes the population inside the per interrupt loop which triggers a warning in the sysfs code and causes the interrupt allocation to fail.
Move it outside of the loop so it works correctly for single and multi-MSI.
--- kernel/irq/msi.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)
kernel/irq/msi.c +5 -6
@@ -887,12 +887,11 @@ int __msi_domain_alloc_irqs(struct irq_domain *domain, struct device *dev, ret =msi_init_virq (domain, virq + i, vflags);if (ret)return ret; - -if (info->flags &MSI_FLAG_DEV_SYSFS ) { - ret =msi_sysfs_populate_desc (dev, desc); -if (ret) -return ret; - } + } +if (info->flags &MSI_FLAG_DEV_SYSFS ) { + ret =msi_sysfs_populate_desc (dev, desc); +if (ret) +return ret; } allocated++; }
Re: [patch] genirq/msi: Populate sysfs entry only once
In reply to Thomas GleixnerQuoted 5 lines · Thomas Gleixner
The MSI entries for multi-MSI are populated en bloc for the MSI descriptor, but the current code invokes the population inside the per interrupt loop which triggers a warning in the sysfs code and causes the interrupt allocation to fail.
Quoted 8 lines
Move it outside of the loop so it works correctly for single and multi-MSI.
Fixes bf5e758f02fc ("genirq/msi: Simplify sysfs handling")Reported-by Borislav Petkov <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>--- kernel/irq/msi.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)
Re: [patch] genirq/msi: Populate sysfs entry only once
In reply to Thomas GleixnerQuoted 10 lines · Thomas Gleixner
The MSI entries for multi-MSI are populated en bloc for the MSI descriptor, but the current code invokes the population inside the per interrupt loop which triggers a warning in the sysfs code and causes the interrupt allocation to fail.
Move it outside of the loop so it works correctly for single and multi-MSI.
Fixes bf5e758f02fc ("genirq/msi: Simplify sysfs handling")Reported-by Borislav Petkov <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>
Thanks,
C.
Quoted 25 lines
--- kernel/irq/msi.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)kernel/irq/msi.c +5
-6@@ -887,12 +887,11 @@ int __msi_domain_alloc_irqs(struct irq_d ret =msi_init_virq (domain, virq + i, vflags);if (ret)return ret; - -if (info->flags &MSI_FLAG_DEV_SYSFS ) { - ret =msi_sysfs_populate_desc (dev, desc); -if (ret) -return ret; - } + } +if (info->flags &MSI_FLAG_DEV_SYSFS ) { + ret =msi_sysfs_populate_desc (dev, desc); +if (ret) +return ret; } allocated++; }
Re: [patch] genirq/msi: Populate sysfs entry only once
In reply to Thomas GleixnerHi Thomas,
Is this fix the same as below?
https://marc.info/?l=linux-kernel&m=164061119923119&w=2
Quoted 27 lines · Thomas Gleixner
The MSI entries for multi-MSI are populated en bloc for the MSI descriptor,
but the current code invokes the population inside the per interrupt loop which triggers a warning in the sysfs code and causes the interrupt allocation to fail.Move it outside of the loop so it works correctly for single and multi-MSI.
Fixes bf5e758f02fc ("genirq/msi: Simplify sysfs handling")Reported-by Borislav Petkov <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>--- kernel/irq/msi.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)kernel/irq/msi.c +0
-4@@ -887,12 +887,11 @@ int __msi_domain_alloc_irqs(struct irq_d ret =msi_init_virq (domain, virq + i, vflags);if (ret)return ret; - -if (info->flags &MSI_FLAG_DEV_SYSFS ) { - ret =msi_sysfs_populate_desc (dev, desc); -if (ret)
kernel/irq/msi.c int __msi_domain_alloc_irqs(struct irq_d · line 897
Quoted 10 lines
kernel/irq/msi.c +5
-2-return ret; - } + } +if (info->flags &MSI_FLAG_DEV_SYSFS ) { + ret =msi_sysfs_populate_desc (dev, desc); +if (ret) +return ret; } allocated++; }
---
Best Regards
Kunihiko Hayashi
Re: [patch] genirq/msi: Populate sysfs entry only once
Kunihiko,
Quoted 2 lines · Kunihiko Hayashi
Is this fix the same as below?
https://marc.info/?l=linux-kernel&m=164061119923119&w=2
pretty much the same, but I missed that patch. I was off for 2+ weeks and on return Boris poked me about this issue and I fixed it. Then I went ahead and marked all vacation mail read as I always do :)
So sorry for not noticing that patch.
Thanks,
Thomas
Re: [patch] genirq/msi: Populate sysfs entry only once
Hi Thomas,
Quoted 11 lines · Thomas Gleixner
Kunihiko,
Quoted 2 lines · Kunihiko Hayashi
Is this fix the same as below?
https://marc.info/?l=linux-kernel&m=164061119923119&w=2pretty much the same, but I missed that patch. I was off for 2+ weeks and on return Boris poked me about this issue and I fixed it. Then I went ahead and marked all vacation mail read as I always do :)
So sorry for not noticing that patch.
No problem. If this issue wansn't resolved, the PCIe controller wouldn't work properly, so I'm relieved to solve the issue and get your response.
Thank you,
---
Best Regards
Kunihiko Hayashi
PATCH v2 31/31 genirq/msi: Convert storage to xarray
In reply to Thomas GleixnerThe current linked list storage for MSI descriptors is suboptimal in several ways:
1) Looking up a MSI desciptor requires a O(n) list walk in the worst case
2) The upcoming support of runtime expansion of MSI-X vectors would need to do a full list walk to figure out whether a particular index is already associated.
3) Runtime expansion of sparse allocations is even more complex as the current implementation assumes an ordered list (increasing MSI index).
Use an xarray which solves all of the above problems nicely.
--- include/linux/msi.h | 13 +--- kernel/irq/msi.c | 169 +++++++++++++++++++++++----------------------------- 2 files changed, 83 insertions(+), 99 deletions(-)
include/linux/msi.h +6 -7
@@ -17,6 +17,7 @@*/ #include <linux/cpumask.h> +#include <linux/xarray.h> #include <linux/mutex.h> #include <linux/list.h> #include <linux/bits.h>
@@ -124,7 +125,6 @@ struct pci_msi_desc {/** * struct msi_desc - Descriptor structure for MSI based interrupts -* @list: List head for management * @irq: The base interrupt number * @nvec_used: The number of vectors used * @dev: Pointer to the device which uses this descriptor
@@ -141,7 +141,6 @@ struct pci_msi_desc {*/ struct msi_desc {/* Shared device/bus type independent data */ -struct list_head list;unsigned int irq;unsigned int nvec_used;struct device *dev;
@@ -177,16 +176,16 @@ enum msi_desc_filter {* msi_device_data - MSI per device data * @properties: MSI properties which are interesting to drivers * @platform_data: Platform-MSI specific data -* @list: List of MSI descriptors associated to the device -* @mutex: Mutex protecting the MSI list -* @__next: Cached pointer to the next entry for iterators +* @mutex: Mutex protecting the MSI descriptor store +* @__store: Xarray for storing MSI descriptor pointers +* @__iter_idx: Index to search the next entry for iterators */ struct msi_device_data {unsigned long properties;struct platform_msi_priv_data *platform_data; -struct list_head list;struct mutex mutex; -struct msi_desc *__next; +struct xarray __store; +unsigned long __iter_idx; };int msi_setup_device_data (struct device *dev);
kernel/irq/msi.c +77 -92
304 lines not on this page · raw message
[tip: irq/msi] genirq/msi: Convert storage to xarray
The following commit has been merged into the irq/msi branch of tip:
The following commit has been merged into the irq/msi branch of tip:
Commit-ID: cd6cf06590b9792340dceaa285138777f3cc4d90 Gitweb: https://git.kernel.org/tip/cd6cf06590b9792340dceaa285138777f3cc4d90 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 06 Dec 2021 23:51:52 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 16 Dec 2021 22:22:20 +01:00
genirq/msi: Convert storage to xarray
The current linked list storage for MSI descriptors is suboptimal in several ways:
1) Looking up a MSI desciptor requires a O(n) list walk in the worst case
2) The upcoming support of runtime expansion of MSI-X vectors would need to do a full list walk to figure out whether a particular index is already associated.
3) Runtime expansion of sparse allocations is even more complex as the current implementation assumes an ordered list (increasing MSI index).
Use an xarray which solves all of the above problems nicely.
--- include/linux/msi.h | 13 +-- kernel/irq/msi.c | 169 +++++++++++++++++++------------------------ 2 files changed, 83 insertions(+), 99 deletions(-)
include/linux/msi.h +6 -7
@@ -17,6 +17,7 @@*/ #include <linux/cpumask.h> +#include <linux/xarray.h> #include <linux/mutex.h> #include <linux/list.h> #include <asm/msi.h>
@@ -123,7 +124,6 @@ struct pci_msi_desc {/** * struct msi_desc - Descriptor structure for MSI based interrupts -* @list: List head for management * @irq: The base interrupt number * @nvec_used: The number of vectors used * @dev: Pointer to the device which uses this descriptor
@@ -140,7 +140,6 @@ struct pci_msi_desc {*/ struct msi_desc {/* Shared device/bus type independent data */ -struct list_head list;unsigned int irq;unsigned int nvec_used;struct device *dev;
@@ -176,16 +175,16 @@ enum msi_desc_filter {* msi_device_data - MSI per device data * @properties: MSI properties which are interesting to drivers * @platform_data: Platform-MSI specific data -* @list: List of MSI descriptors associated to the device -* @mutex: Mutex protecting the MSI list -* @__next: Cached pointer to the next entry for iterators +* @mutex: Mutex protecting the MSI descriptor store +* @__store: Xarray for storing MSI descriptor pointers +* @__iter_idx: Index to search the next entry for iterators */ struct msi_device_data {unsigned long properties;struct platform_msi_priv_data *platform_data; -struct list_head list;struct mutex mutex; -struct msi_desc *__next; +struct xarray __store; +unsigned long __iter_idx; };int msi_setup_device_data (struct device *dev);
kernel/irq/msi.c +77 -92
304 lines not on this page · raw message
Quoted 2 lines · Thomas Gleixner
This is the third part of [PCI]MSI refactoring which aims to provide the ability of expanding MSI-X vectors after enabling MSI-X.
I read through this and didn't have any substantive remarks
Jason