PCI: Validate ACS enable flags against device-specific ACS capabilities
Subsystems (2)
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH v8 1/6 PCI: Validate ACS enable flags against device-specific ACS capabilities
The ACS flag validation used the kernel's full set of ACS control bits, which allowed users to request ACS features that the device does not support. These unsupported bits would be silently ignored by hardware.
Validate the requested ACS enable bits against dev->acs_capabilities so that only device-supported ACS controls are accepted. Mask the capability with GENMASK_U16(6, 0) to select only the currently defined ACS control bits (0-6); higher bits in the capability structure (e.g. the egress control vector size in bits 8-15) do not correspond to control bits in the ACS control register.
__pci_config_acs() is also called from disable_acs_redir_param(), which passes a hardcoded acs_mask (PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_EC) that does not need validation. Gate the new check on !acs_mask so it only fires for the config_acs_param path, which always invokes __pci_config_acs() with acs_mask == 0 and builds the actual mask from user input.
Also move the check after the device is matched, since the ctrl bits apply only to the matched device.
Finally, improve the error message to report which invalid bits were requested.
--- drivers/pci/pci.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-)
drivers/pci/pci.c +7 -6
@@ -886,6 +886,7 @@ struct pci_acs {static void __pci_config_acs (struct pci_dev *dev,struct pci_acs *caps,const char *p,const u16 acs_mask,const u16 acs_flags) { +u16 valid_ctrl = dev->acs_capabilities &GENMASK_U16 (6 ,0 );u16 flags = acs_flags;u16 mask = acs_mask;char *delimit;
@@ -931,12 +932,6 @@ static void __pci_config_acs(struct pci_dev *dev, struct pci_acs *caps, } } -if (mask & ~(PCI_ACS_SV |PCI_ACS_TB |PCI_ACS_RR |PCI_ACS_CR | -PCI_ACS_UF |PCI_ACS_EC |PCI_ACS_DT )) { -pci_err (dev,"Invalid ACS flags specified\n" ); -return ; - } - ret =pci_dev_str_match (dev, p, &p);if (ret <0 ) {pr_warn_once ("PCI: Can't parse ACS command line parameter\n" );
@@ -959,6 +954,12 @@ static void __pci_config_acs(struct pci_dev *dev, struct pci_acs *caps,if (!pci_dev_specific_disable_acs_redir (dev))return ; +if (!acs_mask && (mask & ~valid_ctrl)) { +pci_err (dev,"Invalid ACS bits specified: %#06x\n" , + mask & ~valid_ctrl); +return ; + } +pci_dbg (dev,"ACS mask = %#06x\n" , mask);pci_dbg (dev,"ACS flags = %#06x\n" , flags);pci_dbg (dev,"ACS control = %#06x\n" , caps->ctrl);
Signature · 1 line
2.51.0
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] The new ACS bit validation strictly rejects configurations that include unsupported bits (both…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] The new ACS bit validation strictly rejects configurations that include unsupported bits (both enables and disables), breaking existing command-line parameter usage. --
commit b54fadf9f09be9bfcfae1cf9a51034c115a768c7
Author: Wei Wang <[email protected]>
PCI: Validate ACS enable flags against device-specific ACS capabilities
This commit validates the requested ACS enable bits against the device's acs_capabilities. It ensures that only device-supported ACS controls are accepted, returning an error for unsupported bits instead of letting the hardware ignore them.
Quoted 11 lines
drivers/pci/pci.c +1
-0@@ -896,6 +896,7 @@ struct pci_acs {static void __pci_config_acs (struct pci_dev *dev,struct pci_acs *caps,const char *p,const u16 acs_mask,const u16 acs_flags) { +u16 valid_ctrl = dev->acs_capabilities &GENMASK_U16 (6 ,0 );u16 flags = acs_flags;u16 mask = acs_mask;
[ ... ]
drivers/pci/pci.c static void __pci_config_acs(struct pci_dev *dev, struct pci_acs *caps, · line 971
Quoted 9 lines
drivers/pci/pci.c +5
-0@@ -969,6 +964,12 @@ static void __pci_config_acs(struct pci_dev *dev, struct pci_acs *caps,if (!pci_dev_specific_disable_acs_redir (dev))return ; +if (!acs_mask && (mask & ~valid_ctrl)) { +pci_err (dev,"Invalid ACS bits specified: %#06x\n" , + mask & ~valid_ctrl); +return ; + }
[Severity: High]
Does this new validation break existing command-line configurations?
Generic command-line configurations, such as pci=config_acs=10x@pci:0:0, can apply blanket masks to devices. Previously, the hardware would silently ignore the unsupported bits, but this validation now aborts the entire configuration, leaving even the supported bits unconfigured.
Additionally, passing a 0 to explicitly disable an unsupported bit will also cause the configuration to fail, as the mask includes disabled bits.
Should the code silently mask out unsupported bits instead of returning an error?
Quoted 4 lines
drivers/pci/pci.c +1
-0+pci_dbg (dev,"ACS mask = %#06x\n" , mask);pci_dbg (dev,"ACS flags = %#06x\n" , flags);pci_dbg (dev,"ACS control = %#06x\n" , caps->ctrl);
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
PATCH v8 2/6 Documentation/kernel-parameters: Add multi-device config_acs example
In reply to a message not in the archiveThe config_acs parameter allows configuring ACS settings for multiple PCI devices by separating entries with semicolons. The current documentation only illustrates applying one configuration pattern to all devices, but does not show how to specify multiple devices with different ACS settings in a single parameter. Add an example demonstrating multi-device usage with distinct ACS configurations.
Some bootloaders interpret ';' as a command separator, which can cause the parameter to be split as multiple commands. Document that the entire parameter may need to be quoted to avoid bootloader parsing issues. This avoids confusing bootloader errors such as "can't find command <BDF>" when passing multiple device entries.
--- Documentation/admin-guide/kernel-parameters.txt | 7 +++++++ 1 file changed, 7 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +7 -0
@@ -5281,6 +5281,13 @@ Kernel parameters Note: this may remove isolation between devices and may put more devices in an IOMMU group. + + "pci=config_acs=10x@0000:04:00.0;1x101@0000:84:00.0" + configures two devices with different ACS settings. + Note: Some bootloaders interpret ';' as a command + separator. If so, quote the entire parameter to + ensure it is passed to the kernel unchanged. + force_floating [S390] Force usage of floating interrupts. nomio [S390] Do not use MIO instructions. norid [S390] ignore the RID field and force use of
Signature · 1 line
2.51.0
PATCH v8 3/6 PCI: Consolidate delimiter handling into pci_dev_str_match()
In reply to a message not in the archiveCallers of pci_dev_str_match() manually checked for the ';' or ',' delimiter and advanced the parameter pointer past it. Move this common logic into pci_dev_str_match() so callers no longer need to duplicate it.
As a side effect of this consolidation, pci_dev_str_match() now enforces stricter boundary checks on successful matches. Previously, if a user provided a malformed parameter with garbage characters appended to a valid BDF (e.g., "pci=config_acs=110x@0000:04:00.0foo"), the callers would silently accept the prefix match and ignore the trailing garbage. Now, pci_dev_str_match() strictly verifies that the matched token is immediately followed by a valid delimiter (';', ',') or the null terminator ('\0'), returning -EINVAL if it encounters invalid trailing characters.
--- drivers/pci/pci.c | 40 ++++++++++++++++++---------------------- 1 file changed, 18 insertions(+), 22 deletions(-)
drivers/pci/pci.c +18 -22
@@ -334,7 +334,7 @@ static int pci_dev_str_match_path(struct pci_dev *dev, const char *path,* pci_dev_str_match - test if a string matches a device * @dev: the PCI device to test * @p: string to match the device against -* @endptr: pointer to the string after the match +* @endptr: pointer to the string after the match, with the delimiter skipped * * Test if a string (typically from a kernel parameter) matches a specified * PCI device. The string may be of one of the following formats:
@@ -388,8 +388,13 @@ static int pci_dev_str_match(struct pci_dev *dev, const char *p, (!subsystem_vendor || subsystem_vendor == dev->subsystem_vendor) && (!subsystem_device || - subsystem_device == dev->subsystem_device)) - goto found; + subsystem_device == dev->subsystem_device)) { + ret =1 ; + goto out; + } + +/* No matching string found */ + ret =0 ; }else {/* * PCI Bus, Device, Function IDs are specified
@@ -399,15 +404,18 @@ static int pci_dev_str_match(struct pci_dev *dev, const char *p,if (ret <0 )return ret;else if (ret) - goto found; + goto out; } +out: +/* +* Whether we matched (ret == 1) or didn't (ret == 0), +* ensure the token ends with a valid boundary. +*/ +if (*p !='\0' && *p !=';' && *p !=',' ) +return -EINVAL ; - *endptr = p; -return 0 ; - -found: - *endptr = p; -return 1 ; + *endptr = *p =='\0' ? p : p +1 ; +return ret; } static u8 __pci_find_next_cap(struct pci_bus *bus, unsigned int devfn,
@@ -940,12 +948,6 @@ static void __pci_config_acs(struct pci_dev *dev, struct pci_acs *caps,/* Found a match */ break ; } - -if (*p !=';' && *p !=',' ) { -/* End of param or invalid format */ -break ; - } - p++; }if (ret !=1 )
@@ -6398,12 +6400,6 @@ static resource_size_t pci_specified_resource_alignment(struct pci_dev *dev, p);break ; } - -if (*p !=';' && *p !=',' ) { -/* End of param or invalid format */ -break ; - } - p++; } out:spin_unlock (&resource_alignment_lock);
Signature · 1 line
2.51.0
PATCH v8 4/6 PCI: Refactor disable_acs_redir and config_acs param handling
In reply to a message not in the archiveThe current implementation mixes disable_acs_redir and config_acs param processing inside __pci_config_acs(), using acs_mask==0 as an implicit signal to switch into config_acs_param mode. The intertwined logic is hard to follow and easy to break:
- The acs_mask==0 special case is non-obvious and obscures which code paths apply to which parameter.
- The interleaved logic is fragile; changes intended for one parameter can unintentionally affect the other. For example, pci_dev_specific_disable_acs_redir() is invoked on the common path even though it should apply only to disable_acs_redir.
Split the two behaviors into dedicated functions, pci_param_disable_acs_redir() and pci_param_config_acs(), making the control flow explicit and easier to maintain.
The new pci_param_config_acs() implementation also improves on the original logic:
- It searches for the matching device first and parses ACS flags only for the matched device, avoiding unnecessary work.
- A switch statement replaces multiple if/else blocks, improving readability.
- Variable names (enabled_bits, disabled_bits) more clearly express their roles compared to the previous mask/flags pair.
- Error messages are clearer.
This refactor separates concerns, improves robustness, and makes future extensions to ACS parameter handling safer and easier to review.
--- drivers/pci/pci.c | 176 +++++++++++++++++++++++++++------------------- 1 file changed, 105 insertions(+), 71 deletions(-)
drivers/pci/pci.c +105 -71
@@ -891,89 +891,118 @@ struct pci_acs {u16 fw_ctrl; }; -static void __pci_config_acs (struct pci_dev *dev,struct pci_acs *caps, -const char *p,const u16 acs_mask,const u16 acs_flags) +static bool pci_dev_match_disable_acs_redir (struct pci_dev *dev,const char *p) { -u16 valid_ctrl = dev->acs_capabilities &GENMASK_U16 (6 ,0 ); -u16 flags = acs_flags; -u16 mask = acs_mask; -char *delimit;int ret =0 ; -if (!p) -return ; -while (*p) { -if (!acs_mask) { -/* Check for ACS flags */ - delimit =strstr (p,"@" ); -if (delimit) { -int end; -u32 shift =0 ; - - end = delimit - p -1 ; - mask =0 ; - flags =0 ; - -while (end >-1 ) { -if (*(p + end) =='0' ) { - mask |=1 << shift; - shift++; - end--; - }else if (*(p + end) =='1' ) { - mask |=1 << shift; - flags |=1 << shift; - shift++; - end--; - }else if ((*(p + end) =='x' ) || (*(p + end) =='X' )) { - shift++; - end--; - }else { -pci_err (dev,"Invalid ACS flags... Ignoring\n" ); -return ; - } - } - p = delimit +1 ; - }else { -pci_err (dev,"ACS Flags missing\n" ); -return ; - } - } - ret =pci_dev_str_match (dev, p, &p); -if (ret <0 ) { -pr_warn_once ("PCI: Can't parse ACS command line parameter\n" ); -break ; - }else if (ret ==1 ) { -/* Found a match */ +if (ret ==1 ) { +return true; + }else if (ret <0 ) { +pr_warn_once ("PCI: Can't parse disable_acs_redir param\n" );break ; } } -if (ret !=1 ) +return false; +} + +static void pci_param_disable_acs_redir (struct pci_dev *dev, +struct pci_acs *caps) +{ +const u16 acs_redir_mask =PCI_ACS_RR |PCI_ACS_CR |PCI_ACS_EC ; + +if (!disable_acs_redir_param || + !pci_dev_match_disable_acs_redir (dev, disable_acs_redir_param) || + !pci_dev_specific_disable_acs_redir (dev))return ; -if (!pci_dev_specific_disable_acs_redir (dev)) -return ; + caps->ctrl = caps->fw_ctrl & ~acs_redir_mask; +} -if (!acs_mask && (mask & ~valid_ctrl)) { -pci_err (dev,"Invalid ACS bits specified: %#06x\n" , - mask & ~valid_ctrl); -return ; - } - -pci_dbg (dev,"ACS mask = %#06x\n" , mask); -pci_dbg (dev,"ACS flags = %#06x\n" , flags); -pci_dbg (dev,"ACS control = %#06x\n" , caps->ctrl); -pci_dbg (dev,"ACS fw_ctrl = %#06x\n" , caps->fw_ctrl); +static const char *pci_dev_match_config_acs (struct pci_dev *dev,const char *p) +{ +const char *seg; +int ret;/* -* For mask bits that are 0, copy them from the firmware setting -* and apply flags for all the mask bits that are 1. +* Example: 11101010x@0000:01:00.0;101x@0000:02:00.0;1@0000:03:00.0 +* Three segments delimited via ';'. @seg always points to the start +* of a segment and p advances to the start of the device id (BDF) +* after '@'. Upon match, return the start of the matching segment. */ - caps->ctrl = (caps->fw_ctrl & ~mask) | (flags & mask); +while (*p) { + seg = p; + p =strchr (seg,'@' ); +/* If malformed string, stop parsing. */ +if (!p || p == seg) +break ; -pci_info (dev,"Configured ACS to %#06x\n" , caps->ctrl); + p++; +/* pci_dev_str_match() updates p to the next segment. */ + ret =pci_dev_str_match (dev, p, &p); +if (ret ==1 ) +return seg; + +if (ret <0 ) { +pr_warn_once ("PCI: Can't parse config_acs param\n" ); +break ; + } + } + +return NULL ; +} + +static void pci_param_config_acs (struct pci_dev *dev,struct pci_acs *caps) +{ +u16 shift =0 , valid_ctrl = dev->acs_capabilities &GENMASK_U16 (6 ,0 ); +u16 invalid_bits, enabled_bits =0 , disabled_bits =0 ; +const char *p, *seg; + +if (!config_acs_param || !valid_ctrl) +return ; + + seg =pci_dev_match_config_acs (dev, config_acs_param); +if (!seg) +return ; + + p =strchr (seg,'@' ); +/* Parse bitstring backwards from '@' */ +while (p > seg) { +if (shift >=16 ) { +pci_err (dev,"ACS bitstring exceeds 16 bits\n" ); +return ; + } +switch (*--p) { +case '1' : + enabled_bits |=BIT (shift); +break ; +case '0' : + disabled_bits |=BIT (shift); +break ; +case 'x' : +case 'X' : +/* Skip this bit */ +break ; +default : +pci_err (dev,"Invalid ACS flag character '%c'\n" , *p); +return ; + } + shift++; + } + + invalid_bits = (enabled_bits | disabled_bits) & ~valid_ctrl; +if (invalid_bits) { +pci_err (dev,"Invalid ACS bits specified: %#06x\n" , + invalid_bits); +return ; + } + +pci_dbg (dev,"ACS enabled: %#06x, disabled: %#06x\n" , + enabled_bits, disabled_bits); + + caps->ctrl = (caps->fw_ctrl | enabled_bits) & ~disabled_bits; }/**
@@ -1008,6 +1037,7 @@ void pci_enable_acs(struct pci_dev *dev) {struct pci_acs caps;bool enable_acs = false; +u16 kernel_default_ctrl;int pos;/* If an iommu is present we start with kernel default caps */
@@ -1026,14 +1056,18 @@ void pci_enable_acs(struct pci_dev *dev)if (enable_acs)pci_std_enable_acs (dev, &caps); + kernel_default_ctrl = caps.ctrl; +/* * Always apply caps from the command line, even if there is no iommu. * Trust that the admin has a reason to change the ACS settings. */ -__pci_config_acs (dev, &caps, disable_acs_redir_param, -PCI_ACS_RR |PCI_ACS_CR |PCI_ACS_EC , - ~(PCI_ACS_RR |PCI_ACS_CR |PCI_ACS_EC )); -__pci_config_acs (dev, &caps, config_acs_param,0 ,0 ); +pci_param_disable_acs_redir (dev, &caps); +pci_param_config_acs (dev, &caps); + +if (caps.ctrl != kernel_default_ctrl) +pci_info (dev,"User configured ACS to %#06x (default: %#06x)\n" , + caps.ctrl, kernel_default_ctrl);pci_write_config_word (dev, pos +PCI_ACS_CTRL , caps.ctrl); }
Signature · 1 line
2.51.0
[email protected]
AI reviewRe: [PATCH v8 4/6] PCI: Refactor disable_acs_redir and config_acs param handling
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
New issues:
- [Critical] The refactored config_acs parsing logic silently rejects empty flag strings and missing delimiters, breaking backward compatibility and dropping diagnostics.
Pre-existing issues:
- [High] Applying command-line ACS parameters clobbers kernel-enforced IOMMU security features and causes sequential parameters to overwrite each other.
- [High] Successful execution of a specific quirk inadvertently skips clearing standard ACS redirection bits, which are then improperly re-enabled. --
commit a4f9c35859d379acf636ff701d27c2c0461fd84d
Author: Wei Wang <[email protected]>
PCI: Refactor disable_acs_redir and config_acs param handling
This patch splits the disable_acs_redir and config_acs parameter processing into dedicated functions. It separates concerns, improves robustness, and makes the control flow explicit.
Quoted 4 lines
drivers/pci/pci.c +0
-0
[ ... ]
drivers/pci/pci.c struct pci_acs { · line 964
Quoted 9 lines
drivers/pci/pci.c +9
-0+static void pci_param_disable_acs_redir (struct pci_dev *dev, +struct pci_acs *caps) +{ +const u16 acs_redir_mask =PCI_ACS_RR |PCI_ACS_CR |PCI_ACS_EC ; + +if (!disable_acs_redir_param || + !pci_dev_match_disable_acs_redir (dev, disable_acs_redir_param) || + !pci_dev_specific_disable_acs_redir (dev)) +return ;
[Severity: High]
This isn't a bug introduced by this patch, but if pci_dev_specific_disable_acs_redir(dev) executes successfully and returns 0, this function returns early.
Could this early return skip clearing the standard redirection bits (PCI_ACS_RR and PCI_ACS_CR) in caps->ctrl?
Because pci_std_enable_acs() previously enabled these bits, the subsequent pci_write_config_word() at the end of pci_enable_acs() will write those enabled bits directly to the standard ACS capability register, actively re-enabling redirection in hardware.
drivers/pci/pci.c
Quoted 2 lines
drivers/pci/pci.c +2
-0+ + caps->ctrl = caps->fw_ctrl & ~acs_redir_mask;
[Severity: High]
This is a pre-existing issue, but pci_param_disable_acs_redir() overwrites caps->ctrl using caps->fw_ctrl as a base.
Would this overwrite completely ignore the security mitigations (like Source Validation and Upstream Forwarding) that were enabled earlier by pci_std_enable_acs()?
As a result, applying disable_acs_redir could unintentionally disable IOMMU isolation features.
If both disable_acs_redir and config_acs are used, won't config_acs silently overwrite the changes made here since both independently assign to caps->ctrl based on caps->fw_ctrl?
Quoted 14 lines
drivers/pci/pci.c +13
-0+} + +static const char *pci_dev_match_config_acs (struct pci_dev *dev,const char *p) +{ +const char *seg; +int ret; + +/* +* Example: 11101010x@0000:01:00.0;101x@0000:02:00.0;1@0000:03:00.0 +* Three segments delimited via ';'. @seg always points to the start +* of a segment and p advances to the start of the device id (BDF) +* after '@'. Upon match, return the start of the matching segment. +*/ while (*p) {
[ ... ]
drivers/pci/pci.c struct pci_acs { · line 940
Quoted 5 lines
drivers/pci/pci.c +5
-0+ seg = p; + p =strchr (seg,'@' ); +/* If malformed string, stop parsing. */ +if (!p || p == seg) +break ;
[Severity: Critical]
If p is NULL or p == seg (such as an empty bitstring like @0000:01:00.0), this break aborts parsing completely, ignoring any subsequent valid segments in the parameter string.
In the original code, an empty flag string was a valid supported format to reset a device to its firmware defaults, and a missing @ delimiter triggered an explicit pci_err() for missing ACS flags.
Does this change introduce a regression by silently rejecting previously valid command lines and depriving administrators of necessary diagnostic feedback for malformed parameters?
Quoted 4 lines
drivers/pci/pci.c +3
-0+ + p++; +/* pci_dev_str_match() updates p to the next segment. */ ret =pci_dev_str_match (dev, p, &p);
[ ... ]
Quoted 2 lines
drivers/pci/pci.c +2
-0+static void pci_param_config_acs (struct pci_dev *dev,struct pci_acs *caps) +{
[ ... ]
drivers/pci/pci.c struct pci_acs {
Quoted 5 lines
drivers/pci/pci.c +3
-1+pci_dbg (dev,"ACS enabled: %#06x, disabled: %#06x\n" , + enabled_bits, disabled_bits); -pci_info (dev,"Configured ACS to %#06x\n" , caps->ctrl); + caps->ctrl = (caps->fw_ctrl | enabled_bits) & ~disabled_bits;
[Severity: High]
This is a pre-existing issue, but similar to pci_param_disable_acs_redir(), this overwrites caps->ctrl using caps->fw_ctrl as a base.
Doesn't this overwrite the security mitigations enabled by pci_std_enable_acs() and silently discard the changes just made by pci_param_disable_acs_redir()?
Could the modifications be applied via bitwise operations on top of caps->ctrl instead?
Quoted 1 line
}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
PATCH v8 5/6 PCI: Enable the enhanced ACS controls introduced by PCI_ACS_ECAP
In reply to a message not in the archiveThe ACS Enhanced Capability introduces several new access controls to improve device isolation. These new controls are particularly important for device passthrough in virtualization scenarios.
For example, a DMA transaction from a device may target a guest physical address that lies within the memory aperture of the switch's upstream port, but not within any memory aperture or BAR space of a downstream port. In such cases, the switch would generate an Unsupported Request (UR) response to the device, which is undesirable. Enabling Unclaimed Request Redirect Control ensures that these DMA requests are forwarded upstream instead of being rejected.
The ACS DSP and USP Memory Target Access Control and ACS I/O Request Blocking features similarly enhance device isolation. Device grouping in Linux assumes that devices are properly isolated. Therefore, enable these controls by default if PCI_ACS_ECAP is supported by the hardware. As with other basic ACS access controls, these new controls can be configured via the "config_acs=" boot parameter.
--- .../admin-guide/kernel-parameters.txt | 23 +++++++++----- drivers/pci/pci.c | 30 +++++++++++++++++-- include/uapi/linux/pci_regs.h | 13 ++++++++ 3 files changed, 57 insertions(+), 9 deletions(-)
Documentation/admin-guide/kernel-parameters.txt +16 -7
@@ -5260,13 +5260,22 @@ Kernel parameters flags. ACS Flags is defined as follows: - bit-0 : ACS Source Validation - bit-1 : ACS Translation Blocking - bit-2 : ACS P2P Request Redirect - bit-3 : ACS P2P Completion Redirect - bit-4 : ACS Upstream Forwarding - bit-5 : ACS P2P Egress Control - bit-6 : ACS Direct Translated P2P + bit-0 : ACS Source Validation + bit-1 : ACS Translation Blocking + bit-2 : ACS P2P Request Redirect + bit-3 : ACS P2P Completion Redirect + bit-4 : ACS Upstream Forwarding + bit-5 : ACS P2P Egress Control + bit-6 : ACS Direct Translated P2P + bit-7 : ACS I/O Request Blocking + bit-9:8 : ACS DSP Memory Target Access Ctrl + 00 : Direct Request access enabled + 01 : Request blocking enabled + 10 : Request redirect enabled + 11 : Reserved + bit-11:10 : ACS USP Memory Target Access Ctrl + Same encoding as bit-9:8 + bit-12 : ACS Unclaimed Request Redirect Ctrl Each bit can be marked as: '0' – force disabled '1' – force enabled
drivers/pci/pci.c +28 -2
@@ -957,9 +957,12 @@ static const char *pci_dev_match_config_acs(struct pci_dev *dev, const char *p)static void pci_param_config_acs (struct pci_dev *dev,struct pci_acs *caps) {u16 shift =0 , valid_ctrl = dev->acs_capabilities &GENMASK_U16 (6 ,0 ); -u16 invalid_bits, enabled_bits =0 , disabled_bits =0 ; +u16 new_ctrl, invalid_bits, enabled_bits =0 , disabled_bits =0 ;const char *p, *seg; +if (dev->acs_capabilities &PCI_ACS_ECAP ) + valid_ctrl |=GENMASK_U16 (12 ,7 ); +if (!config_acs_param || !valid_ctrl)return ;
@@ -999,10 +1002,23 @@ static void pci_param_config_acs(struct pci_dev *dev, struct pci_acs *caps)return ; } +/* +* DMAC/UMAC are 2-bit fields where encoding 0b11 is reserved. The +* final value can land on 0b11 not only when the user enables both +* bits, but also when they enable one bit, e.g. "1x", while fw_ctrl +* already has the other set (e.g. "01"). +*/ + new_ctrl = (caps->fw_ctrl | enabled_bits) & ~disabled_bits; +if (FIELD_GET (PCI_ACS_DMAC_MASK , new_ctrl) ==PCI_ACS_MAC_RSVD || +FIELD_GET (PCI_ACS_UMAC_MASK , new_ctrl) ==PCI_ACS_MAC_RSVD ) { +pci_err (dev,"ACS DMAC/UMAC would be set to reserved value\n" ); +return ; + } +pci_dbg (dev,"ACS enabled: %#06x, disabled: %#06x\n" , enabled_bits, disabled_bits); - caps->ctrl = (caps->fw_ctrl | enabled_bits) & ~disabled_bits; + caps->ctrl = new_ctrl; }/**
@@ -1024,6 +1040,16 @@ static void pci_std_enable_acs(struct pci_dev *dev, struct pci_acs *caps)/* Upstream Forwarding */ caps->ctrl |= (dev->acs_capabilities &PCI_ACS_UF ); +/* +* Enable Unclaimed Request Redirect Control, I/O Request Blocking, +* and Downstream and Upstream Port Memory Target Access Redirect. +*/ +if (dev->acs_capabilities &PCI_ACS_ECAP ) { + caps->ctrl |=PCI_ACS_URRC |PCI_ACS_IB ; +FIELD_MODIFY (PCI_ACS_DMAC_MASK , &caps->ctrl,PCI_ACS_MAC_RR ); +FIELD_MODIFY (PCI_ACS_UMAC_MASK , &caps->ctrl,PCI_ACS_MAC_RR ); + } +/* Enable Translation Blocking for external devices and noats */ if (pci_ats_disabled () || dev->external_facing || dev->untrusted) caps->ctrl |= (dev->acs_capabilities &PCI_ACS_TB );
include/uapi/linux/pci_regs.h +13 -0
@@ -1016,6 +1016,7 @@/* Access Control Service */ #define PCI_ACS_CAP 0x04/* ACS Capability Register */ +#define PCI_ACS_ECAP 0x0080/* ACS Enhanced Capability (CAP reg) */ #define PCI_ACS_SV 0x0001/* Source Validation */ #define PCI_ACS_TB 0x0002/* Translation Blocking */ #define PCI_ACS_RR 0x0004/* P2P Request Redirect */
@@ -1023,10 +1024,22 @@#define PCI_ACS_UF 0x0010/* Upstream Forwarding */ #define PCI_ACS_EC 0x0020/* P2P Egress Control */ #define PCI_ACS_DT 0x0040/* Direct Translated P2P */ +#define PCI_ACS_IB 0x0080/* I/O Request Blocking (CTRL reg) */ +#define PCI_ACS_DMAC_MASK 0x0300/* DSP Memory Target Access Control */ +#define PCI_ACS_UMAC_MASK 0x0C00/* USP Memory Target Access Control */ +#define PCI_ACS_URRC 0x1000/* Unclaimed Request Redirect Ctrl */ #define PCI_ACS_EGRESS_BITS 0x05/* ACS Egress Control Vector Size */ #define PCI_ACS_CTRL 0x06/* ACS Control Register */ #define PCI_ACS_EGRESS_CTL_V 0x08/* ACS Egress Control Vector */ +/* Encodings for DSP and USP Memory Target Access Control */ +enum { +PCI_ACS_MAC_DA =0x0 ,/* Direct request access */ +PCI_ACS_MAC_RB =0x1 ,/* Request blocking */ +PCI_ACS_MAC_RR =0x2 ,/* Request redirect */ +PCI_ACS_MAC_RSVD =0x3 ,/* Reserved */ +}; +/* SATA capability */ #define PCI_SATA_REGS 4/* SATA REGs specifier */ #define PCI_SATA_REGS_MASK 0xF/* location - BAR#/inline */
Signature · 1 line
2.51.0
[email protected]
AI reviewRe: [PATCH v8 5/6] PCI: Enable the enhanced ACS controls introduced by PCI_ACS_ECAP
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [High] Unconditionally modifying port-specific enhanced ACS fields writes to reserved bits on unsupported…
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] Unconditionally modifying port-specific enhanced ACS fields writes to reserved bits on unsupported port types.
- [High] The implementation erroneously assumes a single capability bit dictates support for all distinct enhanced ACS features.
- [Medium] Unconditional validation of reserved DMAC/UMAC bits in pci_param_config_acs() incorrectly rejects valid ACS configurations. --
commit abb6544c6b6950bebc64c85febd33746df14b3cb
Author: Wei Wang <[email protected]>
PCI: Enable the enhanced ACS controls introduced by PCI_ACS_ECAP
The ACS Enhanced Capability introduces several new access controls to improve device isolation. This commit enables Unclaimed Request Redirect Control, DSP and USP Memory Target Access Control, and I/O Request Blocking by default if PCI_ACS_ECAP is supported.
Quoted 4 lines
drivers/pci/pci.c +0
-0
[ ... ]
Quoted 1 line
drivers/pci/pci.c +0
-0@@ -1009,10 +1012,23 @@ static void pci_param_config_acs(struct pci_dev *dev, struct pci_acs *caps)
[ ... ]
drivers/pci/pci.c static void pci_param_config_acs(struct pci_dev *dev, struct pci_acs *caps) · line 1016
Quoted 12 lines
drivers/pci/pci.c +12
-0+/* +* DMAC/UMAC are 2-bit fields where encoding 0b11 is reserved. The +* final value can land on 0b11 not only when the user enables both +* bits, but also when they enable one bit, e.g. "1x", while fw_ctrl +* already has the other set (e.g. "01"). +*/ + new_ctrl = (caps->fw_ctrl | enabled_bits) & ~disabled_bits; +if (FIELD_GET (PCI_ACS_DMAC_MASK , new_ctrl) ==PCI_ACS_MAC_RSVD || +FIELD_GET (PCI_ACS_UMAC_MASK , new_ctrl) ==PCI_ACS_MAC_RSVD ) { +pci_err (dev,"ACS DMAC/UMAC would be set to reserved value\n" ); +return ; + }
[Severity: Medium]
Will this unconditionally reject valid ACS configurations on legacy devices?
If a legacy device has 1s in these reserved bits of its ACS Control register due to hardware implementation choices or flawed firmware, new_ctrl will inherit them from caps->fw_ctrl.
This causes the validation to fail, completely aborting the application of valid user configurations for bits 0-6 via the config_acs= boot parameter.
Should this check be conditional on the device actually supporting the Enhanced ACS features?
[ ... ]
Quoted 1 line
drivers/pci/pci.c +0
-0@@ -1034,6 +1050,16 @@ static void pci_std_enable_acs(struct pci_dev *dev, struct pci_acs *caps)
[ ... ]
drivers/pci/pci.c static void pci_std_enable_acs(struct pci_dev *dev, struct pci_acs *caps) · line 1051
Quoted 9 lines
drivers/pci/pci.c +9
-0+/* +* Enable Unclaimed Request Redirect Control, I/O Request Blocking, +* and Downstream and Upstream Port Memory Target Access Redirect. +*/ +if (dev->acs_capabilities &PCI_ACS_ECAP ) { + caps->ctrl |=PCI_ACS_URRC |PCI_ACS_IB ; +FIELD_MODIFY (PCI_ACS_DMAC_MASK , &caps->ctrl,PCI_ACS_MAC_RR ); +FIELD_MODIFY (PCI_ACS_UMAC_MASK , &caps->ctrl,PCI_ACS_MAC_RR ); + }
[Severity: High]
Does PCI_ACS_ECAP correctly indicate support for all of these discrete features, and are these features applicable to all port types?
The patch defines PCI_ACS_ECAP as 0x0080 (bit 7), which the PCIe specification maps specifically to I/O Request Blocking Support (IBS). By using bit 7 as a catch-all, could the code blindly enable URRC, DMAC, and UMAC on hardware that only supports IBS?
Additionally, these features appear to be port-specific. For example, URRC is only applicable to Downstream Ports, and UMAC is not applicable to Endpoints.
By blindly applying these settings to all port types, could the kernel write non-zero values to reserved bits in the PCI_ACS_CTRL register on unsupported port types?
Would it be better to check the specific discrete capability bits for each feature, and verify the port type before modifying these fields?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
PATCH v8 6/6 PCI: Add the enhanced ACS controls check to pci_acs_flags_enabled()
In reply to a message not in the archiveThe enhanced ACS controls introduced by PCIe Gen 5 ensures better device isolation. On devices that support the PCI_ACS_ECAP capability, the controls are required to be enabled properly:
- ACS I/O Request Blocking needs to be enabled to avoid unintended upstream I/O requests.
- ACS DSP and USP Memory Target Access Control needs to be set with Request Redirect or Request Blocking to ensure the Downstream and Upstream Port memory resource ranges are not accessed by upstream memory requests.
- ACS Unclaimed Request Redirect needs to be enabled to ensure accesses to areas that lies within a Switch's Upstream Port memory apertures but not within any Downstream Port memory apertures get redirected.
To maintain compatibility with legacy devices that lack PCI_ACS_ECAP support, pci_acs_enabled() skips checking for the capability.
--- drivers/pci/pci.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+)
drivers/pci/pci.c +65 -0
@@ -3573,6 +3573,57 @@ void pci_configure_ari(struct pci_dev *dev) } } +static bool pci_dev_has_memory_bars (struct pci_dev *pdev) +{ +int i; + +for (i =0 ; i <=PCI_ROM_RESOURCE ; i++) { +if (pci_resource_flags (pdev, i) &IORESOURCE_MEM ) +return true; + } + +return false; +} + +static bool pci_acs_ecap_enabled (struct pci_dev *pdev,u16 ctrl) +{ +struct pci_dev *upstream_pdev; + +/* +* For ACS DSP/USP Memory Target Access Control, either Request +* Redirect or Request Blocking must be enabled to enforce isolation. +* According to PCIe spec 7.0, the DSP Memory Target Access is +* applicable to both Root Ports and Switch Downstream Ports that have +* applicable Memory BAR space to protect. So if the device does not +* have a Memory BAR, it skips the check. +*/ +if (pci_dev_has_memory_bars (pdev) && +FIELD_GET (PCI_ACS_DMAC_MASK , ctrl) !=PCI_ACS_MAC_RB && +FIELD_GET (PCI_ACS_DMAC_MASK , ctrl) !=PCI_ACS_MAC_RR ) +return false; + +if (pci_pcie_type (pdev) ==PCI_EXP_TYPE_DOWNSTREAM ) { + upstream_pdev =pci_upstream_bridge (pdev); + +/* +* The USP Memory Target Access is only applicable to +* downstream ports that have applicable Memory BAR space in +* the Switch Upstream Port to protect. +*/ +if (upstream_pdev &&pci_dev_has_memory_bars (upstream_pdev) && +FIELD_GET (PCI_ACS_UMAC_MASK , ctrl) !=PCI_ACS_MAC_RB && +FIELD_GET (PCI_ACS_UMAC_MASK , ctrl) !=PCI_ACS_MAC_RR ) +return false; + +/* PCI_ACS_URRC is applicable to Downstream Ports only. */ +if (!(ctrl &PCI_ACS_URRC )) +return false; + } + +/* PCI_ACS_IB is applicable to both Root and Downstream Ports. */ +return !!(ctrl &PCI_ACS_IB ); +} +static bool pci_acs_flags_enabled (struct pci_dev *pdev,u16 acs_flags) {int pos;
@@ -3590,6 +3641,18 @@ static bool pci_acs_flags_enabled(struct pci_dev *pdev, u16 acs_flags) acs_flags &= (pdev->acs_capabilities |PCI_ACS_EC );pci_read_config_word (pdev, pos +PCI_ACS_CTRL , &ctrl); + +if (acs_flags &PCI_ACS_ECAP ) { +if (!pci_acs_ecap_enabled (pdev, ctrl)) +return false; +/* +* The check for the required controls in PCI_ACS_ECAP has +* passed. Clear the ECAP flag and continue to check the +* basic ACS controls. +*/ + acs_flags &= ~PCI_ACS_ECAP ; + } +return (ctrl & acs_flags) == acs_flags; }
@@ -3648,6 +3711,8 @@ bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags)*/ case PCI_EXP_TYPE_DOWNSTREAM :case PCI_EXP_TYPE_ROOT_PORT : +/* PCI_ACS_ECAP applies to Root and Downstream Ports only */ + acs_flags |=PCI_ACS_ECAP ;return pci_acs_flags_enabled (pdev, acs_flags);/* * PCIe 3.0, 6.12.1.2 specifies ACS capabilities that should be
Signature · 1 line
2.51.0