* [PATCH v2 1/3] RISC-V: KVM: Order writes to the SBI STA shared structure
2026-11-21 17:35 [PATCH v2 0/3] RISC-V: KVM: Lessen steal time update overhead Koichiro Den
@ 2026-11-21 17:35 ` Koichiro Den
2026-11-21 17:35 ` [PATCH v2 2/3] RISC-V: KVM: Batch user accesses when updating steal time Koichiro Den
2026-11-21 17:35 ` [PATCH v2 3/3] RISC-V: KVM: Skip steal-time updates when run_delay is unchanged Koichiro Den
2 siblings, 0 replies; 4+ messages in thread
From: Koichiro Den @ 2026-11-21 17:35 UTC (permalink / raw)
To: Anup Patel, Atish Patra, Andrew Jones
Cc: Paul Walmsley, Palmer Dabbelt, Albert Ou, Alexandre Ghiti,
Bingyu Xian, kvm, kvm-riscv, linux-riscv, linux-kernel
The guest checks the sequence before and after reading steal time. If
the final even sequence becomes visible before the updated steal time,
the guest can accept a stale value. CSR accesses are weakly ordered;
toggling sstatus.SUM in get_user() and put_user() does not guarantee
that the guest observes those stores in order.
Pair the read barriers in pv_time_steal_clock() with write barriers.
Fixes: e9f12b5fff8a ("RISC-V: KVM: Implement SBI STA extension")
Signed-off-by: Koichiro Den <den@valinux.co.jp>
---
Changes since v1:
- New patch. Split the write barriers out of v1 patch #1 into a
separate fix. (Andrew)
arch/riscv/kvm/vcpu_sbi_sta.c | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/arch/riscv/kvm/vcpu_sbi_sta.c b/arch/riscv/kvm/vcpu_sbi_sta.c
index 60e50296a008..f1be90b514b2 100644
--- a/arch/riscv/kvm/vcpu_sbi_sta.c
+++ b/arch/riscv/kvm/vcpu_sbi_sta.c
@@ -9,6 +9,7 @@
#include <linux/mm.h>
#include <linux/sizes.h>
+#include <asm/barrier.h>
#include <asm/bug.h>
#include <asm/current.h>
#include <asm/kvm_vcpu_sbi.h>
@@ -65,6 +66,8 @@ void kvm_riscv_vcpu_record_steal_time(struct kvm_vcpu *vcpu)
if (WARN_ON(put_user(cpu_to_le32(sequence), sequence_ptr)))
return;
+ /* Publish the odd sequence before updating stolen time. */
+ smp_wmb();
if (!WARN_ON(get_user(steal_le, steal_ptr))) {
steal = le64_to_cpu(steal_le);
vcpu->arch.sta.last_steal = READ_ONCE(current->sched_info.run_delay);
@@ -72,6 +75,8 @@ void kvm_riscv_vcpu_record_steal_time(struct kvm_vcpu *vcpu)
WARN_ON(put_user(cpu_to_le64(steal), steal_ptr));
}
+ /* Publish stolen time before the sequence becomes even. */
+ smp_wmb();
sequence += 1;
WARN_ON(put_user(cpu_to_le32(sequence), sequence_ptr));
--
2.54.0
^ permalink raw reply [flat|nested] 4+ messages in thread* [PATCH v2 2/3] RISC-V: KVM: Batch user accesses when updating steal time
2026-11-21 17:35 [PATCH v2 0/3] RISC-V: KVM: Lessen steal time update overhead Koichiro Den
2026-11-21 17:35 ` [PATCH v2 1/3] RISC-V: KVM: Order writes to the SBI STA shared structure Koichiro Den
@ 2026-11-21 17:35 ` Koichiro Den
2026-11-21 17:35 ` [PATCH v2 3/3] RISC-V: KVM: Skip steal-time updates when run_delay is unchanged Koichiro Den
2 siblings, 0 replies; 4+ messages in thread
From: Koichiro Den @ 2026-11-21 17:35 UTC (permalink / raw)
To: Anup Patel, Atish Patra, Andrew Jones
Cc: Paul Walmsley, Palmer Dabbelt, Albert Ou, Alexandre Ghiti,
Bingyu Xian, kvm, kvm-riscv, linux-riscv, linux-kernel
Updating the SBI STA shared structure performs 2x get_user() + 3x
put_user() calls, each of which toggles sstatus.SUM.
Keep SUM enabled across all five accesses to the shared structure.
Signed-off-by: Koichiro Den <den@valinux.co.jp>
---
Changes since v1:
- Drop might_fault(). (Andrew)
- Use scoped_user_rw_access(). (Andrew)
- Use le32_add_cpu() and le64_add_cpu() to avoid the extra temporaries.
Note:
- I haven't carried over Andrew's Reviewed-by since the scoped_
conversion reworks the fault paths. Would appreciate another look.
- As in v1, I kept WARN_ON() for uaccess failures.
v1: https://lore.kernel.org/r/20261118062242.2914385-2-den@valinux.co.jp/
arch/riscv/kvm/vcpu_sbi_sta.c | 60 +++++++++++++++++------------------
1 file changed, 30 insertions(+), 30 deletions(-)
diff --git a/arch/riscv/kvm/vcpu_sbi_sta.c b/arch/riscv/kvm/vcpu_sbi_sta.c
index f1be90b514b2..68d54696dbae 100644
--- a/arch/riscv/kvm/vcpu_sbi_sta.c
+++ b/arch/riscv/kvm/vcpu_sbi_sta.c
@@ -8,6 +8,7 @@
#include <linux/kvm_host.h>
#include <linux/mm.h>
#include <linux/sizes.h>
+#include <linux/uaccess.h>
#include <asm/barrier.h>
#include <asm/bug.h>
@@ -15,7 +16,6 @@
#include <asm/kvm_vcpu_sbi.h>
#include <asm/page.h>
#include <asm/sbi.h>
-#include <asm/uaccess.h>
static void kvm_riscv_vcpu_sbi_sta_reset(struct kvm_vcpu *vcpu)
{
@@ -27,13 +27,9 @@ void kvm_riscv_vcpu_record_steal_time(struct kvm_vcpu *vcpu)
{
gpa_t shmem = vcpu->arch.sta.shmem;
u64 last_steal = vcpu->arch.sta.last_steal;
- __le32 __user *sequence_ptr;
- __le64 __user *steal_ptr;
- __le32 sequence_le;
- __le64 steal_le;
- u32 sequence;
- u64 steal;
+ struct sbi_sta_struct __user *st;
unsigned long hva;
+ bool updated = false;
gfn_t gfn;
if (shmem == INVALID_GPA)
@@ -52,35 +48,39 @@ void kvm_riscv_vcpu_record_steal_time(struct kvm_vcpu *vcpu)
return;
}
- sequence_ptr = (__le32 __user *)(hva + offset_in_page(shmem) +
- offsetof(struct sbi_sta_struct, sequence));
- steal_ptr = (__le64 __user *)(hva + offset_in_page(shmem) +
- offsetof(struct sbi_sta_struct, steal));
+ st = (struct sbi_sta_struct __user *)(hva + offset_in_page(shmem));
+ scoped_user_rw_access(st, no_write) {
+ bool wrote_steal = false;
+ __le32 sequence;
+ __le64 steal;
- if (WARN_ON(get_user(sequence_le, sequence_ptr)))
- return;
-
- sequence = le32_to_cpu(sequence_le);
- sequence += 1;
-
- if (WARN_ON(put_user(cpu_to_le32(sequence), sequence_ptr)))
- return;
+ unsafe_get_user(sequence, &st->sequence, no_write);
+ le32_add_cpu(&sequence, 1);
+ unsafe_put_user(sequence, &st->sequence, no_write);
- /* Publish the odd sequence before updating stolen time. */
- smp_wmb();
- if (!WARN_ON(get_user(steal_le, steal_ptr))) {
- steal = le64_to_cpu(steal_le);
+ /* Publish the odd sequence before updating stolen time. */
+ smp_wmb();
+ unsafe_get_user(steal, &st->steal, finish_update);
vcpu->arch.sta.last_steal = READ_ONCE(current->sched_info.run_delay);
- steal += vcpu->arch.sta.last_steal - last_steal;
- WARN_ON(put_user(cpu_to_le64(steal), steal_ptr));
+ le64_add_cpu(&steal, vcpu->arch.sta.last_steal - last_steal);
+ unsafe_put_user(steal, &st->steal, finish_update);
+ wrote_steal = true;
+
+finish_update:
+ /* Publish stolen time before the sequence becomes even. */
+ smp_wmb();
+ le32_add_cpu(&sequence, 1);
+ unsafe_put_user(sequence, &st->sequence, mark_dirty);
+ updated = wrote_steal;
}
- /* Publish stolen time before the sequence becomes even. */
- smp_wmb();
- sequence += 1;
- WARN_ON(put_user(cpu_to_le32(sequence), sequence_ptr));
-
+mark_dirty:
+ WARN_ON(!updated);
kvm_vcpu_mark_page_dirty(vcpu, gfn);
+ return;
+
+no_write:
+ WARN_ON(1);
}
static int kvm_sbi_sta_steal_time_set_shmem(struct kvm_vcpu *vcpu)
--
2.54.0
^ permalink raw reply [flat|nested] 4+ messages in thread* [PATCH v2 3/3] RISC-V: KVM: Skip steal-time updates when run_delay is unchanged
2026-11-21 17:35 [PATCH v2 0/3] RISC-V: KVM: Lessen steal time update overhead Koichiro Den
2026-11-21 17:35 ` [PATCH v2 1/3] RISC-V: KVM: Order writes to the SBI STA shared structure Koichiro Den
2026-11-21 17:35 ` [PATCH v2 2/3] RISC-V: KVM: Batch user accesses when updating steal time Koichiro Den
@ 2026-11-21 17:35 ` Koichiro Den
2 siblings, 0 replies; 4+ messages in thread
From: Koichiro Den @ 2026-11-21 17:35 UTC (permalink / raw)
To: Anup Patel, Atish Patra, Andrew Jones
Cc: Paul Walmsley, Palmer Dabbelt, Albert Ou, Alexandre Ghiti,
Bingyu Xian, kvm, kvm-riscv, linux-riscv, linux-kernel
Check run_delay against last_steal and skip the update if they match.
This avoids looking up the memslot, accessing the SBI STA shared
structure, and marking its page dirty on vCPU loads with no new steal
time to report.
Reviewed-by: Andrew Jones <andrew.jones@linux.dev>
Signed-off-by: Koichiro Den <den@valinux.co.jp>
---
Changes since v1:
- Check run_delay before looking up the memslot. (Andrew)
v1: https://lore.kernel.org/r/20261118062242.2914385-3-den@valinux.co.jp/
arch/riscv/kvm/vcpu_sbi_sta.c | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/arch/riscv/kvm/vcpu_sbi_sta.c b/arch/riscv/kvm/vcpu_sbi_sta.c
index 68d54696dbae..ebdd1435abd4 100644
--- a/arch/riscv/kvm/vcpu_sbi_sta.c
+++ b/arch/riscv/kvm/vcpu_sbi_sta.c
@@ -30,11 +30,16 @@ void kvm_riscv_vcpu_record_steal_time(struct kvm_vcpu *vcpu)
struct sbi_sta_struct __user *st;
unsigned long hva;
bool updated = false;
+ u64 run_delay;
gfn_t gfn;
if (shmem == INVALID_GPA)
return;
+ run_delay = READ_ONCE(current->sched_info.run_delay);
+ if (run_delay == last_steal)
+ return;
+
/*
* shmem is 64-byte aligned (see the enforcement in
* kvm_sbi_sta_steal_time_set_shmem()) and the size of sbi_sta_struct
@@ -61,7 +66,7 @@ void kvm_riscv_vcpu_record_steal_time(struct kvm_vcpu *vcpu)
/* Publish the odd sequence before updating stolen time. */
smp_wmb();
unsafe_get_user(steal, &st->steal, finish_update);
- vcpu->arch.sta.last_steal = READ_ONCE(current->sched_info.run_delay);
+ vcpu->arch.sta.last_steal = run_delay;
le64_add_cpu(&steal, vcpu->arch.sta.last_steal - last_steal);
unsafe_put_user(steal, &st->steal, finish_update);
wrote_steal = true;
--
2.54.0
^ permalink raw reply [flat|nested] 4+ messages in thread