Make PCI's devres API more consistent
Subsystems (5)
v2 cover Make PCI's devres API more consistent
Changes in v2:
- Make commit head lines congruent with PCI's style (Bjorn)
- Add missing error checks for devm_add_action(). (Andy)
- Repair the "Returns: " marks for docu generation (Andy)
- Initialize the addr_devres struct with memset(). (Andy)
- Make pcim_intx() a PCI-internal function so that new drivers won't be encouraged to use the outdated pci_intx() mechanism. (Andy / Philipp)
- Fix grammar and spelling (Bjorn)
- Be more precise on why pcim_iomap_table() is problematic (Bjorn)
- Provide the actual structs' and functions' names in the commit messages (Bjorn)
- Remove redundant variable initializers (Andy)
- Regroup PM bitfield members in struct pci_dev (Andy)
- Consistently use the term "PCI devres API"; also in Patch #10 (Bjorn)
¡Hola!
PCI's devres API suffers several weaknesses:
1. There are functions prefixed with pcim_. Those are always managed counterparts to never-managed functions prefixed with pci_ – or so one would like to think. There are some apparently unmanaged functions (all region-request / release functions, and pci_intx()) which suddenly become managed once the user has initialized the device with pcim_enable_device() instead of pci_enable_device(). This "sometimes yes, sometimes no" nature of those functions is confusing and therefore bug-provoking. In fact, it has already caused a bug in DRM. The last patch in this series fixes that bug.
2. iomappings: Instead of giving each mapping its own callback, the existing API uses a statically allocated struct tracking one mapping per bar. This is not extensible. Especially, you can't create _ranged_ managed mappings that way, which many drivers want.
3. Managed request functions only exist as "plural versions" with a bit-mask as a parameter. That's quite over-engineered considering that each user only ever mapps one, maybe two bars.
This series:
- add a set of new "singular" devres functions that use devres the way its intended, with one callback per resource.
- deprecates the existing iomap-table mechanism.
- deprecates the hybrid nature of pci_ functions.
- preserves backwards compatibility so that drivers using the existing API won't notice any changes.
- adds documentation, especially some warning users about the complicated nature of PCI's devres.
Note that this series is based on my "unify pci_iounmap"-series from a few weeks ago. [1]
I tested this on a x86 VM with a simple pci test-device with two regions. Operates and reserves resources as intended on my system. Kasan and kmemleak didn't find any problems.
I believe this series cleans the API up as much as possible without having to port all existing drivers to the new API. Especially, I think that this implementation is easy to extend if the need for new managed functions arises :)
Greetings,
P.
Philipp Stanner (10):
PCI: add new set of devres functions
PCI: deprecate iomap-table functions
PCI: warn users about complicated devres nature
PCI: make devres region requests consistent
PCI: move dev-enabled status bit to struct pci_dev
PCI: move pinned status bit to struct pci_dev
PCI: give pcim_set_mwi() its own devres callback
PCI: give pci(m)_intx its own devres callback
PCI: remove legacy pcim_release() drm/vboxvideo: fix mapping leaks
Documentation/driver-api/pci/pci.rst | 3 + drivers/gpu/drm/vboxvideo/vbox_main.c | 24 +- drivers/pci/devres.c | 1015 +++++++++++++++++++++---- drivers/pci/iomap.c | 18 + drivers/pci/pci.c | 123 ++- drivers/pci/pci.h | 25 +- include/linux/pci.h | 18 +- 7 files changed, 1011 insertions(+), 215 deletions(-)
Signature · 1 line
2.43.0
PATCH v2 1/10 PCI: add new set of devres functions
The PCI devres API is not extensible to partial BAR mappings and has bug-provoking features. Improve that by providing better alternatives.
When the original PCI devres API was implemented, priority was given to the creation of a set of "plural functions" such as pcim_request_regions(). These functions have bit masks as parameters to specify which BARs shall get mapped. Most users, however, only use those to map 1-3 BARs.
A complete set of "singular functions" does not exist.
As functions mapping / requesting multiple BARs at once have (almost) no mechanism in C to return the resources to the caller of the plural function, the PCI devres API utilizes the iomap-table administrated by the function pcim_iomap_table().
The entire PCI devres API was strongly tied to that table which only allows for mapping whole, complete BARs, as the BAR's index is used as table index. Consequently, it's not possible to, e.g., have a pcim_iomap_range() function with that mechanism.
An additional problem is hat the PCI devres API has been ipmlemented in a sort of "hybrid-mode": Some unmanaged functions have managed counterparts (e.g.: pci_iomap() <-> pcim_iomap()), making their managed nature obvious to the programmer. However, the region-request functions in pci.c, prefixed with pci_, behave either managed or unmanaged, depending on whether pci_enable_device() or pcim_enable_device() has been called in advance.
This hybrid API is confusing and should be more cleanly separated by providing always-managed functions prefixed with pcim_.
Thus, the existing PCI devres API is not desirable because:
a) The vast majority of the users of the plural functions only ever sets a single bit in the bit mask, consequently making them singular functions anyways.
b) There is no mechanism to request / iomap only part of a BAR.
c) The iomap-table mechanism is over-engineered and complicated. Even worse, some users index over the table administration function directly:
void __iomem *mapping = pcim_iomap_table(pdev)[my_index]; This can not perform bounds checks; an invalid index won't cause return of -EINVAL or even NULL, resulting in undefined behavior.
d) region-request functions being sometimes managed and sometimes not is bug-provoking.
Implement a set of singular pcim_ functions that use devres directly and bypass the legacy iomap table mechanism.
Add devres.c to driver-api documentation.
--- Documentation/driver-api/pci/pci.rst | 3 + drivers/pci/devres.c | 473 ++++++++++++++++++++++++++- include/linux/pci.h | 11 + 3 files changed, 482 insertions(+), 5 deletions(-)
Documentation/driver-api/pci/pci.rst +3 -0
@@ -4,6 +4,9 @@ PCI Support Library .. kernel-doc:: drivers/pci/pci.c :export: +.. kernel-doc:: drivers/pci/devres.c + :export: + .. kernel-doc:: drivers/pci/pci-driver.c :export:
drivers/pci/devres.c +468 -5
511 lines not on this page · raw message
include/linux/pci.h +11 -0
@@ -2314,10 +2314,21 @@ static inline void pci_fixup_device(enum pci_fixup_pass pass,void __iomem *pcim_iomap (struct pci_dev *pdev,int bar,unsigned long maxlen);void pcim_iounmap (struct pci_dev *pdev,void __iomem *addr);void __iomem *const *pcim_iomap_table (struct pci_dev *pdev); +void __iomem *pcim_iomap_region (struct pci_dev *pdev,int bar,const char *name); +void pcim_iounmap_region (struct pci_dev *pdev,int bar);int pcim_iomap_regions (struct pci_dev *pdev,int mask,const char *name);int pcim_iomap_regions_request_all (struct pci_dev *pdev,int mask,const char *name);void pcim_iounmap_regions (struct pci_dev *pdev,int mask); +int pcim_request_region (struct pci_dev *pdev,int bar,const char *res_name); +void pcim_release_region (struct pci_dev *pdev,int bar); +void __iomem *pcim_iomap_range (struct pci_dev *pdev,int bar, +unsigned long offset,unsigned long len); +void __iomem *pcim_iomap_region_range (struct pci_dev *pdev,int bar, +unsigned long offset,unsigned long len, +const char *res_name); +void pcim_iounmap_region_range (struct pci_dev *pdev,int bar, +unsigned long offset,unsigned long len);extern int pci_pci_problems;#define PCIPCI_FAIL 1/* No PCI PCI DMA */
Signature · 1 line
2.43.0
PATCH v2 2/10 PCI: deprecate iomap-table functions
In reply to Philipp StannerThe old plural devres functions tie the PCI devres API to the iomap-table mechanism which unfortunately is not extensible.
As the purlal functions are almost never used with more than one bit set in their bit-mask, deprecating them and encouraging users to use the new singular functions instead is reasonable.
Furthermore, to make the implementation more consistent and extensible, the plural functions should use the singular functions.
Add new wrapper to request / release all BARs. Make the plural functions call into the singular functions. Mark the plural functions as deprecated.
Remove as much of the iomap-table-mechanism as possible. Add comments describing the path towards a cleaned-up API.
--- drivers/pci/devres.c | 374 +++++++++++++++++++++++++++++++++---------- drivers/pci/pci.c | 20 +++ drivers/pci/pci.h | 5 + include/linux/pci.h | 2 + 4 files changed, 318 insertions(+), 83 deletions(-)
drivers/pci/devres.c +291 -83
@@ -4,15 +4,43 @@#include "pci.h" /* -* PCI iomap devres +* On the state of PCI's devres implementation: +* +* The older devres API for PCI has two significant problems: +* +* 1. It is very strongly tied to the statically allocated mapping table in +* struct pcim_iomap_devres below. This is mostly solved in the sense of the +* pcim_ functions in this file providing things like ranged mapping by +* bypassing this table, wheras the functions that were present in the old +* API still enter the mapping addresses into the table for users of the old +* API. +* 2. The region-request-functions in pci.c do become managed IF the device has +* been enabled with pcim_enable_device() instead of pci_enable_device(). +* This resulted in the API becoming inconsistent: Some functions have an +* obviously managed counter-part (e.g., pci_iomap() <-> pcim_iomap()), +* whereas some don't and are never managed, while others don't and are +* _sometimes_ managed (e.g. pci_request_region()). +* Consequently, in the new API, region requests performed by the pcim_ +* functions are automatically cleaned up through the devres callback +* pcim_addr_resource_release(), while requests performed by +* pcim_enable_device() + pci_*region*() are automatically cleaned up +* through the for-loop in pcim_release(). +* +* TODO 1: +* Remove the legacy table entirely once all calls to pcim_iomap_table() in +* the kernel have been removed. +* +* TODO 2: +* Port everyone calling pcim_enable_device() + pci_*region*() to using the +* pcim_ functions. Then, remove all devres functionality from pci_*region*() +* functions and remove the associated cleanups described above in point #2. */ -#define PCIM_IOMAP_MAX PCI_STD_NUM_BARS/* * Legacy struct storing addresses to whole mapped BARs. */ struct pcim_iomap_devres { -void __iomem *table[PCIM_IOMAP_MAX ]; +void __iomem *table[PCI_STD_NUM_BARS ]; };enum pcim_addr_devres_type {
@@ -373,6 +401,16 @@ static void pcim_release(struct device *gendev, void *res)struct pci_devres *this = res;int i; +/* +* This is legacy code. +* All regions requested by a pcim_ function do get released through +* pcim_addr_resource_release(). Thanks to the hybrid nature of the pci_ +* region-request functions, this for-loop has to release the regions +* if they have been requested by such a function. +* +* TODO: Remove this once all users of pcim_enable_device() PLUS +* pci-region-request-functions have been ported to pcim_ functions. +*/ for (i =0 ; i <DEVICE_COUNT_RESOURCE ; i++)if (this->region_mask & (1 << i))pci_release_region (dev, i);
@@ -461,19 +499,21 @@ EXPORT_SYMBOL(pcim_pin_device);static void pcim_iomap_release (struct device *gendev,void *res) { -struct pci_dev *dev =to_pci_dev (gendev); -struct pcim_iomap_devres *this = res; -int i; - -for (i =0 ; i <PCIM_IOMAP_MAX ; i++) -if (this->table[i]) -pci_iounmap (dev, this->table[i]); +/* +* Do nothing. This is legacy code. +* +* Cleanup of the mappings is now done directly through the callbacks +* registered when creating them. +*/ }/** -* pcim_iomap_table - access iomap allocation table +* pcim_iomap_table - access iomap allocation table (DEPRECATED) * @pdev: PCI device to access iomap table for * +* Returns: +* Const pointer to array of __iomem pointers on success NULL on failure. +* * Access iomap allocation table for @dev. If iomap table doesn't * exist and @pdev is managed, it will be allocated. All iomaps * recorded in the iomap table are automatically unmapped on driver
@@ -482,6 +522,11 @@ static void pcim_iomap_release(struct device *gendev, void *res)* This function might sleep when the table is first allocated but can * be safely called without context and guaranteed to succeed once * allocated. +* +* This function is DEPRECATED. Do not use it in new code. +* Instead, obtain a mapping's address directly from one of the pcim_* mapping +* functions. For example: +* void __iomem *mappy = pcim_iomap(pdev, barnr, length); */ void __iomem *const *pcim_iomap_table (struct pci_dev *pdev) {
@@ -500,27 +545,114 @@ void __iomem * const *pcim_iomap_table(struct pci_dev *pdev) }EXPORT_SYMBOL (pcim_iomap_table); +/* +* Fill the legacy mapping-table, so that drivers using the old API +* can still get a BAR's mapping address through pcim_iomap_table(). +*/ +static int pcim_add_mapping_to_legacy_table (struct pci_dev *pdev, +void __iomem *mapping,short bar) +{ +void __iomem **legacy_iomap_table; + +if (bar >=PCI_STD_NUM_BARS ) +return -EINVAL ; + + legacy_iomap_table = (void __iomem **)pcim_iomap_table (pdev); +if (!legacy_iomap_table) +return -ENOMEM ; + +/* The legacy mechanism doesn't allow for duplicate mappings. */ +WARN_ON (legacy_iomap_table[bar]); + + legacy_iomap_table[bar] = mapping; + +return 0 ; +} + +/* +* Removes a mapping. The table only contains whole-bar-mappings, so this will +* never interfere with ranged mappings. +*/ +static void pcim_remove_mapping_from_legacy_table (struct pci_dev *pdev, +void __iomem *addr) +{ +short bar; +void __iomem **legacy_iomap_table; + + legacy_iomap_table = (void __iomem **)pcim_iomap_table (pdev); +if (!legacy_iomap_table) +return ; + +for (bar =0 ; bar <PCI_STD_NUM_BARS ; bar++) { +if (legacy_iomap_table[bar] == addr) { + legacy_iomap_table[bar] =NULL ; +return ; + } + } +} + +/* +* The same as pcim_remove_mapping_from_legacy_table(), but identifies the +* mapping by its BAR index. +*/ +static void pcim_remove_bar_from_legacy_table (struct pci_dev *pdev,short bar) +{ +void __iomem **legacy_iomap_table; + +if (bar >=PCI_STD_NUM_BARS ) +return ; + + legacy_iomap_table = (void __iomem **)pcim_iomap_table (pdev); +if (!legacy_iomap_table) +return ; + + legacy_iomap_table[bar] =NULL ; +} +/** * pcim_iomap - Managed pcim_iomap() * @pdev: PCI device to iomap for * @bar: BAR to iomap * @maxlen: Maximum length of iomap * -* Managed pci_iomap(). Map is automatically unmapped on driver -* detach. +* Returns: __iomem pointer on success, NULL on failure. +* +* Managed pci_iomap(). Map is automatically unmapped on driver detach. If +* desired, unmap manually only with pcim_iounmap(). +* +* This SHOULD only be used once per BAR. +* +* NOTE: +* Contrary to the other pcim_* functions, this function does not return an +* IOMEM_ERR_PTR() on failure, but a simple NULL. This is done for backwards +* compatibility. */ void __iomem *pcim_iomap (struct pci_dev *pdev,int bar,unsigned long maxlen) { -void __iomem **tbl; - -BUG_ON (bar >=PCIM_IOMAP_MAX ); +void __iomem *mapping; +struct pcim_addr_devres *res; - tbl = (void __iomem **)pcim_iomap_table (pdev); -if (!tbl || tbl[bar])/* duplicate mappings not allowed */ + res =pcim_addr_devres_alloc (pdev); +if (!res)return NULL ; + res->type =PCIM_ADDR_DEVRES_TYPE_MAPPING ; + + mapping =pci_iomap (pdev, bar, maxlen); +if (!mapping) + goto err_iomap; + res->baseaddr = mapping; + +if (pcim_add_mapping_to_legacy_table (pdev, mapping, bar) !=0 ) + goto err_table; - tbl[bar] =pci_iomap (pdev, bar, maxlen); -return tbl[bar]; +devres_add (&pdev->dev, res); +return mapping; + +err_table: +pci_iounmap (pdev, mapping); +err_iomap: +pcim_addr_devres_free (res); +return NULL ; }EXPORT_SYMBOL (pcim_iomap);
@@ -529,23 +661,24 @@ EXPORT_SYMBOL(pcim_iomap);* @pdev: PCI device to iounmap for * @addr: Address to unmap * -* Managed pci_iounmap(). @addr must have been mapped using pcim_iomap(). +* Managed pci_iounmap(). @addr must have been mapped using pcim_iomap() or +* pcim_iomap_range(). */ void pcim_iounmap (struct pci_dev *pdev,void __iomem *addr) { -void __iomem **tbl; -int i; +struct pcim_addr_devres res_searched; -pci_iounmap (pdev, addr); +pcim_addr_devres_clear (&res_searched); + res_searched.type =PCIM_ADDR_DEVRES_TYPE_MAPPING ; + res_searched.baseaddr = addr; - tbl = (void __iomem **)pcim_iomap_table (pdev); -BUG_ON (!tbl); +if (devres_release (&pdev->dev, pcim_addr_resource_release, + pcim_addr_resources_match, &res_searched) !=0 ) { +/* Doesn't exist. User passed nonsense. */ +return ; + } -for (i =0 ; i <PCIM_IOMAP_MAX ; i++) -if (tbl[i] == addr) { - tbl[i] =NULL ; -return ; - } +pcim_remove_mapping_from_legacy_table (pdev, addr); }EXPORT_SYMBOL (pcim_iounmap);
@@ -615,106 +748,181 @@ void pcim_iounmap_region(struct pci_dev *pdev, int bar) }EXPORT_SYMBOL (pcim_iounmap_region); +static inline bool mask_contains_bar (int mask,int bar) +{ +return mask &BIT (bar); +} +/** -* pcim_iomap_regions - Request and iomap PCI BARs +* pcim_iomap_regions - Request and iomap PCI BARs (DEPRECATED) * @pdev: PCI device to map IO resources for * @mask: Mask of BARs to request and iomap * @name: Name associated with the requests * +* Returns: 0 on success, negative error code on failure. +* * Request and iomap regions specified by @mask. +* +* This function is DEPRECATED. Don't use it in new code. +* Use pcim_iomap_region() instead. */ int pcim_iomap_regions (struct pci_dev *pdev,int mask,const char *name) { -void __iomem *const *iomap; -int i, rc; +int ret; +short bar; +void __iomem *mapping; - iomap =pcim_iomap_table (pdev); -if (!iomap) -return -ENOMEM ; +for (bar =0 ; bar <DEVICE_COUNT_RESOURCE ; bar++) { +if (!mask_contains_bar (mask, bar)) +continue ; -for (i =0 ; i <DEVICE_COUNT_RESOURCE ; i++) { -unsigned long len; + mapping =pcim_iomap_region (pdev, bar, name); +if (IS_ERR (mapping)) { + ret =PTR_ERR (mapping); + goto err; + } + ret =pcim_add_mapping_to_legacy_table (pdev, mapping, bar); +if (ret !=0 ) + goto err; + } -if (!(mask & (1 << i))) -continue ; +return 0 ; - rc = -EINVAL ; - len =pci_resource_len (pdev, i); -if (!len) - goto err_inval; +err: +while (--bar >=0 ) { +pcim_iounmap_region (pdev, bar); +pcim_remove_bar_from_legacy_table (pdev, bar); + } - rc =pci_request_region (pdev, i, name); -if (rc) - goto err_inval; +return ret; +} +EXPORT_SYMBOL (pcim_iomap_regions); - rc = -ENOMEM ; -if (!pcim_iomap (pdev, i,0 )) - goto err_region; +/** +* pcim_release_all_regions - Release all regions of a PCI-device +* @pdev: the PCI device +* +* Will release all regions previously requested through pcim_request_region() +* or pcim_request_all_regions(). +* +* Can be called from any context, i.e., not necessarily as a counterpart to +* pcim_request_all_regions(). +*/ +void pcim_release_all_regions (struct pci_dev *pdev) +{ +short bar; + +for (bar =0 ; bar <PCI_STD_NUM_BARS ; bar++) +pcim_release_region (pdev, bar); +} +EXPORT_SYMBOL (pcim_release_all_regions); + +/** +* pcim_request_all_regions - Request all regions +* @pdev: PCI device to map IO resources for +* @name: name associated with the request +* +* Returns: 0 on success, negative error code on failure. +* +* Requested regions will automatically be released at driver detach. If desired, +* release individual regions with pcim_release_region() or all of them at once +* with pcim_release_all_regions(). +*/ +int pcim_request_all_regions (struct pci_dev *pdev,const char *name) +{ +int ret; +short bar; + +for (bar =0 ; bar <PCI_STD_NUM_BARS ; bar++) { + ret =pcim_request_region (pdev, bar, name); +if (ret !=0 ) + goto err; }return 0 ; - err_region: -pci_release_region (pdev, i); - err_inval: -while (--i >=0 ) { -if (!(mask & (1 << i))) -continue ; -pcim_iounmap (pdev, iomap[i]); -pci_release_region (pdev, i); - } +err: +pcim_release_all_regions (pdev); -return rc; +return ret; } -EXPORT_SYMBOL (pcim_iomap_regions); +EXPORT_SYMBOL (pcim_request_all_regions);/** -* pcim_iomap_regions_request_all - Request all BARs and iomap specified ones +* pcim_iomap_regions_request_all - Request all BARs and iomap specified ones (DEPRECATED) * @pdev: PCI device to map IO resources for * @mask: Mask of BARs to iomap * @name: Name associated with the requests * +* Returns: 0 on success, negative error code on failure. +* * Request all PCI BARs and iomap regions specified by @mask. +* +* To release these resources manually, call pcim_release_region() for the +* regions and pcim_iounmap() for the mappings. +* +* This function is DEPRECATED. Don't use it in new code. +* Use pcim_request_all_regions() + pcim_iomap*() instead. */ int pcim_iomap_regions_request_all (struct pci_dev *pdev,int mask,const char *name) { -int request_mask = ((1 <<6 ) -1 ) & ~mask; -int rc; +short bar; +int ret; +void __iomem **legacy_iomap_table; + + ret =pcim_request_all_regions (pdev, name); +if (ret !=0 ) +return ret; - rc =pci_request_selected_regions (pdev, request_mask, name); -if (rc) -return rc; +for (bar =0 ; bar <PCI_STD_NUM_BARS ; bar++) { +if (!mask_contains_bar (mask, bar)) +continue ; +if (!pcim_iomap (pdev, bar,0 )) + goto err; + } - rc =pcim_iomap_regions (pdev, mask, name); -if (rc) -pci_release_selected_regions (pdev, request_mask); -return rc; +return 0 ; + +err: +/* +* Here it gets tricky: pcim_iomap() above has most likely +* failed because it got an OOM when trying to create the +* legacy-table. +* We check here if that has happened. If not, pcim_iomap() +* must have failed because of EINVAL. +*/ + legacy_iomap_table = (void __iomem **)pcim_iomap_table (pdev); + ret = legacy_iomap_table ? -EINVAL : -ENOMEM ; + +while (--bar >=0 ) +pcim_iounmap (pdev, legacy_iomap_table[bar]); + +pcim_release_all_regions (pdev); + +return ret; }EXPORT_SYMBOL (pcim_iomap_regions_request_all);/** -* pcim_iounmap_regions - Unmap and release PCI BARs +* pcim_iounmap_regions - Unmap and release PCI BARs (DEPRECATED) * @pdev: PCI device to map IO resources for * @mask: Mask of BARs to unmap and release * * Unmap and release regions specified by @mask. +* +* This function is DEPRECATED. Don't use it in new code. */ void pcim_iounmap_regions (struct pci_dev *pdev,int mask) { -void __iomem *const *iomap; -int i; - - iomap =pcim_iomap_table (pdev); -if (!iomap) -return ; +short bar; -for (i =0 ; i <PCIM_IOMAP_MAX ; i++) { -if (!(mask & (1 << i))) +for (bar =0 ; bar <PCI_STD_NUM_BARS ; bar++) { +if (!mask_contains_bar (mask, bar))continue ; -pcim_iounmap (pdev, iomap[i]); -pci_release_region (pdev, i); +pcim_iounmap_region (pdev, bar); +pcim_remove_bar_from_legacy_table (pdev, bar); } }EXPORT_SYMBOL (pcim_iounmap_regions);
drivers/pci/pci.c +20 -0
@@ -3884,6 +3884,16 @@ void pci_release_region(struct pci_dev *pdev, int bar)release_mem_region (pci_resource_start (pdev, bar),pci_resource_len (pdev, bar)); +/* +* This devres utility makes this function sometimes managed +* (when pcim_enable_device() has been called before). +* This is bad because it conflicts with the pcim_ functions being +* exclusively responsible for managed pci. Its "sometimes yes, sometimes +* no" nature can cause bugs. +* +* TODO: Remove this once all users that use pcim_enable_device() PLUS +* a region request function have been ported to using pcim_ functions. +*/ dr =find_pci_dr (pdev);if (dr) dr->region_mask &= ~(1 << bar);
@@ -3928,6 +3938,16 @@ static int __pci_request_region(struct pci_dev *pdev, int bar, goto err_out; } +/* +* This devres utility makes this function sometimes managed +* (when pcim_enable_device() has been called before). +* This is bad because it conflicts with the pcim_ functions being +* exclusively responsible for managed pci. Its "sometimes yes, sometimes +* no" nature can cause bugs. +* +* TODO: Remove this once all users that use pcim_enable_device() PLUS +* a region request function have been ported to using pcim_ functions. +*/ dr =find_pci_dr (pdev);if (dr) dr->region_mask |=1 << bar;
drivers/pci/pci.h +5 -0
@@ -814,6 +814,11 @@ struct pci_devres { unsigned int orig_intx:1; unsigned int restore_intx:1; unsigned int mwi:1; + +/* +* TODO: remove the region_mask once everyone calling +* pcim_enable_device() + pci_*region*() is ported to pcim_ functions. +*/ u32 region_mask; };
include/linux/pci.h +2 -0
@@ -2322,6 +2322,8 @@ int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask,void pcim_iounmap_regions (struct pci_dev *pdev,int mask);int pcim_request_region (struct pci_dev *pdev,int bar,const char *res_name);void pcim_release_region (struct pci_dev *pdev,int bar); +void pcim_release_all_regions (struct pci_dev *pdev); +int pcim_request_all_regions (struct pci_dev *pdev,const char *name);void __iomem *pcim_iomap_range (struct pci_dev *pdev,int bar,unsigned long offset,unsigned long len); void __iomem *pcim_iomap_region_range(struct pci_dev *pdev, int bar,
Signature · 1 line
2.43.0
PATCH v2 3/10 PCI: warn users about complicated devres nature
In reply to Philipp StannerThe PCI region-request functions become managed functions when pcim_enable_device() has been called previously instead of pci_enable_device().
This has already caused bugs by confusing users, who came to believe that all pci functions, such as pci_iomap_range(), suddenly are managed that way.
This is not the case.
Add comments to the relevant functions' docstrings that warn users about this behavior.
--- drivers/pci/iomap.c | 18 ++++++++++++++ drivers/pci/pci.c | 60 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 77 insertions(+), 1 deletion(-)
drivers/pci/iomap.c +18 -0
@@ -23,6 +23,11 @@* * @maxlen specifies the maximum length to map. If you want to get access to * the complete BAR from offset to the end, pass %0 here. +* +* NOTE: +* This function is never managed, even if you initialized with +* pcim_enable_device(). +* If you need automatic cleanup, use pcim_iomap_range(). * */ void __iomem *pci_iomap_range(struct pci_dev *dev, int bar,
@@ -63,6 +68,10 @@ EXPORT_SYMBOL(pci_iomap_range);* * @maxlen specifies the maximum length to map. If you want to get access to * the complete BAR from offset to the end, pass %0 here. +* +* NOTE: +* This function is never managed, even if you initialized with +* pcim_enable_device(). * */ void __iomem *pci_iomap_wc_range(struct pci_dev *dev, int bar,
@@ -106,6 +115,11 @@ EXPORT_SYMBOL_GPL(pci_iomap_wc_range);* * @maxlen specifies the maximum length to map. If you want to get access to * the complete BAR without checking for its length first, pass %0 here. +* +* NOTE: +* This function is never managed, even if you initialized with +* pcim_enable_device(). +* If you need automatic cleanup, use pcim_iomap(). * */ void __iomem *pci_iomap (struct pci_dev *dev,int bar,unsigned long maxlen) {
@@ -127,6 +141,10 @@ EXPORT_SYMBOL(pci_iomap);* * @maxlen specifies the maximum length to map. If you want to get access to * the complete BAR without checking for its length first, pass %0 here. +* +* NOTE: +* This function is never managed, even if you initialized with +* pcim_enable_device(). * */ void __iomem *pci_iomap_wc (struct pci_dev *dev,int bar,unsigned long maxlen) {
drivers/pci/pci.c +59 -1
126 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v2 4/10 PCI: make devres region requests consistent
In reply to Philipp StannerNow that pure managed region request functions are available, the implementation of the hybrid-functions which are only sometimes managed can be made more consistent and readable by wrapping those always-managed functions.
Implement a new pcim_ function for exclusively requested regions. Have the pci_request / release functions call their pcim_ counterparts. Remove the now surplus region_mask from struct pci_devres.
--- drivers/pci/devres.c | 49 ++++++++++++++++++++++--------------------- drivers/pci/pci.c | 50 +++++++++++++++----------------------------- drivers/pci/pci.h | 6 ------ include/linux/pci.h | 1 + 4 files changed, 43 insertions(+), 63 deletions(-)
drivers/pci/devres.c +25 -24
@@ -22,18 +22,15 @@* _sometimes_ managed (e.g. pci_request_region()). * Consequently, in the new API, region requests performed by the pcim_ * functions are automatically cleaned up through the devres callback -* pcim_addr_resource_release(), while requests performed by -* pcim_enable_device() + pci_*region*() are automatically cleaned up -* through the for-loop in pcim_release(). +* pcim_addr_resource_release(). +* Users utilizing pcim_enable_device() + pci_*region*() are redirected in +* pci.c to the managed functions here in this file. This isn't exactly +* perfect, but the only alternative way would be to port ALL drivers using +* said combination to pcim_ functions. * -* TODO 1: +* TODO: * Remove the legacy table entirely once all calls to pcim_iomap_table() in * the kernel have been removed. -* -* TODO 2: -* Port everyone calling pcim_enable_device() + pci_*region*() to using the -* pcim_ functions. Then, remove all devres functionality from pci_*region*() -* functions and remove the associated cleanups described above in point #2. */ /*
@@ -399,21 +396,6 @@ static void pcim_release(struct device *gendev, void *res) {struct pci_dev *dev =to_pci_dev (gendev);struct pci_devres *this = res; -int i; - -/* -* This is legacy code. -* All regions requested by a pcim_ function do get released through -* pcim_addr_resource_release(). Thanks to the hybrid nature of the pci_ -* region-request functions, this for-loop has to release the regions -* if they have been requested by such a function. -* -* TODO: Remove this once all users of pcim_enable_device() PLUS -* pci-region-request-functions have been ported to pcim_ functions. -*/ -for (i =0 ; i <DEVICE_COUNT_RESOURCE ; i++) -if (this->region_mask & (1 << i)) -pci_release_region (dev, i);if (this->mwi)pci_clear_mwi (dev);
@@ -968,6 +950,25 @@ int pcim_request_region(struct pci_dev *pdev, int bar, const char *name) }EXPORT_SYMBOL (pcim_request_region); +/** +* pcim_request_region_exclusive - Request a PCI BAR exclusively +* @pdev: PCI device to requestion region for +* @bar: Index of BAR to request +* @name: Name associated with the request +* +* Returns: 0 on success, a negative error code on failure. +* +* Request region specified by @bar exclusively. +* +* The region will automatically be released on driver detach. If desired, +* release manually only with pcim_release_region(). +*/ +int pcim_request_region_exclusive (struct pci_dev *pdev,int bar,const char *name) +{ +return _pcim_request_region (pdev, bar, name,IORESOURCE_EXCLUSIVE ); +} +EXPORT_SYMBOL (pcim_request_region_exclusive); +/** * pcim_release_region - Release a PCI BAR * @pdev: PCI device to operate on
drivers/pci/pci.c +17 -33
78 lines not on this page · raw message
drivers/pci/pci.h +0 -6
@@ -814,12 +814,6 @@ struct pci_devres { unsigned int orig_intx:1; unsigned int restore_intx:1; unsigned int mwi:1; - -/* -* TODO: remove the region_mask once everyone calling -* pcim_enable_device() + pci_*region*() is ported to pcim_ functions. -*/ -u32 region_mask; };struct pci_devres *find_pci_dr (struct pci_dev *pdev);
include/linux/pci.h +1 -0
@@ -2321,6 +2321,7 @@ int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask, const char *name);void pcim_iounmap_regions (struct pci_dev *pdev,int mask);int pcim_request_region (struct pci_dev *pdev,int bar,const char *res_name); +int pcim_request_region_exclusive (struct pci_dev *pdev,int bar,const char *name);void pcim_release_region (struct pci_dev *pdev,int bar);void pcim_release_all_regions (struct pci_dev *pdev);int pcim_request_all_regions (struct pci_dev *pdev,const char *name);
Signature · 1 line
2.43.0
PATCH v2 5/10 PCI: move dev-enabled status bit to struct pci_dev
In reply to Philipp StannerThe bit describing whether the PCI device is currently enabled is stored in struct pci_devres. Besides this struct being subject of a cleanup process, struct pci_device is in general the right place to store this information, since it is not devres-specific.
Move the 'enabled' boolean bit to struct pci_dev.
--- drivers/pci/devres.c | 11 ++++------- drivers/pci/pci.c | 17 ++++++++++------- drivers/pci/pci.h | 1 - include/linux/pci.h | 1 + 4 files changed, 15 insertions(+), 15 deletions(-)
drivers/pci/devres.c +4 -7
@@ -403,7 +403,7 @@ static void pcim_release(struct device *gendev, void *res)if (this->restore_intx)pci_intx (dev, this->orig_intx); -if (this->enabled && !this->pinned) +if (!this->pinned)pci_disable_device (dev); }
@@ -448,14 +448,11 @@ int pcim_enable_device(struct pci_dev *pdev) dr =get_pci_dr (pdev);if (unlikely (!dr))return -ENOMEM ; -if (dr->enabled) -return 0 ; rc =pci_enable_device (pdev); -if (!rc) { +if (!rc) pdev->is_managed =1 ; - dr->enabled =1 ; - } +return rc; }EXPORT_SYMBOL (pcim_enable_device);
@@ -473,7 +470,7 @@ void pcim_pin_device(struct pci_dev *pdev)struct pci_devres *dr; dr =find_pci_dr (pdev); -WARN_ON (!dr || !dr->enabled); +WARN_ON (!dr || !pdev->enabled);if (dr) dr->pinned =1 ; }
drivers/pci/pci.c +10 -7
@@ -1953,6 +1953,9 @@ static int do_pci_enable_device(struct pci_dev *dev, int bars)u16 cmd;u8 pin; +if (dev->enabled) +return 0 ; + err =pci_set_power_state (dev,PCI_D0 );if (err <0 && err != -EIO )return err;
@@ -1967,7 +1970,7 @@ static int do_pci_enable_device(struct pci_dev *dev, int bars)pci_fixup_device (pci_fixup_enable, dev);if (dev->msi_enabled || dev->msix_enabled) -return 0 ; + goto success_out;pci_read_config_byte (dev,PCI_INTERRUPT_PIN , &pin);if (pin) {
@@ -1977,6 +1980,8 @@ static int do_pci_enable_device(struct pci_dev *dev, int bars) cmd & ~PCI_COMMAND_INTX_DISABLE); } +success_out: + dev->enabled = true;return 0 ; }
@@ -2146,6 +2151,9 @@ static void do_pci_disable_device(struct pci_dev *dev) {u16 pci_command; +if (!dev->enabled) +return ; +pci_read_config_word (dev,PCI_COMMAND , &pci_command);if (pci_command &PCI_COMMAND_MASTER ) { pci_command &= ~PCI_COMMAND_MASTER ;
@@ -2153,6 +2161,7 @@ static void do_pci_disable_device(struct pci_dev *dev) }pcibios_disable_device (dev); + dev->enabled = false; }/**
@@ -2180,12 +2189,6 @@ void pci_disable_enabled_device(struct pci_dev *dev)*/ void pci_disable_device (struct pci_dev *dev) { -struct pci_devres *dr; - - dr =find_pci_dr (dev); -if (dr) - dr->enabled =0 ; -dev_WARN_ONCE (&dev->dev,atomic_read (&dev->enable_cnt) <=0 ,"disabling already-disabled device" );
drivers/pci/pci.h +0 -1
@@ -809,7 +809,6 @@ static inline pci_power_t mid_pci_get_power_state(struct pci_dev *pdev)* when a device is enabled using managed PCI device enable interface. */ struct pci_devres { -unsigned int enabled:1 ;unsigned int pinned:1 ;unsigned int orig_intx:1 ;unsigned int restore_intx:1 ;
include/linux/pci.h +1 -0
@@ -367,6 +367,7 @@ struct pci_dev {this is D0-D3, D0 being fully functional, and D3 being off. */ u8 pm_cap;/* PM capability offset */ + unsigned int enabled:1; /* Whether this dev is enabled */ unsigned int imm_ready:1; /* Supports Immediate Readiness */ unsigned int pme_support:5; /* Bitmask of states from which PME#can be generated */
Signature · 1 line
2.43.0
PATCH v2 6/10 PCI: move pinned status bit to struct pci_dev
In reply to Philipp StannerThe bit describing whether the PCI device is currently pinned is stored in struct pci_devres. To clean up and simplify the PCI devres API, it's better if this information is stored in struct pci_dev, because it allows for checking that device's pinned-status directly through struct pci_dev.
This will later permit simplifying pcim_enable_device().
Move the 'pinned' boolean bit to struct pci_dev.
--- drivers/pci/devres.c | 14 ++++---------- drivers/pci/pci.h | 1 - include/linux/pci.h | 5 +++-- 3 files changed, 7 insertions(+), 13 deletions(-)
drivers/pci/devres.c +4 -10
@@ -403,7 +403,7 @@ static void pcim_release(struct device *gendev, void *res)if (this->restore_intx)pci_intx (dev, this->orig_intx); -if (!this->pinned) +if (!dev->pinned)pci_disable_device (dev); }
@@ -461,18 +461,12 @@ EXPORT_SYMBOL(pcim_enable_device);* pcim_pin_device - Pin managed PCI device * @pdev: PCI device to pin * -* Pin managed PCI device @pdev. Pinned device won't be disabled on -* driver detach. @pdev must have been enabled with -* pcim_enable_device(). +* Pin managed PCI device @pdev. Pinned device won't be disabled on driver +* detach. @pdev must have been enabled with pcim_enable_device(). */ void pcim_pin_device (struct pci_dev *pdev) { -struct pci_devres *dr; - - dr =find_pci_dr (pdev); -WARN_ON (!dr || !pdev->enabled); -if (dr) - dr->pinned =1 ; + pdev->pinned = true; }EXPORT_SYMBOL (pcim_pin_device);
drivers/pci/pci.h +0 -1
@@ -809,7 +809,6 @@ static inline pci_power_t mid_pci_get_power_state(struct pci_dev *pdev)* when a device is enabled using managed PCI device enable interface. */ struct pci_devres { -unsigned int pinned:1 ;unsigned int orig_intx:1 ;unsigned int restore_intx:1 ;unsigned int mwi:1 ;
include/linux/pci.h +3 -2
@@ -367,11 +367,12 @@ struct pci_dev {this is D0-D3, D0 being fully functional, and D3 being off. */ u8 pm_cap;/* PM capability offset */ - unsigned int enabled:1; /* Whether this dev is enabled */ - unsigned int imm_ready:1; /* Supports Immediate Readiness */ unsigned int pme_support:5; /* Bitmask of states from which PME#can be generated */ unsigned int pme_poll:1; /* Poll device's PME status bit */ + unsigned int enabled:1; /* Whether this dev is enabled */ + unsigned int pinned:1; /* Whether this dev is pinned */ + unsigned int imm_ready:1; /* Supports Immediate Readiness */ unsigned int d1_support:1; /* Low power state D1 is supported */ unsigned int d2_support:1; /* Low power state D2 is supported */ unsigned int no_d1d2:1; /* D1 and D2 are forbidden */
Signature · 1 line
2.43.0
PATCH v2 7/10 PCI: give pcim_set_mwi() its own devres callback
In reply to Philipp StannerManaging pci_set_mwi() with devres can easily be done with its own callback, without the necessity to store any state about it in a device-related struct.
Remove the MWI state from struct pci_devres.
Give pcim_set_mwi() a separate devres-callback.
--- drivers/pci/devres.c | 29 ++++++++++++++++++----------- drivers/pci/pci.h | 1 - 2 files changed, 18 insertions(+), 12 deletions(-)
drivers/pci/devres.c +18 -11
@@ -370,24 +370,34 @@ void __iomem *devm_pci_remap_cfg_resource(struct device *dev, }EXPORT_SYMBOL (devm_pci_remap_cfg_resource); +static void __pcim_clear_mwi (void *pdev_raw) +{ +struct pci_dev *pdev = pdev_raw; + +pci_clear_mwi (pdev); +} +/** * pcim_set_mwi - a device-managed pci_set_mwi() -* @dev: the PCI device for which MWI is enabled +* @pdev: the PCI device for which MWI is enabled * * Managed pci_set_mwi(). * * RETURNS: An appropriate -ERRNO error value on error, or zero for success. */ -int pcim_set_mwi (struct pci_dev *dev) +int pcim_set_mwi (struct pci_dev *pdev) { -struct pci_devres *dr; +int ret; - dr =find_pci_dr (dev); -if (!dr) -return -ENOMEM ; + ret =devm_add_action (&pdev->dev, __pcim_clear_mwi, pdev); +if (ret !=0 ) +return ret; + + ret =pci_set_mwi (pdev); +if (ret !=0 ) +devm_remove_action (&pdev->dev, __pcim_clear_mwi, pdev); - dr->mwi =1 ; -return pci_set_mwi (dev); +return ret; }EXPORT_SYMBOL (pcim_set_mwi);
@@ -397,9 +407,6 @@ static void pcim_release(struct device *gendev, void *res)struct pci_dev *dev =to_pci_dev (gendev);struct pci_devres *this = res; -if (this->mwi) -pci_clear_mwi (dev); -if (this->restore_intx)pci_intx (dev, this->orig_intx);
drivers/pci/pci.h +0 -1
@@ -811,7 +811,6 @@ static inline pci_power_t mid_pci_get_power_state(struct pci_dev *pdev)struct pci_devres {unsigned int orig_intx:1 ;unsigned int restore_intx:1 ; -unsigned int mwi:1 ; };struct pci_devres *find_pci_dr (struct pci_dev *pdev);
Signature · 1 line
2.43.0
PATCH v2 8/10 PCI: give pci(m)_intx its own devres callback
In reply to Philipp Stannerpci_intx() is one of the functions that have "hybrid mode" (i.e., sometimes managed, sometimes not). Providing a separate pcim_intx() function with its own device resource and cleanup callback allows for removing further large parts of the legacy pci-devres implementation.
As in the region-request-functions, pci_intx() has to call into its managed counterpart for backwards compatibility.
As pci_intx() is an outdated function, pcim_intx() shall not be made visible to other drivers via a public API.
Implement pcim_intx() with its own device resource. Make pci_intx() call pcim_intx() in the managed case. Remove the struct pci_devres from pci.h.
--- drivers/pci/devres.c | 76 ++++++++++++++++++++++++++++++++++---------- drivers/pci/pci.c | 24 +++++++------- drivers/pci/pci.h | 21 +++--------- 3 files changed, 77 insertions(+), 44 deletions(-)
drivers/pci/devres.c +60 -16
@@ -40,6 +40,11 @@ struct pcim_iomap_devres {void __iomem *table[PCI_STD_NUM_BARS ]; }; +/* Used to restore the old intx state on driver detach. */ +struct pcim_intx_devres { +int orig_intx; +}; +enum pcim_addr_devres_type {/* Default initializer. */ PCIM_ADDR_DEVRES_TYPE_INVALID ,
@@ -401,31 +406,70 @@ int pcim_set_mwi(struct pci_dev *pdev) }EXPORT_SYMBOL (pcim_set_mwi); +static void pcim_intx_restore (struct device *dev,void *data) +{ +struct pci_dev *pdev =to_pci_dev (dev); +struct pcim_intx_devres *res = data; -static void pcim_release (struct device *gendev,void *res) +pci_intx (pdev, res->orig_intx); +} + +static struct pcim_intx_devres *get_or_create_intx_devres (struct device *dev) { -struct pci_dev *dev =to_pci_dev (gendev); -struct pci_devres *this = res; +struct pcim_intx_devres *res; -if (this->restore_intx) -pci_intx (dev, this->orig_intx); + res =devres_find (dev, pcim_intx_restore,NULL ,NULL ); +if (res) +return res; -if (!dev->pinned) -pci_disable_device (dev); + res =devres_alloc (pcim_intx_restore,sizeof (*res),GFP_KERNEL ); +if (res) +devres_add (dev, res); + +return res; } -/* -* TODO: -* Once the last four callers in pci.c are ported, this function here needs to -* be made static again. +/** +* pcim_intx - managed pci_intx() +* @pdev: the PCI device to operate on +* @enable: boolean: whether to enable or disable PCI INTx +* +* Returns: 0 on success, -ENOMEM on error. +* +* Enables/disables PCI INTx for device @pdev. +* Restores the original state on driver detach. */ -struct pci_devres *find_pci_dr (struct pci_dev *pdev) +int pcim_intx (struct pci_dev *pdev,int enable) { -if (pci_is_managed (pdev)) -return devres_find (&pdev->dev, pcim_release,NULL ,NULL ); -return NULL ; +u16 pci_command, new; +struct pcim_intx_devres *res; + + res =get_or_create_intx_devres (&pdev->dev); +if (!res) +return -ENOMEM ; + + res->orig_intx = !enable; + +pci_read_config_word (pdev,PCI_COMMAND , &pci_command); + +if (enable) + new = pci_command & ~PCI_COMMAND_INTX_DISABLE ; +else + new = pci_command |PCI_COMMAND_INTX_DISABLE ; + +if (new != pci_command) +pci_write_config_word (pdev,PCI_COMMAND , new); + +return 0 ; +} + +static void pcim_release (struct device *gendev,void *res) +{ +struct pci_dev *dev =to_pci_dev (gendev); + +if (!dev->pinned) +pci_disable_device (dev); } -EXPORT_SYMBOL (find_pci_dr);static struct pci_devres *get_pci_dr (struct pci_dev *pdev) {
drivers/pci/pci.c +13 -11
@@ -3877,7 +3877,7 @@ EXPORT_SYMBOL_GPL(pci_common_swizzle);void pci_release_region (struct pci_dev *pdev,int bar) {/* -* This is done for backwards compatibility, because the old pci-devres +* This is done for backwards compatibility, because the old PCI devres * API had a mode in which the function became managed if it had been * enabled with pcim_enable_device() instead of pci_enable_device(). */
@@ -4465,11 +4465,22 @@ void pci_disable_parity(struct pci_dev *dev)* This is a "hybrid" function: Its normally unmanaged, but becomes managed * when pcim_enable_device() has been called in advance. * This hybrid feature is DEPRECATED! +* Use pcim_intx() if you need a managed version. */ void pci_intx (struct pci_dev *pdev,int enable) {u16 pci_command, new; +/* +* This is done for backwards compatibility, because the old PCI devres +* API had a mode in which this function became managed if the dev had +* been enabled with pcim_enable_device() instead of pci_enable_device(). +*/ +if (pci_is_managed (pdev)) { +WARN_ON_ONCE (pcim_intx (pdev, enable) !=0 ); +return ; + } +pci_read_config_word (pdev,PCI_COMMAND , &pci_command);if (enable)
@@ -4477,17 +4488,8 @@ void pci_intx(struct pci_dev *pdev, int enable)else new = pci_command |PCI_COMMAND_INTX_DISABLE ; -if (new != pci_command) { -struct pci_devres *dr; - +if (new != pci_command)pci_write_config_word (pdev,PCI_COMMAND , new); - - dr =find_pci_dr (pdev); -if (dr && !dr->restore_intx) { - dr->restore_intx =1 ; - dr->orig_intx = !enable; - } - } }EXPORT_SYMBOL_GPL (pci_intx);
drivers/pci/pci.h +4 -17
@@ -796,24 +796,11 @@ static inline pci_power_t mid_pci_get_power_state(struct pci_dev *pdev)#endif /* -* TODO: -* The following two components wouldn't need to be here if they weren't used at -* four last places in pci.c -* Port or move these functions to devres.c and then remove the -* pci_devres-components from this header file here. +* This is a helper that shall only ever be called by pci_intx(). It helps +* cleaning up the PCI devres API in which pci_intx() became a managed function +* under certain conditions. */ -/* -* Managed PCI resources. This manages device on/off, INTx/MSI/MSI-X -* on/off and BAR regions. pci_dev itself records MSI/MSI-X status, so -* there's no need to track it separately. pci_devres is initialized -* when a device is enabled using managed PCI device enable interface. -*/ -struct pci_devres { -unsigned int orig_intx:1 ; -unsigned int restore_intx:1 ; -}; - -struct pci_devres *find_pci_dr (struct pci_dev *pdev); +int pcim_intx (struct pci_dev *dev,int enable);/* * Config Address for PCI Configuration Mechanism #1
Signature · 1 line
2.43.0
PATCH v2 9/10 PCI: remove legacy pcim_release()
In reply to Philipp StannerThanks to preceding cleanup steps, pcim_release() is now not needed anymore and can be replaced by pcim_disable_device(), which is the exact counterpart to pcim_enable_device().
This permits removing further parts of the old devres API.
Replace pcim_release() with pcim_disable_device(). Remove the now surplus function get_pci_dr().
--- drivers/pci/devres.c | 49 +++++++++++++++++++------------------------- 1 file changed, 21 insertions(+), 28 deletions(-)
drivers/pci/devres.c +21 -28
@@ -463,48 +463,41 @@ int pcim_intx(struct pci_dev *pdev, int enable)return 0 ; } -static void pcim_release (struct device *gendev,void *res) +static void pcim_disable_device (void *pdev_raw) { -struct pci_dev *dev =to_pci_dev (gendev); - -if (!dev->pinned) -pci_disable_device (dev); -} - -static struct pci_devres *get_pci_dr (struct pci_dev *pdev) -{ -struct pci_devres *dr, *new_dr; - - dr =devres_find (&pdev->dev, pcim_release,NULL ,NULL ); -if (dr) -return dr; +struct pci_dev *pdev = pdev_raw; - new_dr =devres_alloc (pcim_release,sizeof (*new_dr),GFP_KERNEL ); -if (!new_dr) -return NULL ; -return devres_get (&pdev->dev, new_dr,NULL ,NULL ); +if (!pdev->pinned) +pci_disable_device (pdev); }/** * pcim_enable_device - Managed pci_enable_device() * @pdev: PCI device to be initialized * -* Managed pci_enable_device(). +* Returns: 0 on success, negative error code on failure. +* +* Managed pci_enable_device(). Device will automatically be disabled on +* driver detach. */ int pcim_enable_device (struct pci_dev *pdev) { -struct pci_devres *dr; -int rc; +int ret; - dr =get_pci_dr (pdev); -if (unlikely (!dr)) -return -ENOMEM ; + ret =devm_add_action (&pdev->dev, pcim_disable_device, pdev); +if (ret !=0 ) +return ret; - rc =pci_enable_device (pdev); -if (!rc) - pdev->is_managed =1 ; +/* +* We prefer removing the action in case of an error over +* devm_add_action_or_reset() because the later could theoretically be +* disturbed by users having pinned the device too soon. +*/ + ret =pci_enable_device (pdev); +if (ret !=0 ) +devm_remove_action (&pdev->dev, pcim_disable_device, pdev); -return rc; +return ret; }EXPORT_SYMBOL (pcim_enable_device);
Signature · 1 line
2.43.0
PATCH v2 10/10 drm/vboxvideo: fix mapping leaks
In reply to Philipp StannerWhen the PCI devres API was introduced to this driver, it was wrongly assumed that initializing the device with pcim_enable_device() instead of pci_enable_device() will make all PCI functions managed.
This is wrong and was caused by the quite confusing devres API for PCI in which some, but not all, functions become managed that way.
The function pci_iomap_range() is never managed.
Replace pci_iomap_range() with the actually managed function pcim_iomap_range().
Additionally, add a call to pcim_request_region() to ensure exclusive access to BAR 0.
--- drivers/gpu/drm/vboxvideo/vbox_main.c | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-)
drivers/gpu/drm/vboxvideo/vbox_main.c +13 -11
@@ -42,12 +42,11 @@ static int vbox_accel_init(struct vbox_private *vbox)/* Take a command buffer for each screen from the end of usable VRAM. */ vbox->available_vram_size -= vbox->num_crtcs *VBVA_MIN_BUFFER_SIZE ; - vbox->vbva_buffers =pci_iomap_range (pdev,0 , - vbox->available_vram_size, - vbox->num_crtcs * -VBVA_MIN_BUFFER_SIZE ); -if (!vbox->vbva_buffers) -return -ENOMEM ; + vbox->vbva_buffers =pcim_iomap_range ( + pdev,0 , vbox->available_vram_size, + vbox->num_crtcs *VBVA_MIN_BUFFER_SIZE ); +if (IS_ERR (vbox->vbva_buffers)) +return PTR_ERR (vbox->vbva_buffers);for (i =0 ; i < vbox->num_crtcs; ++i) { vbva_setup_buffer_context(&vbox->vbva_info[i],
@@ -115,12 +114,15 @@ int vbox_hw_init(struct vbox_private *vbox)DRM_INFO ("VRAM %08x\n" , vbox->full_vram_size); + ret =pcim_request_region (pdev,0 ,"vboxvideo" ); +if (ret) +return ret; +/* Map guest-heap at end of vram */ - vbox->guest_heap = -pci_iomap_range (pdev,0 ,GUEST_HEAP_OFFSET (vbox), -GUEST_HEAP_SIZE ); -if (!vbox->guest_heap) -return -ENOMEM ; + vbox->guest_heap =pcim_iomap_range (pdev,0 , +GUEST_HEAP_OFFSET (vbox),GUEST_HEAP_SIZE ); +if (IS_ERR (vbox->guest_heap)) +return PTR_ERR (vbox->guest_heap);/* Create guest-heap mem-pool use 2^4 = 16 byte chunks */ vbox->guest_pool = devm_gen_pool_create(vbox->ddev.dev, 4, -1,
Signature · 1 line
2.43.0
Re: [PATCH v2 10/10] drm/vboxvideo: fix mapping leaks
Hi Philipp,
Quoted 7 lines · Philipp Stanner
When the PCI devres API was introduced to this driver, it was wrongly assumed that initializing the device with
pcim_enable_device()instead ofpci_enable_device()will make all PCI functions managed.This is wrong and was caused by the quite confusing devres API for PCI in which some, but not all, functions become managed that way.
Quoted 7 lines
The function
pci_iomap_range()is never managed.Replace
pci_iomap_range()with the actually managed functionpcim_iomap_range().Additionally, add a call to
pcim_request_region()to ensure exclusive access to BAR 0.
I'm a bit worried about this last change. There might be issues where the pcim_request_region() fails due to e.g. a conflict with the simplefb / simpledrm code.
There is a drm_aperture_remove_conflicting_pci_framebuffers() call done before hw_init() gets called, but still this has been known to cause issues in the past.
Can you split out the adding of the pcim_request_region() into a separate patch and *not* mark that separate patch for stable ?
Regards,
Hans
Quoted 51 lines
CC <[email protected]> # v5.10+Fixes 8558de401b5f ("drm/vboxvideo: use managed pci functions")Signed-off-by Philipp Stanner <[email protected]>--- drivers/gpu/drm/vboxvideo/vbox_main.c | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-)drivers/gpu/drm/vboxvideo/vbox_main.c +13
-11@@ -42,12 +42,11 @@ static int vbox_accel_init(struct vbox_private *vbox)/* Take a command buffer for each screen from the end of usable VRAM. */ vbox->available_vram_size -= vbox->num_crtcs *VBVA_MIN_BUFFER_SIZE ; - vbox->vbva_buffers =pci_iomap_range (pdev,0 , - vbox->available_vram_size, - vbox->num_crtcs * -VBVA_MIN_BUFFER_SIZE ); -if (!vbox->vbva_buffers) -return -ENOMEM ; + vbox->vbva_buffers =pcim_iomap_range ( + pdev,0 , vbox->available_vram_size, + vbox->num_crtcs *VBVA_MIN_BUFFER_SIZE ); +if (IS_ERR (vbox->vbva_buffers)) +return PTR_ERR (vbox->vbva_buffers);for (i =0 ; i < vbox->num_crtcs; ++i) { vbva_setup_buffer_context(&vbox->vbva_info[i],@@ -115,12 +114,15 @@ int vbox_hw_init(struct vbox_private *vbox)DRM_INFO ("VRAM %08x\n" , vbox->full_vram_size); + ret =pcim_request_region (pdev,0 ,"vboxvideo" ); +if (ret) +return ret; +/* Map guest-heap at end of vram */ - vbox->guest_heap = -pci_iomap_range (pdev,0 ,GUEST_HEAP_OFFSET (vbox), -GUEST_HEAP_SIZE ); -if (!vbox->guest_heap) -return -ENOMEM ; + vbox->guest_heap =pcim_iomap_range (pdev,0 , +GUEST_HEAP_OFFSET (vbox),GUEST_HEAP_SIZE ); +if (IS_ERR (vbox->guest_heap)) +return PTR_ERR (vbox->guest_heap);/* Create guest-heap mem-pool use 2^4 = 16 byte chunks */ vbox->guest_pool = devm_gen_pool_create(vbox->ddev.dev, 4, -1,
Re: [PATCH v2 10/10] drm/vboxvideo: fix mapping leaks
Hi,
Quoted 26 lines · Hans de Goede
Hi Philipp,
Quoted 10 lines · Philipp Stanner
When the PCI devres API was introduced to this driver, it was wrongly
assumed that initializing the device withpcim_enable_device()instead
ofpci_enable_device()will make all PCI functions managed.This is wrong and was caused by the quite confusing devres API for PCI
in which some, but not all, functions become managed that way.Quoted 8 lines
The function
pci_iomap_range()is never managed.Replace
pci_iomap_range()with the actually managed functionpcim_iomap_range().Additionally, add a call to
pcim_request_region()to ensure exclusive
access to BAR 0.I'm a bit worried about this last change. There might be issues where the
pcim_request_region()fails due to e.g. a conflict with the simplefb / simpledrm code.
Quoted 7 lines
There is a
drm_aperture_remove_conflicting_pci_framebuffers()call done beforehw_init()gets called, but still this has been known to cause issues in the past.Can you split out the adding of the
pcim_request_region()into a separate patch and *not* mark that separate patch for stable ?
Yes, that sounds reasonable. I'll split it out and deal with it once I'll send the other DRM patches from my backlog.
Greetings,
P.
Quoted 68 lines
Regards,
Hans
Quoted 58 lines
CC <[email protected]> # v5.10+Fixes 8558de401b5f ("drm/vboxvideo: use managed pci functions")Signed-off-by Philipp Stanner <[email protected]>---
drivers/gpu/drm/vboxvideo/vbox_main.c | 24 +++++++++++++---------- -1 file changed, 13 insertions(+), 11 deletions(-)drivers/gpu/drm/vboxvideo/vbox_main.c +0
-0@@ -42,12 +42,11 @@ static int vbox_accel_init(struct vbox_private *vbox) /* Take a command buffer for each screen from the end ofusable VRAM. */
vbox->available_vram_size -=vbox->num_crtcs*VBVA_MIN_BUFFER_SIZE;
- vbox->vbva_buffers = pci_iomap_range(pdev, 0, - vbox-Quoted 1 line
available_vram_size,-
vbox->num_crtcs* -VBVA_MIN_BUFFER_SIZE); - if (!vbox->vbva_buffers)
- return-ENOMEM;
+ vbox->vbva_buffers = pcim_iomap_range(
+ pdev, 0,vbox->available_vram_size, + vbox->num_crtcs *VBVA_MIN_BUFFER_SIZE); + if (IS_ERR(vbox->vbva_buffers))
+ returnPTR_ERR(vbox->vbva_buffers);
for (i = 0; i <vbox->num_crtcs; ++i) { vbva_setup_buffer_context(&vbox->vbva_info[i],drivers/gpu/drm/vboxvideo/vbox_main.c +0
-0@@ -115,12 +114,15 @@ int vbox_hw_init(struct vbox_private *vbox)
DRM_INFO("VRAM %08x\n",vbox->full_vram_size);
+ ret =pcim_request_region(pdev, 0, "vboxvideo"); + if (ret)
+ return ret;
+
/* Map guest-heap at end of vram */
- vbox->guest_heap =
- pci_iomap_range(pdev, 0,GUEST_HEAP_OFFSET(vbox), -GUEST_HEAP_SIZE);
- if (!vbox->guest_heap)
- return-ENOMEM;
+ vbox->guest_heap = pcim_iomap_range(pdev, 0,
+ GUEST_HEAP_OFFSET(vbox),GUEST_HEAP_SIZE); + if (IS_ERR(vbox->guest_heap))
+ returnPTR_ERR(vbox->guest_heap);
/* Create guest-heap mem-pool use 2^4 = 16 byte chunks */vbox->guest_pool= devm_gen_pool_create(vbox->ddev.dev, 4, -1,
Forgot to add a few changes to the changelog:
Quoted 9 lines · Philipp Stanner
Changes in v2:
- Make commit head lines congruent with PCI's style (Bjorn)
- Add missing error checks fordevm_add_action(). (Andy)
- Repair the "Returns: " marks for docu generation (Andy)
- Initialize theaddr_devresstruct withmemset(). (Andy)
- Makepcim_intx()a PCI-internal function so that new drivers won't
be encouraged to use the outdatedpci_intx()mechanism. (Andy / Philipp)
Quoted 8 lines
- Fix grammar and spelling (Bjorn)
- Be more precise on whypcim_iomap_table()is problematic (Bjorn)
- Provide the actual structs' and functions' names in the commit messages (Bjorn)
- Remove redundant variable initializers (Andy)
- Regroup PM bitfield members in structpci_dev(Andy)
- Consistently use the term "PCI devres API"; also in Patch #10 (Bjorn)
* Make pcim_intx() visible only for the PCI subsystem so that new drivers won't use this outdated API (Andy, Myself)
* Add a NOTE to pcim_iomap() to warn about this function being the onee
xception that does just return NULL.
This v2 now contains most of the feedback, except the ones Andy and I haven't agreed on yet.
Thx,
P.
Quoted 81 lines
¡Hola!
PCI's devres API suffers several weaknesses:
1. There are functions prefixed with
pcim_. Those are always managed counterparts to never-managed functions prefixed withpci_– or so one
would like to think. There are some apparently unmanaged functions (all region-request / release functions, andpci_intx()) which suddenly become managed once the user has initialized the device with
pcim_enable_device()instead ofpci_enable_device(). This "sometimes
yes, sometimes no" nature of those functions is confusing and therefore bug-provoking. In fact, it has already caused a bug in DRM.
The last patch in this series fixes that bug.
2. iomappings: Instead of giving each mapping its own callback, the existing API uses a statically allocated struct tracking one mapping
per bar. This is not extensible. Especially, you can't create _ranged_ managed mappings that way, which many drivers want.
3. Managed request functions only exist as "plural versions" with a bit-mask as a parameter. That's quite over-engineered considering that each user only ever mapps one, maybe two bars.This series:
- add a set of new "singular" devres functions that use devres the way
its intended, with one callback per resource.
- deprecates the existing iomap-table mechanism.
- deprecates the hybrid nature ofpci_functions.
- preserves backwards compatibility so that drivers using the existing
API won't notice any changes.
- adds documentation, especially some warning users about the complicated nature of PCI's devres.Note that this series is based on my "unify pci_iounmap"-series from a
few weeks ago. [1]I tested this on a x86 VM with a simple pci test-device with two regions. Operates and reserves resources as intended on my system. Kasan and kmemleak didn't find any problems.
I believe this series cleans the API up as much as possible without having to port all existing drivers to the new API. Especially, I think
that this implementation is easy to extend if the need for new managed
functions arises :)Greetings,
P.Philipp Stanner (10):
PCI: add new set of devres functions
PCI: deprecate iomap-table functions
PCI: warn users about complicated devres nature
PCI: make devres region requests consistent
PCI: move dev-enabled status bit to structpci_dev
PCI: move pinned status bit to structpci_dev
PCI: givepcim_set_mwi()its own devres callback
PCI: give pci(m)_intx its own devres callback
PCI: remove legacypcim_release()drm/vboxvideo: fix mapping leaksDocumentation/driver-api/pci/pci.rst | 3 +
drivers/gpu/drm/vboxvideo/vbox_main.c| 24 +- drivers/pci/devres.c | 1015 +++++++++++++++++++++-- --
drivers/pci/iomap.c | 18 + drivers/pci/pci.c | 123 ++- drivers/pci/pci.h | 25 +- include/linux/pci.h | 18 +-7 files changed, 1011 insertions(+), 215 deletions(-)