iommu/riscv: Add hardware dirty tracking for second-stage domains
Subsystems (5)
v2 cover iommu/riscv: Add hardware dirty tracking for second-stage domains
From: Fangyu Yu <[email protected]>
The RISC-V IOMMU architecture defines an AMO_HWAD capability (Hardware Access/Dirty update) that allows the IOMMU to atomically set the A/D bits in second-stage PTEs on DMA access. When DC.tc.GADE is asserted, the IOMMU autonomously sets D on the first write to a page mapped by an iohgatp domain. This series wires that capability up to the iommufd dirty-tracking interface (IOMMU_HWPT_SET_DIRTY_TRACKING / IOMMU_HWPT_GET_DIRTY_BITMAP) and reports IOMMU_CAP_DIRTY_TRACKING.
Design notes
------------
* The feature is scoped to second-stage (iohgatp) domains only; these are the domains created for KVM / VFIO device pass-through when userspace allocates an HWPT with IOMMU_HWPT_ALLOC_NEST_PARENT or IOMMU_HWPT_ALLOC_DIRTY_TRACKING. First-stage (iosatp) domains are not touched by this series.
* The page-table side plugs into the existing generic_pt dirty hook framework (amdv1 / vtdss style). RISC-V adds the three required PTE ops – is_write_dirty / make_write_clean / make_write_dirty.
Testing
-------
* Test on QEMU RISC-V, a virtio-net and an e1000e device was passed through to an L2 guest via vfio-pci + iommufd.
* generic_pt KUnit: the existing test_dirty case now runs and passes for the RISC-V 64-bit format.
Follow-up work
--------------
* Build a dedicated end-to-end test case that drives the full flow (HWPT_ALLOC with DIRTY_TRACKING -> attach -> IOAS_MAP -> generate real DMA -> SET_DIRTY_TRACKING -> GET_DIRTY_BITMAP -> verify bitmap against expected IOVA footprint) so that the behaviour can be regression-tested beyond the KUnit PTE-level coverage.
* If possible, rebase and retest on top of the updated "iommu irqbypass" patchset.
---
Changes in v2 (Jason's suggestions):
- Introduced a single PT_FEAT_RISCV_S2: second-stage selection is driven purely by this feature bit.
- Switched from dynamic DC.tc.GADE toggling to static pre-enable.
- domain_alloc_paging_flags: follow the switch/case design from other drivers.
- Drop IOMMU_CAP_DEFERRED_FLUSH in riscv_iommu_capable.
- Remove the .hw_info-related patch.
- Link to v1:
https://lore.kernel.org/linux-riscv/[email protected]/
Fangyu Yu (6):
iommupt: Add RISC-V Second-stage (iohgatp) page table support
iommupt: Add RISC-V dirty tracking PTE ops
iommu/riscv: Add domain_alloc_paging_flags for second-stage domain iommu/riscv: Pre-enable GADE for second-stage domains iommu/riscv: Add dirty tracking support for second-stage domains iommu/riscv: Add IOTINVAL.GVMA after updating DDT/PDT entries
Tomasz Jeznach (2):
iommu/riscv: report iommu capabilities
RISC-V: KVM: Enable KVM_VFIO interfaces on RISC-V arch
Zong Li (2):
iommu/riscv: use data structure instead of individual values iommu/riscv: support GSCID and GVMA invalidation command
arch/riscv/kvm/Kconfig | 2 + drivers/iommu/generic_pt/fmt/riscv.h | 104 ++++++++++++++- drivers/iommu/riscv/iommu-bits.h | 7 + drivers/iommu/riscv/iommu.c | 190 +++++++++++++++++++++------ include/linux/generic_pt/common.h | 5 +- include/linux/generic_pt/iommu.h | 17 ++- 6 files changed, 277 insertions(+), 48 deletions(-)
Signature · 1 line
2.50.1
RFC PATCH v2 1/10 iommupt: Add RISC-V Second-stage (iohgatp) page table support
From: Fangyu Yu <[email protected]>
Add support for Sv39x4/Sv48x4/Sv57x4 Second-stage page tables used by the RISC-V IOMMU iohgatp register. The x4 root page table is 16 KiB instead of the usual 4 KiB, covering 2 extra GPA bits (hw_max_vasz_lg2 = 41/50/59).
--- drivers/iommu/generic_pt/fmt/riscv.h | 61 +++++++++++++++++++++++++--- include/linux/generic_pt/common.h | 5 ++- include/linux/generic_pt/iommu.h | 17 +++++++- 3 files changed, 76 insertions(+), 7 deletions(-)
drivers/iommu/generic_pt/fmt/riscv.h +56 -5
@@ -37,7 +37,16 @@ enum {PT_MAX_OUTPUT_ADDRESS_LG2 =34 ,PT_MAX_TOP_LEVEL =1 , #else -PT_MAX_VA_ADDRESS_LG2 =57 , +/* +* PT_MAX_VA_ADDRESS_LG2 is the upper bound accepted by the generic +* pt_iommu_init() range check. It must cover both first-stage and +* second-stage (G-stage) modes: +* +* First-stage (fsc/iosatp): Sv39=39, Sv48=48, Sv57=57 +* Second-stage (iohgatp): Sv39x4=41, Sv48x4=50, Sv57x4=59 +* +*/ +PT_MAX_VA_ADDRESS_LG2 =59 ,PT_MAX_OUTPUT_ADDRESS_LG2 =56 , PT_MAX_TOP_LEVEL = 4, #endif
@@ -124,6 +133,14 @@ riscvpt_entry_num_contig_lg2(const struct pt_state *pts)static inline unsigned int riscvpt_num_items_lg2 (const struct pt_state *pts) { +/* +* Second-stage (iohgatp) root page tables have 4x the usual number of +* entries (2048 = 2^11 instead of 512 = 2^9) to cover the 2 extra GPA +* bits in Sv39x4/Sv48x4/Sv57x4. Only the root (top) level is +* enlarged; all other levels remain at the standard 9-bit index width. +*/ +if (pts_feature (pts,PT_FEAT_RISCV_S2 ) && pts->level == pts->range->top_level) +return PT_TABLEMEM_LG2SZ -ilog2 (sizeof (u64)) +2 ;return PT_TABLEMEM_LG2SZ -ilog2 (sizeof (u64)); }#define pt_num_items_lg2 riscvpt_num_items_lg2
@@ -254,6 +271,7 @@ riscvpt_iommu_fmt_init(struct pt_iommu_riscv_64 *iommu_table,struct pt_riscv *table = &iommu_table->riscv_64pt;switch (cfg->common.hw_max_vasz_lg2) { +/* First-stage (fsc/iosatp): Sv39 / Sv48 / Sv57 */ case 39 :pt_top_set_level (&table->common,2 );break ;
@@ -263,6 +281,19 @@ riscvpt_iommu_fmt_init(struct pt_iommu_riscv_64 *iommu_table,case 57 :pt_top_set_level (&table->common,4 );break ; +/* +* Second-stage (iohgatp): Sv39x4 / Sv48x4 / Sv57x4. +* The top level is the same as for the first-stage counterpart. +*/ +case 41 : +pt_top_set_level (&table->common,2 ); +break ; +case 50 : +pt_top_set_level (&table->common,3 ); +break ; +case 59 : +pt_top_set_level (&table->common,4 ); +break ;default :return -EINVAL ; }
@@ -283,10 +314,17 @@ riscvpt_iommu_fmt_hw_info(struct pt_iommu_riscv_64 *table,PT_WARN_ON (top_phys & ~PT_TOP_PHYS_MASK );/* -* See Table 3. Encodings of iosatp.MODE field" for DC.tx.SXL = 0: -* 8 = Sv39 = top level 2 -* 9 = Sv38 = top level 3 -* 10 = Sv57 = top level 4 +* Both first-stage (fsc/iosatp) and second-stage (iohgatp) share the +* same MODE numeric values for a given top level: +* top_level 2 -> MODE 8 (Sv39 / Sv39x4) +* top_level 3 -> MODE 9 (Sv48 / Sv48x4) +* top_level 4 -> MODE 10 (Sv57 / Sv57x4) +* +* The union members fsc_iosatp_mode and iohgatp_mode occupy the same +* byte; the caller selects the appropriate name based on domain type. +* +* See "Table 3. Encodings of iosatp.MODE field" (DC.tc.SXL = 0) and +* "Table 2. Encoding of iohgatp.MODE field" in the RISC-V IOMMU spec. */ info->fsc_iosatp_mode = top_range->top_level +6 ; }
@@ -294,6 +332,7 @@ riscvpt_iommu_fmt_hw_info(struct pt_iommu_riscv_64 *table,#if defined(GENERIC_PT_KUNIT )static const struct pt_iommu_riscv_64_cfg riscv_64_kunit_fmt_cfgs[] = { +/* First-stage (fsc/iosatp): Sv39 / Sv48 / Sv57 */ [0 ] = { .common.features =BIT (PT_FEAT_RISCV_SVNAPOT_64K ), .common.hw_max_oasz_lg2 =56 , .common.hw_max_vasz_lg2 = 39 },
@@ -303,6 +342,18 @@ static const struct pt_iommu_riscv_64_cfg riscv_64_kunit_fmt_cfgs[] = { [2 ] = { .common.features =BIT (PT_FEAT_RISCV_SVNAPOT_64K ), .common.hw_max_oasz_lg2 =56 , .common.hw_max_vasz_lg2 =57 }, +/* +* Second-stage (iohgatp): Sv39x4 / Sv48x4 / Sv57x4. + */ + [3 ] = { .common.features =BIT (PT_FEAT_RISCV_SVNAPOT_64K ), + .common.hw_max_oasz_lg2 =56 , + .common.hw_max_vasz_lg2 = 41 }, + [4 ] = { .common.features =0 , + .common.hw_max_oasz_lg2 =56 , + .common.hw_max_vasz_lg2 = 50 }, + [5 ] = { .common.features =BIT (PT_FEAT_RISCV_SVNAPOT_64K ), + .common.hw_max_oasz_lg2 =56 , + .common.hw_max_vasz_lg2 = 59 }, };#define kunit_fmt_cfgs riscv_64_kunit_fmt_cfgsenum {
include/linux/generic_pt/common.h +4 -1
@@ -188,7 +188,10 @@ enum {* Support the 64k contiguous page size following the Svnapot extension. */ PT_FEAT_RISCV_SVNAPOT_64K =PT_FEAT_FMT_START , - +/* +* Using second-stage / iohgatp address translation. +*/ + PT_FEAT_RISCV_S2, }; struct pt_x86_64 {
include/linux/generic_pt/iommu.h +16 -1
@@ -328,7 +328,22 @@ struct pt_iommu_riscv_64_cfg {struct pt_iommu_riscv_64_hw_info {u64 ppn; -u8 fsc_iosatp_mode; +union { +/* +* First-stage (fsc/iosatp) MODE encoding: +* 8 = Sv39, 9 = Sv48, 10 = Sv57 +* Used to program DC.fsc.iosatp.MODE. +*/ +u8 fsc_iosatp_mode; +/* +* Second-stage (iohgatp) MODE encoding: +* 8 = Sv39x4, 9 = Sv48x4, 10 = Sv57x4 +* Used to program DC.iohgatp.MODE. +* The numeric values are identical to fsc_iosatp_mode; +* the caller selects the interpretation based on domain type. +*/ +u8 iohgatp_mode; + }; };IOMMU_FORMAT (riscv_64, riscv_64pt);
Signature · 1 line
2.50.1
Re: [RFC PATCH v2 01/10] iommupt: Add RISC-V Second-stage (iohgatp) page table support
On Thu, May 07, 2026 at 07:36:57PM +0800, [email protected] wrote:
...
include/linux/generic_pt/common.h enum { · line 194
Quoted 13 lines
include/linux/generic_pt/common.h +4
-1@@ -188,7 +188,10 @@ enum {* Support the 64k contiguous page size following the Svnapot extension. */ PT_FEAT_RISCV_SVNAPOT_64K =PT_FEAT_FMT_START , - +/* +* Using second-stage / iohgatp address translation. +*/ + PT_FEAT_RISCV_S2,
Hi Fangyu,
I just sent [1], but I actually discovered that issue when testing this patch and finding PT_FEAT_RISCV_S2 was missing from PT_SUPPORTED_FEATURES. So this patch needs the same fix as [1] as well.
Thanks,
drew
Re: [RFC PATCH v2 01/10] iommupt: Add RISC-V Second-stage (iohgatp) page table support
Quoted 18 lines · On Thu, May 07, 2026 at 07:36:57PM +0800, [email protected] wrote:
...
include/linux/generic_pt/common.h enum { · line 194
Quoted 13 lines
include/linux/generic_pt/common.h +4
-1@@ -188,7 +188,10 @@ enum {* Support the 64k contiguous page size following the Svnapot extension. */ PT_FEAT_RISCV_SVNAPOT_64K =PT_FEAT_FMT_START , - +/* +* Using second-stage / iohgatp address translation. +*/ + PT_FEAT_RISCV_S2,Hi Fangyu,
Quoted 4 lines
I just sent [1], but I actually discovered that issue when testing this patch and finding
PT_FEAT_RISCV_S2was missing fromPT_SUPPORTED_FEATURES. So this patch needs the same fix as [1] as well.
Hi Andrew,
Thanks for catching this. I'll fix it in the next revision.
Quoted 4 lines
Thanks,
drew
RFC PATCH v2 2/10 iommupt: Add RISC-V dirty tracking PTE ops
In reply to [email protected]From: Fangyu Yu <[email protected]>
Implement the three dirty-tracking hooks required by the generic page table framework for the RISC-V format:
pt_entry_is_write_dirty():
Check the D bit (bit 7) in the PTE.
pt_entry_make_write_clean():
Clear the D bit across the full contiguous range.
pt_entry_make_write_dirty():
Atomically set D via try_cmpxchg64() on a single PTE.
--- drivers/iommu/generic_pt/fmt/riscv.h | 43 ++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
drivers/iommu/generic_pt/fmt/riscv.h +43 -0
@@ -222,6 +222,49 @@ static inline void riscvpt_attr_from_entry(const struct pt_state *pts, }#define pt_attr_from_entry riscvpt_attr_from_entry +/* +* Dirty tracking: RISC-V PTEs use D (bit 7) as the hardware dirty bit. +* When Svnapot 64K is active a leaf entry spans 16 consecutive PTEs; we +* must check / clear all of them so that no dirty indication is lost. +*/ +static inline bool riscvpt_entry_is_write_dirty (const struct pt_state *pts) +{ +unsigned int num_contig_lg2 =riscvpt_entry_num_contig_lg2 (pts); +const pt_riscv_entry_t *tablep = +pt_cur_table (pts, pt_riscv_entry_t) + +log2_set_mod (pts->index,0 , num_contig_lg2); +const pt_riscv_entry_t *end = tablep +log2_to_int (num_contig_lg2); + +for (; tablep != end; tablep++) +if (READ_ONCE (*tablep) &RISCVPT_D ) +return true; +return false; +} +#define pt_entry_is_write_dirty riscvpt_entry_is_write_dirty + +static inline void riscvpt_entry_make_write_clean (struct pt_state *pts) +{ +unsigned int num_contig_lg2 =riscvpt_entry_num_contig_lg2 (pts); +pt_riscv_entry_t *tablep = +pt_cur_table (pts, pt_riscv_entry_t) + +log2_set_mod (pts->index,0 , num_contig_lg2); +pt_riscv_entry_t *end = tablep +log2_to_int (num_contig_lg2); + +for (; tablep != end; tablep++) +WRITE_ONCE (*tablep,READ_ONCE (*tablep) & ~(pt_riscv_entry_t )RISCVPT_D ); +} +#define pt_entry_make_write_clean riscvpt_entry_make_write_clean + +static inline bool riscvpt_entry_make_write_dirty (struct pt_state *pts) +{ +pt_riscv_entry_t *tablep = +pt_cur_table (pts, pt_riscv_entry_t) + pts->index; +pt_riscv_entry_t new = pts->entry |RISCVPT_D ; + +return try_cmpxchg64 (tablep, &pts->entry, new); +} +#define pt_entry_make_write_dirty riscvpt_entry_make_write_dirty +/* --- iommu */ #include <linux/generic_pt/iommu.h> #include <linux/iommu.h>
Signature · 1 line
2.50.1
RFC PATCH v2 3/10 iommu/riscv: report iommu capabilities
In reply to [email protected]From: Tomasz Jeznach <[email protected]>
Report RISC-V IOMMU capabilities required by VFIO subsystem to enable PCIe device assignment.
--- drivers/iommu/riscv/iommu.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
drivers/iommu/riscv/iommu.c +11 -0
@@ -1336,6 +1336,16 @@ static struct iommu_group *riscv_iommu_device_group(struct device *dev)return generic_device_group (dev); } +static bool riscv_iommu_capable (struct device *dev,enum iommu_cap cap) +{ +switch (cap) { +case IOMMU_CAP_CACHE_COHERENCY : +return true; +default : +return false; + } +} +static int riscv_iommu_of_xlate (struct device *dev,const struct of_phandle_args *args) {return iommu_fwspec_add_ids (dev, args->args,1 );
@@ -1397,6 +1407,7 @@ static void riscv_iommu_release_device(struct device *dev)static const struct iommu_ops riscv_iommu_ops = { .of_xlate = riscv_iommu_of_xlate, + .capable = riscv_iommu_capable, .identity_domain = &riscv_iommu_identity_domain, .blocked_domain = &riscv_iommu_blocking_domain, .release_domain = &riscv_iommu_blocking_domain,
Signature · 1 line
2.50.1
RFC PATCH v2 4/10 iommu/riscv: use data structure instead of individual values
In reply to [email protected]From: Zong Li <[email protected]>
The parameter will be increased when we need to set up more bit fields in the device context. Use a data structure to wrap them up.
--- drivers/iommu/riscv/iommu.c | 27 +++++++++++++++++---------- 1 file changed, 17 insertions(+), 10 deletions(-)
drivers/iommu/riscv/iommu.c +17 -10
@@ -1077,7 +1077,7 @@ static void riscv_iommu_iodir_iotinval(struct riscv_iommu_device *iommu,* interim translation faults. */ static void riscv_iommu_iodir_update (struct riscv_iommu_device *iommu, -struct device *dev,u64 fsc,u64 ta) +struct device *dev,struct riscv_iommu_dc *new_dc) {struct iommu_fwspec *fwspec =dev_iommu_fwspec_get (dev);struct riscv_iommu_dc *dc;
@@ -1116,10 +1116,10 @@ static void riscv_iommu_iodir_update(struct riscv_iommu_device *iommu,for (i =0 ; i < fwspec->num_ids; i++) { dc =riscv_iommu_get_dc (iommu, fwspec->ids[i]); tc =READ_ONCE (dc->tc); - tc |= ta &RISCV_IOMMU_DC_TC_V ; + tc |= new_dc->ta &RISCV_IOMMU_DC_TC_V ; -WRITE_ONCE (dc->fsc, fsc); -WRITE_ONCE (dc->ta, ta &RISCV_IOMMU_PC_TA_PSCID ); +WRITE_ONCE (dc->fsc, new_dc->fsc); +WRITE_ONCE (dc->ta, new_dc->ta &RISCV_IOMMU_PC_TA_PSCID );/* Update device context, write TC.V as the last step. */ dma_wmb ();WRITE_ONCE (dc->tc, tc);
@@ -1205,22 +1205,22 @@ static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain,struct riscv_iommu_device *iommu =dev_to_iommu (dev);struct riscv_iommu_info *info =dev_iommu_priv_get (dev);struct pt_iommu_riscv_64_hw_info pt_info; -u64 fsc, ta; +struct riscv_iommu_dc dc = {0 };pt_iommu_riscv_64_hw_info (&domain->riscvpt, &pt_info);if (!riscv_iommu_pt_supported (iommu, pt_info.fsc_iosatp_mode))return -ENODEV ; - fsc =FIELD_PREP (RISCV_IOMMU_PC_FSC_MODE , pt_info.fsc_iosatp_mode) | + dc.fsc =FIELD_PREP (RISCV_IOMMU_PC_FSC_MODE , pt_info.fsc_iosatp_mode) |FIELD_PREP (RISCV_IOMMU_PC_FSC_PPN , pt_info.ppn); - ta =FIELD_PREP (RISCV_IOMMU_PC_TA_PSCID , domain->pscid) | + dc.ta =FIELD_PREP (RISCV_IOMMU_PC_TA_PSCID , domain->pscid) |RISCV_IOMMU_PC_TA_V ;if (riscv_iommu_bond_link (domain, dev))return -ENOMEM ; -riscv_iommu_iodir_update (iommu, dev, fsc, ta); +riscv_iommu_iodir_update (iommu, dev, &dc);riscv_iommu_bond_unlink (info->domain, dev); info->domain = domain;
@@ -1292,9 +1292,12 @@ static int riscv_iommu_attach_blocking_domain(struct iommu_domain *iommu_domain, {struct riscv_iommu_device *iommu =dev_to_iommu (dev);struct riscv_iommu_info *info =dev_iommu_priv_get (dev); +struct riscv_iommu_dc dc = {0 }; + + dc.fsc =RISCV_IOMMU_FSC_BARE ;/* Make device context invalid, translation requests will fault w/ #258 */ -riscv_iommu_iodir_update (iommu, dev,RISCV_IOMMU_FSC_BARE ,0 ); +riscv_iommu_iodir_update (iommu, dev, &dc);riscv_iommu_bond_unlink (info->domain, dev); info->domain =NULL ;
@@ -1314,8 +1317,12 @@ static int riscv_iommu_attach_identity_domain(struct iommu_domain *iommu_domain, {struct riscv_iommu_device *iommu =dev_to_iommu (dev);struct riscv_iommu_info *info =dev_iommu_priv_get (dev); +struct riscv_iommu_dc dc = {0 }; + + dc.fsc =RISCV_IOMMU_FSC_BARE ; + dc.ta =RISCV_IOMMU_PC_TA_V ; -riscv_iommu_iodir_update (iommu, dev,RISCV_IOMMU_FSC_BARE ,RISCV_IOMMU_PC_TA_V ); +riscv_iommu_iodir_update (iommu, dev, &dc);riscv_iommu_bond_unlink (info->domain, dev); info->domain =NULL ;
Signature · 1 line
2.50.1
RFC PATCH v2 5/10 iommu/riscv: support GSCID and GVMA invalidation command
In reply to [email protected]From: Zong Li <[email protected]>
This patch adds a ID Allocator for GSCID and a wrap for setting up GSCID in IOTLB invalidation command.
Set up iohgatp to enable second stage table and flush stage-2 table if the GSCID is set.
The GSCID of domain should be freed when release domain. GSCID will be allocated for parent domain in nested IOMMU process.
--- drivers/iommu/riscv/iommu-bits.h | 7 +++++++ drivers/iommu/riscv/iommu.c | 32 ++++++++++++++++++++++++++------ 2 files changed, 33 insertions(+), 6 deletions(-)
drivers/iommu/riscv/iommu-bits.h +7 -0
@@ -716,6 +716,13 @@ static inline void riscv_iommu_cmd_inval_vma(struct riscv_iommu_command *cmd) cmd->dword1 =0 ; } +static inline void riscv_iommu_cmd_inval_gvma (struct riscv_iommu_command *cmd) +{ + cmd->dword0 =FIELD_PREP (RISCV_IOMMU_CMD_OPCODE ,RISCV_IOMMU_CMD_IOTINVAL_OPCODE ) | +FIELD_PREP (RISCV_IOMMU_CMD_FUNC ,RISCV_IOMMU_CMD_IOTINVAL_FUNC_GVMA ); + cmd->dword1 =0 ; +} +static inline void riscv_iommu_cmd_inval_set_addr (struct riscv_iommu_command *cmd,u64 addr) {
drivers/iommu/riscv/iommu.c +26 -6
@@ -48,6 +48,10 @@static DEFINE_IDA (riscv_iommu_pscids);#define RISCV_IOMMU_MAX_PSCID (BIT(20) - 1) +/* IOMMU GSCID allocation namespace. */ +static DEFINE_IDA (riscv_iommu_gscids); +#define RISCV_IOMMU_MAX_GSCID (BIT(16) - 1) +/* Device resource-managed allocations */ struct riscv_iommu_devres {void *addr;
@@ -819,6 +823,7 @@ struct riscv_iommu_domain {struct list_head bonds;spinlock_t lock;/* protect bonds list updates. */ int pscid; +int gscid; }; PT_IOMMU_CHECK_DOMAIN(struct riscv_iommu_domain, riscvpt.iommu, domain);
@@ -967,15 +972,20 @@ static void riscv_iommu_iotlb_inval(struct riscv_iommu_domain *domain,/* * IOTLB invalidation request can be safely omitted if already sent -* to the IOMMU for the same PSCID, and with domain->bonds list +* to the IOMMU for the same PSCID/GSCID, and with domain->bonds list * arranged based on the device's IOMMU, it's sufficient to check * last device the invalidation was sent to. */ if (iommu == prev)continue ; -riscv_iommu_cmd_inval_vma (&cmd); -riscv_iommu_cmd_inval_set_pscid (&cmd, domain->pscid); +if (domain->gscid) { +riscv_iommu_cmd_inval_gvma (&cmd); +riscv_iommu_cmd_inval_set_gscid (&cmd, domain->gscid); + }else { +riscv_iommu_cmd_inval_vma (&cmd); +riscv_iommu_cmd_inval_set_pscid (&cmd, domain->pscid); + }if (end - start <RISCV_IOMMU_IOTLB_INVAL_LIMIT -1 ) {unsigned long iova = start;
@@ -1120,6 +1130,7 @@ static void riscv_iommu_iodir_update(struct riscv_iommu_device *iommu,WRITE_ONCE (dc->fsc, new_dc->fsc);WRITE_ONCE (dc->ta, new_dc->ta &RISCV_IOMMU_PC_TA_PSCID ); +WRITE_ONCE (dc->iohgatp, new_dc->iohgatp);/* Update device context, write TC.V as the last step. */ dma_wmb ();WRITE_ONCE (dc->tc, tc);
@@ -1175,8 +1186,10 @@ static void riscv_iommu_free_paging_domain(struct iommu_domain *iommu_domain)WARN_ON (!list_empty (&domain->bonds)); -if ((int )domain->pscid >0 ) +if (domain->pscid >0 )ida_free (&riscv_iommu_pscids, domain->pscid); +if (domain->gscid >0 ) +ida_free (&riscv_iommu_gscids, domain->gscid);pt_iommu_deinit (&domain->riscvpt.iommu);kfree (domain);
@@ -1212,8 +1225,15 @@ static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain,if (!riscv_iommu_pt_supported (iommu, pt_info.fsc_iosatp_mode))return -ENODEV ; - dc.fsc =FIELD_PREP (RISCV_IOMMU_PC_FSC_MODE , pt_info.fsc_iosatp_mode) | -FIELD_PREP (RISCV_IOMMU_PC_FSC_PPN , pt_info.ppn); +if (domain->gscid) { + dc.iohgatp =FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_MODE , pt_info.iohgatp_mode) | +FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_GSCID , domain->gscid) | +FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_PPN , pt_info.ppn); + }else { + dc.fsc =FIELD_PREP (RISCV_IOMMU_PC_FSC_MODE , pt_info.fsc_iosatp_mode) | +FIELD_PREP (RISCV_IOMMU_PC_FSC_PPN , pt_info.ppn); + } + dc.ta =FIELD_PREP (RISCV_IOMMU_PC_TA_PSCID , domain->pscid) |RISCV_IOMMU_PC_TA_V ;
Signature · 1 line
2.50.1
Re: [RFC PATCH v2 05/10] iommu/riscv: support GSCID and GVMA invalidation command
Review static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain, · line 1226
Quoted 3 lines · On Thu, May 07, 2026 at 07:37:01PM +0800, [email protected] wrote:
(quoted diff) +0
-0@@ -1212,8 +1225,15 @@ static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain, if (!riscv_iommu_pt_supported(iommu, pt_info.fsc_iosatp_mode)) return -ENODEV;
This needs something like the below diff squashed in.
Thanks,
drew
Quoted 5 lines
(quoted diff) +2
-2- dc.fsc = FIELD_PREP(RISCV_IOMMU_PC_FSC_MODE, pt_info.fsc_iosatp_mode) | - FIELD_PREP(RISCV_IOMMU_PC_FSC_PPN, pt_info.ppn); + if (domain->gscid) { + dc.iohgatp = FIELD_PREP(RISCV_IOMMU_DC_IOHGATP_MODE, pt_info.iohgatp_mode) |
Review static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain, · line 1238
Quoted 10 lines
(quoted diff) +7
-0+ FIELD_PREP(RISCV_IOMMU_DC_IOHGATP_GSCID, domain->gscid) | + FIELD_PREP(RISCV_IOMMU_DC_IOHGATP_PPN, pt_info.ppn); + } else { + dc.fsc = FIELD_PREP(RISCV_IOMMU_PC_FSC_MODE, pt_info.fsc_iosatp_mode) | + FIELD_PREP(RISCV_IOMMU_PC_FSC_PPN, pt_info.ppn); + } + dc.ta = FIELD_PREP(RISCV_IOMMU_PC_TA_PSCID, domain->pscid) | RISCV_IOMMU_PC_TA_V;
drivers/iommu/riscv/iommu.c +23 -5
@@ -1262,9 +1262,9 @@ static void riscv_iommu_free_paging_domain(struct iommu_domain *iommu_domain)kfree (domain); } -static bool riscv_iommu_pt_supported (struct riscv_iommu_device *iommu,int pgd_mode) +static bool riscv_iommu_fsc_supported (struct riscv_iommu_device *iommu,int mode) { -switch (pgd_mode) { +switch (mode) {case RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV39 :return iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39 ;
@@ -1277,6 +1277,21 @@ static bool riscv_iommu_pt_supported(struct riscv_iommu_device *iommu, int pgd_mreturn false; } +static bool riscv_iommu_iohgatp_supported (struct riscv_iommu_device *iommu,int mode) +{ +switch (mode) { +case RISCV_IOMMU_DC_IOHGATP_MODE_SV39X4 : +return iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39X4 ; + +case RISCV_IOMMU_DC_IOHGATP_MODE_SV48X4 : +return iommu->caps &RISCV_IOMMU_CAPABILITIES_SV48X4 ; + +case RISCV_IOMMU_DC_IOHGATP_MODE_SV57X4 : +return iommu->caps &RISCV_IOMMU_CAPABILITIES_SV57X4 ; + } +return false; +} +static int riscv_iommu_attach_paging_domain (struct iommu_domain *iommu_domain,struct device *dev,struct iommu_domain *old)
@@ -1294,14 +1309,17 @@ static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain,pt_iommu_riscv_64_hw_info (&domain->riscvpt, &pt_info); -if (!riscv_iommu_pt_supported (iommu, pt_info.fsc_iosatp_mode)) -return -ENODEV ; -if (domain->gscid) { +if (!riscv_iommu_iohgatp_supported (iommu, pt_info.iohgatp_mode)) +return -ENODEV ; + dc.iohgatp =FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_MODE , pt_info.iohgatp_mode) |FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_GSCID , domain->gscid) |FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_PPN , pt_info.ppn); }else { +if (!riscv_iommu_fsc_supported (iommu, pt_info.fsc_iosatp_mode)) +return -ENODEV ; + dc.fsc =FIELD_PREP (RISCV_IOMMU_PC_FSC_MODE , pt_info.fsc_iosatp_mode) |FIELD_PREP (RISCV_IOMMU_PC_FSC_PPN , pt_info.ppn); }
Re: [RFC PATCH v2 05/10] iommu/riscv: support GSCID and GVMA invalidation command
Quoted 9 lines
Review static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain, · line 1226
Quoted 3 lines
(quoted diff) +0
-0@@ -1212,8 +1225,15 @@ static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain, if (!riscv_iommu_pt_supported(iommu, pt_info.fsc_iosatp_mode)) return -ENODEV;This needs something like the below diff squashed in.
Thanks,
drew
Thanks, agreed.
I'll split the helper into fsc/iohgatp variants and squash this into patch 5 for next version.
Quoted 75 lines
Quoted 15 lines
(quoted diff) +9
-2- dc.fsc = FIELD_PREP(RISCV_IOMMU_PC_FSC_MODE, pt_info.fsc_iosatp_mode) | - FIELD_PREP(RISCV_IOMMU_PC_FSC_PPN, pt_info.ppn); + if (domain->gscid) { + dc.iohgatp = FIELD_PREP(RISCV_IOMMU_DC_IOHGATP_MODE, pt_info.iohgatp_mode) | + FIELD_PREP(RISCV_IOMMU_DC_IOHGATP_GSCID, domain->gscid) | + FIELD_PREP(RISCV_IOMMU_DC_IOHGATP_PPN, pt_info.ppn); + } else { + dc.fsc = FIELD_PREP(RISCV_IOMMU_PC_FSC_MODE, pt_info.fsc_iosatp_mode) | + FIELD_PREP(RISCV_IOMMU_PC_FSC_PPN, pt_info.ppn); + } + dc.ta = FIELD_PREP(RISCV_IOMMU_PC_TA_PSCID, domain->pscid) | RISCV_IOMMU_PC_TA_V;drivers/iommu/riscv/iommu.c +23
-5@@ -1262,9 +1262,9 @@ static void riscv_iommu_free_paging_domain(struct iommu_domain *iommu_domain)kfree (domain); } -static bool riscv_iommu_pt_supported (struct riscv_iommu_device *iommu,int pgd_mode) +static bool riscv_iommu_fsc_supported (struct riscv_iommu_device *iommu,int mode) { -switch (pgd_mode) { +switch (mode) {case RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV39 :return iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39 ;@@ -1277,6 +1277,21 @@ static bool riscv_iommu_pt_supported(struct riscv_iommu_device *iommu, int pgd_mreturn false; } +static bool riscv_iommu_iohgatp_supported (struct riscv_iommu_device *iommu,int mode) +{ +switch (mode) { +case RISCV_IOMMU_DC_IOHGATP_MODE_SV39X4 : +return iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39X4 ; + +case RISCV_IOMMU_DC_IOHGATP_MODE_SV48X4 : +return iommu->caps &RISCV_IOMMU_CAPABILITIES_SV48X4 ; + +case RISCV_IOMMU_DC_IOHGATP_MODE_SV57X4 : +return iommu->caps &RISCV_IOMMU_CAPABILITIES_SV57X4 ; + } +return false; +} +static int riscv_iommu_attach_paging_domain (struct iommu_domain *iommu_domain,struct device *dev,struct iommu_domain *old)@@ -1294,14 +1309,17 @@ static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain,pt_iommu_riscv_64_hw_info (&domain->riscvpt, &pt_info); -if (!riscv_iommu_pt_supported (iommu, pt_info.fsc_iosatp_mode)) -return -ENODEV ; -if (domain->gscid) { +if (!riscv_iommu_iohgatp_supported (iommu, pt_info.iohgatp_mode)) +return -ENODEV ; + dc.iohgatp =FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_MODE , pt_info.iohgatp_mode) |FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_GSCID , domain->gscid) |FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_PPN , pt_info.ppn); }else { +if (!riscv_iommu_fsc_supported (iommu, pt_info.fsc_iosatp_mode)) +return -ENODEV ; + dc.fsc =FIELD_PREP (RISCV_IOMMU_PC_FSC_MODE , pt_info.fsc_iosatp_mode) |FIELD_PREP (RISCV_IOMMU_PC_FSC_PPN , pt_info.ppn); }
RFC PATCH v2 6/10 RISC-V: KVM: Enable KVM_VFIO interfaces on RISC-V arch
In reply to [email protected]From: Tomasz Jeznach <[email protected]>
Enable KVM/VFIO support on RISC-V architecture.
--- arch/riscv/kvm/Kconfig | 2 ++ 1 file changed, 2 insertions(+)
arch/riscv/kvm/Kconfig +2 -0
@@ -30,8 +30,10 @@ config KVM select KVM_GENERIC_HARDWARE_ENABLING select KVM_MMIO select VIRT_XFER_TO_GUEST_WORK + select KVM_VFIO select SCHED_INFO select GUEST_PERF_EVENTS if PERF_EVENTS + select SRCU help Support hosting virtualized guest machines.
Signature · 1 line
2.50.1
RFC PATCH v2 7/10 iommu/riscv: Add domain_alloc_paging_flags for second-stage domain
In reply to [email protected]From: Fangyu Yu <[email protected]>
Replace .domain_alloc_paging with .domain_alloc_paging_flags so callers can pass allocation flags to select the appropriate page-table type.
When IOMMU_HWPT_ALLOC_NEST_PARENT or IOMMU_HWPT_ALLOC_DIRTY_TRACKING is set in @flags, allocate a second-stage (iohgatp) domain.
When @flags is 0 the behaviour is identical to the previousdomain_alloc_paging: first-stage (iosatp) domain.
--- drivers/iommu/riscv/iommu.c | 90 +++++++++++++++++++++++++++---------- 1 file changed, 67 insertions(+), 23 deletions(-)
drivers/iommu/riscv/iommu.c +67 -23
@@ -1255,25 +1255,21 @@ static const struct iommu_domain_ops riscv_iommu_paging_domain_ops = { .flush_iotlb_all = riscv_iommu_iotlb_flush_all, }; -static struct iommu_domain *riscv_iommu_alloc_paging_domain (struct device *dev) +static struct iommu_domain *riscv_iommu_domain_alloc_paging_flags ( +struct device *dev,u32 flags, +const struct iommu_user_data *user_data) {struct pt_iommu_riscv_64_cfg cfg = {};struct riscv_iommu_domain *domain;struct riscv_iommu_device *iommu;int ret; +const u32 supported_flags =IOMMU_HWPT_ALLOC_DIRTY_TRACKING | +IOMMU_HWPT_ALLOC_NEST_PARENT ; - iommu =dev_to_iommu (dev); -if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV57 ) { - cfg.common.hw_max_vasz_lg2 =57 ; - }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV48 ) { - cfg.common.hw_max_vasz_lg2 =48 ; - }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39 ) { - cfg.common.hw_max_vasz_lg2 =39 ; - }else { -dev_err (dev,"cannot find supported page table mode\n" ); -return ERR_PTR (-ENODEV ); - } - cfg.common.hw_max_oasz_lg2 =56 ; +if (flags & ~supported_flags) +return ERR_PTR (-EOPNOTSUPP ); +if (user_data) +return ERR_PTR (-EOPNOTSUPP ); domain =kzalloc_obj (*domain);if (!domain)
@@ -1281,6 +1277,8 @@ static struct iommu_domain *riscv_iommu_alloc_paging_domain(struct device *dev)INIT_LIST_HEAD_RCU (&domain->bonds);spin_lock_init (&domain->lock); + iommu =dev_to_iommu (dev); + cfg.common.hw_max_oasz_lg2 =56 ;/* * 6.4 IOMMU capabilities [..] IOMMU implementations must support the * Svnapot standard extension for NAPOT Translation Contiguity.
@@ -1291,19 +1289,65 @@ static struct iommu_domain *riscv_iommu_alloc_paging_domain(struct device *dev) domain->riscvpt.iommu.nid =dev_to_node (iommu->dev); domain->domain.ops = &riscv_iommu_paging_domain_ops; - domain->pscid =ida_alloc_range (&riscv_iommu_pscids,1 , -RISCV_IOMMU_MAX_PSCID ,GFP_KERNEL ); -if (domain->pscid <0 ) { -riscv_iommu_free_paging_domain (&domain->domain); -return ERR_PTR (-ENOMEM ); +switch (flags) { +case 0 : +if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV57 ) { + cfg.common.hw_max_vasz_lg2 =57 ; + }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV48 ) { + cfg.common.hw_max_vasz_lg2 =48 ; + }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39 ) { + cfg.common.hw_max_vasz_lg2 =39 ; + }else { + ret = -ENODEV ; + goto err_free; + } + domain->pscid =ida_alloc_range (&riscv_iommu_pscids,1 , +RISCV_IOMMU_MAX_PSCID ,GFP_KERNEL ); +if (domain->pscid <0 ) { + ret = -ENOMEM ; + goto err_free; + } +break ; +case IOMMU_HWPT_ALLOC_NEST_PARENT : +case IOMMU_HWPT_ALLOC_DIRTY_TRACKING : +case IOMMU_HWPT_ALLOC_DIRTY_TRACKING |IOMMU_HWPT_ALLOC_NEST_PARENT : +/* +* Second-stage (iohgatp) page table for KVM VFIO device +* pass-through and dirty tracking. The GPA space is 2 bits +* wider than the corresponding first-stage VA space (x4 root +* page table), so hw_max_vasz_lg2 values are 41/50/59. +*/ +if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV57X4 ) { + cfg.common.hw_max_vasz_lg2 =59 ; + }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV48X4 ) { + cfg.common.hw_max_vasz_lg2 =50 ; + }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39X4 ) { + cfg.common.hw_max_vasz_lg2 =41 ; + }else { + ret = -ENODEV ; + goto err_free; + } + domain->gscid =ida_alloc_range (&riscv_iommu_gscids,1 , +RISCV_IOMMU_MAX_GSCID ,GFP_KERNEL ); +if (domain->gscid <0 ) { + ret = -ENOMEM ; + goto err_free; + } + cfg.common.features |=BIT (PT_FEAT_RISCV_S2 ); +break ; +default : + ret = -EOPNOTSUPP ; + goto err_free; } ret =pt_iommu_riscv_64_init (&domain->riscvpt, &cfg,GFP_KERNEL ); -if (ret) { -riscv_iommu_free_paging_domain (&domain->domain); -return ERR_PTR (ret); - } +if (ret) + goto err_free;return &domain->domain; + +err_free: +riscv_iommu_free_paging_domain (&domain->domain); +return ERR_PTR (ret); } static int riscv_iommu_attach_blocking_domain(struct iommu_domain *iommu_domain,
@@ -1438,7 +1482,7 @@ static const struct iommu_ops riscv_iommu_ops = { .identity_domain = &riscv_iommu_identity_domain, .blocked_domain = &riscv_iommu_blocking_domain, .release_domain = &riscv_iommu_blocking_domain, - .domain_alloc_paging = riscv_iommu_alloc_paging_domain, + .domain_alloc_paging_flags = riscv_iommu_domain_alloc_paging_flags, .device_group = riscv_iommu_device_group, .probe_device = riscv_iommu_probe_device, .release_device = riscv_iommu_release_device,
Signature · 1 line
2.50.1
Re: [RFC PATCH v2 07/10] iommu/riscv: Add domain_alloc_paging_flags for second-stage domain
On Thu, May 07, 2026 at 07:37:03PM +0800, [email protected] wrote:
...
Quoted 16 lines
drivers/iommu/riscv/iommu.c +16
-0+case IOMMU_HWPT_ALLOC_NEST_PARENT : +case IOMMU_HWPT_ALLOC_DIRTY_TRACKING : +case IOMMU_HWPT_ALLOC_DIRTY_TRACKING |IOMMU_HWPT_ALLOC_NEST_PARENT : +/* +* Second-stage (iohgatp) page table for KVM VFIO device +* pass-through and dirty tracking. The GPA space is 2 bits +* wider than the corresponding first-stage VA space (x4 root +* page table), so hw_max_vasz_lg2 values are 41/50/59. +*/ +if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV57X4 ) { + cfg.common.hw_max_vasz_lg2 =59 ; + }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV48X4 ) { + cfg.common.hw_max_vasz_lg2 =50 ; + }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39X4 ) { + cfg.common.hw_max_vasz_lg2 =41 ; + }else {
drivers/iommu/riscv/iommu.c static struct iommu_domain *riscv_iommu_alloc_paging_domain(struct device *dev) · line 1336
Quoted 10 lines
drivers/iommu/riscv/iommu.c +10
-0+ ret = -ENODEV ; + goto err_free; + } + domain->gscid =ida_alloc_range (&riscv_iommu_gscids,1 , +RISCV_IOMMU_MAX_GSCID ,GFP_KERNEL ); +if (domain->gscid <0 ) { + ret = -ENOMEM ; + goto err_free; + } + cfg.common.features |=BIT (PT_FEAT_RISCV_S2 );
cfg.common.features currently has PT_FEAT_SIGN_EXTEND which isn't correct for the second stage. So it needs to removed and then added back in for the first stage. riscv_64_kunit_fmt_cfgs[] in the kunit test will then need to also be updated.
Thanks,
drew
Re: [RFC PATCH v2 07/10] iommu/riscv: Add domain_alloc_paging_flags for second-stage domain
Quoted 25 lines · On Thu, May 07, 2026 at 07:37:03PM +0800, [email protected] wrote:
...
Quoted 23 lines
drivers/iommu/riscv/iommu.c +23
-0+case IOMMU_HWPT_ALLOC_NEST_PARENT : +case IOMMU_HWPT_ALLOC_DIRTY_TRACKING : +case IOMMU_HWPT_ALLOC_DIRTY_TRACKING |IOMMU_HWPT_ALLOC_NEST_PARENT : +/* +* Second-stage (iohgatp) page table for KVM VFIO device +* pass-through and dirty tracking. The GPA space is 2 bits +* wider than the corresponding first-stage VA space (x4 root +* page table), so hw_max_vasz_lg2 values are 41/50/59. +*/ +if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV57X4 ) { + cfg.common.hw_max_vasz_lg2 =59 ; + }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV48X4 ) { + cfg.common.hw_max_vasz_lg2 =50 ; + }else if (iommu->caps &RISCV_IOMMU_CAPABILITIES_SV39X4 ) { + cfg.common.hw_max_vasz_lg2 =41 ; + }else { + ret = -ENODEV ; + goto err_free; + } + domain->gscid =ida_alloc_range (&riscv_iommu_gscids,1 , +RISCV_IOMMU_MAX_GSCID ,GFP_KERNEL ); +if (domain->gscid <0 ) { + ret = -ENOMEM ;
Quoted 8 lines
drivers/iommu/riscv/iommu.c static struct iommu_domain *riscv_iommu_alloc_paging_domain(struct device *dev) · line 1336
Quoted 3 lines
drivers/iommu/riscv/iommu.c +3
-0+ goto err_free; + } + cfg.common.features |=BIT (PT_FEAT_RISCV_S2 );cfg.common.features currently has
PT_FEAT_SIGN_EXTENDwhich isn't correct for the second stage. So it needs to removed and then added back in for the first stage. riscv_64_kunit_fmt_cfgs[] in the kunit test will then need to also be updated.
Thanks, agreed. PT_FEAT_SIGN_EXTEND is only valid for first-stage VA translation and should not be inherited by iohgatp domains. I'll move PT_FEAT_SIGN_EXTEND into the first-stage allocation path, leave second-stage domains with PT_FEAT_RISCV_S2 only, and update the RISC-V KUnit configs accordingly in next version.
Quoted 3 lines
Thanks,
drew
RFC PATCH v2 8/10 iommu/riscv: Pre-enable GADE for second-stage domains
In reply to [email protected]From: Fangyu Yu <[email protected]>
Pre-enable RISCV_IOMMU_DC_TC_GADE in the device context when attaching a second-stage domain, if the IOMMU supports AMO_HWAD.
Software pre-populates second-stage page tables with D set, so enabling GADE by default does not change normal behavior. When dirty tracking is enabled, iommufd clears the pre-set D bits and GADE becomes necessary for hardware to update the dirty bit on write access.
This avoids toggling GADE dynamically and keeps device context setup consistent with second-stage domain attachment.
--- drivers/iommu/riscv/iommu.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/iommu/riscv/iommu.c +2 -0
@@ -1229,6 +1229,8 @@ static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain, dc.iohgatp =FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_MODE , pt_info.iohgatp_mode) |FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_GSCID , domain->gscid) |FIELD_PREP (RISCV_IOMMU_DC_IOHGATP_PPN , pt_info.ppn); +if (iommu->caps &RISCV_IOMMU_CAPABILITIES_AMO_HWAD ) + dc.tc |=RISCV_IOMMU_DC_TC_GADE ; }else { dc.fsc =FIELD_PREP (RISCV_IOMMU_PC_FSC_MODE , pt_info.fsc_iosatp_mode) |FIELD_PREP (RISCV_IOMMU_PC_FSC_PPN , pt_info.ppn);
Signature · 1 line
2.50.1
RFC PATCH v2 9/10 iommu/riscv: Add dirty tracking support for second-stage domains
In reply to [email protected]From: Fangyu Yu <[email protected]>
Add hardware dirty tracking support for second-stage (iohgatp) domains used in KVM VFIO device pass-through.
The RISC-V IOMMU can automatically set the dirty bit in PTEs on write access when DC.tc.GADE is set and the hardware has AMO_HWAD capability. Wire this up to the iommufd dirty tracking interface:
- riscv_iommu_set_dirty_tracking(): Always enabled dirty tracking for second-stage domain.
- riscv_iommu_dirty_ops: Exposes set_dirty_tracking and the generic page-table read_and_clear_dirty via IOMMU_PT_DIRTY_OPS(riscv_64).
- domain_alloc_paging_flags: Assigns dirty_ops to second-stage domains when AMO_HWAD is advertised in hardware capabilities.
- riscv_iommu_capable: Reports IOMMU_CAP_DIRTY_TRACKING when AMO_HWAD is present.
--- drivers/iommu/riscv/iommu.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
drivers/iommu/riscv/iommu.c +21 -0
@@ -1249,6 +1249,21 @@ static int riscv_iommu_attach_paging_domain(struct iommu_domain *iommu_domain,return 0 ; } +static int riscv_iommu_set_dirty_tracking (struct iommu_domain *iommu_domain, +bool enable) +{ +/* +* Always enabled and the dirty bitmap is cleared prior to +* set_dirty_tracking(). +*/ +return 0 ; +} + +static const struct iommu_dirty_ops riscv_iommu_dirty_ops = { +IOMMU_PT_DIRTY_OPS (riscv_64), + .set_dirty_tracking = riscv_iommu_set_dirty_tracking, +}; +static const struct iommu_domain_ops riscv_iommu_paging_domain_ops = {IOMMU_PT_DOMAIN_OPS (riscv_64), .attach_dev = riscv_iommu_attach_paging_domain,
@@ -1336,6 +1351,8 @@ static struct iommu_domain *riscv_iommu_domain_alloc_paging_flags( goto err_free; } cfg.common.features |=BIT (PT_FEAT_RISCV_S2 ); +if (iommu->caps &RISCV_IOMMU_CAPABILITIES_AMO_HWAD ) + domain->domain.dirty_ops = &riscv_iommu_dirty_ops;break ;default : ret = -EOPNOTSUPP ;
@@ -1411,9 +1428,13 @@ static struct iommu_group *riscv_iommu_device_group(struct device *dev)static bool riscv_iommu_capable (struct device *dev,enum iommu_cap cap) { +struct riscv_iommu_device *iommu =dev_to_iommu (dev); +switch (cap) {case IOMMU_CAP_CACHE_COHERENCY :return true; +case IOMMU_CAP_DIRTY_TRACKING : +return !!(iommu->caps &RISCV_IOMMU_CAPABILITIES_AMO_HWAD );default :return false; }
Signature · 1 line
2.50.1
RFC PATCH v2 10/10 iommu/riscv: Add IOTINVAL.GVMA after updating DDT/PDT entries
In reply to [email protected]From: Fangyu Yu <[email protected]>
Previously, only IOTINVAL.VMA was issued, which is insufficient for second-stage address translation consistency.
--- drivers/iommu/riscv/iommu.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
drivers/iommu/riscv/iommu.c +6 -3
@@ -1065,12 +1065,15 @@ static void riscv_iommu_iodir_iotinval(struct riscv_iommu_device *iommu,/* * else: IOTINVAL.VMA with GV=1,AV=PSCV=0,and * GSCID=DC.iohgatp.GSCID -* +*/ +riscv_iommu_cmd_send (iommu, &cmd); +/* * IOTINVAL.GVMA with GV=1,AV=0,and * GSCID=DC.iohgatp.GSCID -* TODO: For now, the Second-Stage feature have not yet been merged, -* also issue IOTINVAL.GVMA once second-stage support is merged. */ +riscv_iommu_cmd_inval_gvma (&cmd); +riscv_iommu_cmd_inval_set_gscid (&cmd, +FIELD_GET (RISCV_IOMMU_DC_IOHGATP_GSCID , iohgatp)); }riscv_iommu_cmd_send (iommu, &cmd); }
Signature · 1 line
2.50.1